[OpenMP][NFC] Introduce helper functions to hide casts and such

[tianshilei1992]

openmp/libomptarget/include/Utilities.h

235

Since we have a helper, better to use the ugly C++ style cast.

[jdoerfert]

openmp/libomptarget/include/Utilities.h

235

Will do.

[kevinsala]

openmp/libomptarget/include/Utilities.h

234

Nit.

235

Shouldn't be End - Begin?

247

Not sure if included indirectly somewhere else, but probably this will need #include <memory>.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

135

[jdoerfert]

openmp/libomptarget/include/Utilities.h

235

Yeah, my bad.

247

I'll add it.

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

135

I got the names wrong above, logic is right.

[jdoerfert]

We actually have two of the three already. Will submit the last one cleaned up according to comments.

[jdoerfert]

The existing functions are in the device runtime, so not usable. Addressed comments.

[kevinsala]

LGTM

openmp/libomptarget/include/Utilities.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
 
 #include "Debug.h"
 
 #include <algorithm>
 #include <atomic>
 #include <cassert>
+#include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <functional>
+#include <limits>
+#include <memory>
 #include <sstream>
 #include <string>
 
 namespace llvm {
 namespace omp {
 namespace target {
 
 /// Utility class for parsing strings to other types.
if (const char *EnvStr = getenv(Name.data())) {
     }
   } else {
     Data = Default;
   }
 
   return Error::success();
 }
 
+/// Return the difference (in bytes) between \p Begin and \p End.
+template <typename Ty = char>
+ptrdiff_t getPtrDiff(const void *End, const void *Begin) {
+  return reinterpret_cast<const Ty *>(End) -
+         reinterpret_cast<const Ty *>(Begin);
+}
+
+/// Return \p Ptr advanced by \p Offset bytes.
+template <typename Ty> Ty *advanceVoidPtr(Ty *Ptr, int64_t Offset) {
+  static_assert(std::is_void<Ty>::value);
+  return const_cast<char *>(reinterpret_cast<const char *>(Ptr) + Offset);
+}
+
+/// Return \p Ptr aligned to \p Alignment bytes.
+template <typename Ty> Ty *alignPtr(Ty *Ptr, int64_t Alignment) {
+  size_t Space = std::numeric_limits<size_t>::max();
+  return std::align(Alignment, sizeof(char), Ptr, Space);
+}
+
 } // namespace target
 } // namespace omp
 } // namespace llvm
 
 #endif // OPENMP_LIBOMPTARGET_INCLUDE_UTILITIES_H

openmp/libomptarget/plugins-nextgen/amdgpu/src/rtl.cpp

 private:
   /// Extract the global's information from the ELF image, section, and symbol.
   Error getGlobalMetadataFromELF(const DeviceImageTy &Image,
                                  const ELF64LE::Sym &Symbol,
                                  const ELF64LE::Shdr &Section,
                                  GlobalTy &ImageGlobal) override {
     // The global's address in AMDGPU is computed as the image begin + the ELF
     // symbol value. Notice we do not add the ELF section offset.
-    ImageGlobal.setPtr((char *)Image.getStart() + Symbol.st_value);
+    ImageGlobal.setPtr(advanceVoidPtr(Image.getStart(), Symbol.st_value));
 
     // Set the global's size.
     ImageGlobal.setSize(Symbol.st_size);
 
     return Plugin::success();
   }
 };
 
Error AMDGPUKernelTy::launchImpl(GenericDeviceTy &GenericDevice,
 
   void *AllArgs = nullptr;
   if (auto Err = ArgsMemoryManager.allocate(AllArgsSize, &AllArgs))
     return Err;
 
   // Initialize implicit arguments.
   utils::AMDGPUImplicitArgsTy *ImplArgs =
       reinterpret_cast<utils::AMDGPUImplicitArgsTy *>(
-          static_cast<char *>(AllArgs) + KernelArgsSize);
+          advanceVoidPtr(AllArgs, KernelArgsSize));
 
   // Initialize the implicit arguments to zero.
   std::memset(ImplArgs, 0, ImplicitArgsSize);
 
   // Copy the explicit arguments.
   // TODO: We should expose the args memory manager alloc to the common part as
   //     alternative to copying them twice.
   if (NumKernelArgs)

openmp/libomptarget/plugins-nextgen/common/PluginInterface/GlobalHandler.cpp

 //===- GlobalHandler.cpp - Target independent global & env. var handling --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Target independent global handler and environment manager.
 //
 //===----------------------------------------------------------------------===//
 
 #include "GlobalHandler.h"
 #include "ELFSymbols.h"
 #include "PluginInterface.h"
