[OpenMP] Use Undef instead of null as pointer for inactive lanes

[jdoerfert]

Summary

Our conditional writes in the runtime look like this:

if (active)
  *ptr = value;

In the RAII we need to assign ptr which comes from a lookup call.
If a thread that is not the main thread calls lookup with the intention
to write the pointer, we'll create a new thread state. As such, we need
to avoid calling lookup for inactive threads. We used to use nullptr
as their ptr value but that can cause pessimistic reasoning. We now
use undef instead.

[jhuber6]

LG

openmp/libomptarget/DeviceRTL/include/State.h

Ty &set(Ty UpdateVal) {
     return (lookup(/* IsReadonly */ false, /* IdentTy */ nullptr) = UpdateVal);
   }
 
   template <typename VTy, typename Ty2> friend struct ValueRAII;
 };
 
 template <typename VTy, typename Ty> struct ValueRAII {
   ValueRAII(VTy &V, Ty NewValue, Ty OldValue, bool Active, IdentTy *Ident)
-      : Ptr(Active ? &V.lookup(/* IsReadonly */ false, Ident) : nullptr),
+      : Ptr(Active ? &V.lookup(/* IsReadonly */ false, Ident)
+                   : (Ty *)utils::UndefPtr),
         Val(OldValue), Active(Active) {
     if (!Active)
       return;
     ASSERT(*Ptr == OldValue &&
            "ValueRAII initialization with wrong old value!");
     *Ptr = NewValue;
   }
   ~ValueRAII() {

openmp/libomptarget/DeviceRTL/include/Utils.h

 //===--------- Utils.h - OpenMP device runtime utility functions -- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef OMPTARGET_DEVICERTL_UTILS_H
 #define OMPTARGET_DEVICERTL_UTILS_H
 
 #include "Types.h"
 
+#pragma omp begin declare target device_type(nohost)
+
 namespace _OMP {
 namespace utils {
 
 /// Return the value \p Var from thread Id \p SrcLane in the warp if the thread
 /// is identified by \p Mask.
 int32_t shuffle(uint64_t Mask, int32_t Var, int32_t SrcLane);
 
 int32_t shuffleDown(uint64_t Mask, int32_t Var, uint32_t Delta, int32_t Width);

 template <typename Ty1, typename Ty2> inline Ty1 align_up(Ty1 V, Ty2 Align) {
   return ((V + Ty1(Align) - 1) / Ty1(Align)) * Ty1(Align);
 }
 /// Return \p V aligned "downwards" according to \p Align.
 template <typename Ty1, typename Ty2> inline Ty1 align_down(Ty1 V, Ty2 Align) {
   return V - V % Align;
 }
 
+/// A  pointer variable that has by design an `undef` value. Use with care.
+__attribute__((loader_uninitialized)) static void *const UndefPtr;
+
 #define OMP_LIKELY(EXPR) __builtin_expect((bool)(EXPR), true)
 #define OMP_UNLIKELY(EXPR) __builtin_expect((bool)(EXPR), false)
 
 } // namespace utils
 } // namespace _OMP
 
+#pragma omp end declare target
+
 #endif