+#include "Utilities.h"
 
 #include <cstring>
 
 using namespace llvm;
 using namespace omp;
 using namespace target;
 using namespace plugin;
 

 }
 
 Error GenericGlobalHandlerTy::getGlobalMetadataFromELF(
     const DeviceImageTy &Image, const ELF64LE::Sym &Symbol,
     const ELF64LE::Shdr &Section, GlobalTy &ImageGlobal) {
 
   // The global's address is computed as the image begin + the ELF section
   // offset + the ELF symbol value.
-  ImageGlobal.setPtr((char *)Image.getStart() + Section.sh_offset +
-                     Symbol.st_value);
+  ImageGlobal.setPtr(
+      advanceVoidPtr(Image.getStart(), Section.sh_offset + Symbol.st_value));
 
   // Set the global's size.
   ImageGlobal.setSize(Symbol.st_size);
 
   return Plugin::success();
 }
 
 Error GenericGlobalHandlerTy::moveGlobalBetweenDeviceAndHost(

openmp/libomptarget/plugins-nextgen/common/PluginInterface/JIT.cpp

createModuleFromMemoryBuffer(std::unique_ptr<MemoryBuffer> &MB,
   if (!Mod)
     return make_error<StringError>("Failed to create module",
                                    inconvertibleErrorCode());
   return std::move(Mod);
 }
 Expected<std::unique_ptr<Module>>
 createModuleFromImage(__tgt_device_image *Image, LLVMContext &Context) {
   StringRef Data((const char *)Image->ImageStart,
-                 (char *)Image->ImageEnd - (char *)Image->ImageStart);
+                 target::getPtrDiff(Image->ImageEnd, Image->ImageStart));
   std::unique_ptr<MemoryBuffer> MB = MemoryBuffer::getMemBuffer(
       Data, /* BufferName */ "", /* RequiresNullTerminator */ false);
   return createModuleFromMemoryBuffer(MB, Context);
 }
 
 CodeGenOpt::Level getCGOptLevel(unsigned OptLevel) {
   switch (OptLevel) {
   case 0:
bool checkBitcodeImage(__tgt_device_image *Image, Triple::ArchType TA) {
 
   {
     auto Itr = BitcodeImageMap.find(Image->ImageStart);
     if (Itr != BitcodeImageMap.end() && Itr->second == TA)
       return true;
   }
 
   StringRef Data(reinterpret_cast<const char *>(Image->ImageStart),
-                 reinterpret_cast<char *>(Image->ImageEnd) -
-                     reinterpret_cast<char *>(Image->ImageStart));
+                 target::getPtrDiff(Image->ImageEnd, Image->ImageStart));
   std::unique_ptr<MemoryBuffer> MB = MemoryBuffer::getMemBuffer(
       Data, /* BufferName */ "", /* RequiresNullTerminator */ false);
   if (!MB)
     return false;
 
   Expected<object::IRSymtabFile> FOrErr = object::readIRSymtab(*MB);
   if (!FOrErr) {
     consumeError(FOrErr.takeError());

openmp/libomptarget/plugins-nextgen/common/PluginInterface/PluginInterface.h

public:
   /// Get the pointer to the raw __tgt_device_image.
   const __tgt_device_image *getTgtImage() const { return TgtImage; }
 
   /// Get the image starting address.
   void *getStart() const { return TgtImage->ImageStart; }
 
   /// Get the image size.
   size_t getSize() const {
-    return ((char *)TgtImage->ImageEnd) - ((char *)TgtImage->ImageStart);
+    return getPtrDiff(TgtImage->ImageEnd, TgtImage->ImageStart);
   }
 
   /// Get a memory buffer reference to the whole image.
   MemoryBufferRef getMemoryBuffer() const {
     return MemoryBufferRef(StringRef((const char *)getStart(), getSize()),
                            "Image");
   }
 
bool isHostPinnedMemoryBuffer(const void *Buffer) const {
     // allocation.
     if (It == HostAllocations.begin())
       return false;
 
     // Move to the previous pinned allocation.
     --It;
 
     // Evaluate whether the buffer is contained in the pinned allocation.
-    return ((const char *)It->first + It->second > (const char *)Buffer);
+    return (advanceVoidPtr(It->first, It->second) > (const char *)Buffer);
   }
 
   /// Return the execution mode used for kernel \p Name.
   Expected<OMPTgtExecModeFlags> getExecutionModeForKernel(StringRef Name,
                                                           DeviceImageTy &Image);
 
   /// Environment variables defined by the LLVM OpenMP implementation
   /// regarding the initial number of streams and events.