[OpenMP][OMPIRBuilder]Move SIMD alignment calculation to LLVM Frontend

[domada]

Summary

Currently default simd alignment is defined by Clang specific TargetInfo class. This class cannot be reused for LLVM Flang. That's why default simd alignment calculation has been moved to OMPIRBuilder which is common for Flang and Clang.

Previous attempt: https://reviews.llvm.org/D138496 was wrong because the default alignment depended on the number of built LLVM targets.

If we wanted to calculate the default alignment for PPC and we hadn't specified PPC LLVM target to build, then we would get 0 as the alignment because OMPIRBuilder couldn't create PPCTargetMachine object and it returned 0 as the default value. If PPC LLVM target had been built earlier, then OMPIRBuilder could have created PPCTargetMachine object and it would have returned 128.

[jsjodin]

This looks good to me. Have @jdoerfert approve as well.

[jdoerfert]

LG

[akyrtzi]

Hi @domada, these changes break compilation of clang, with such build error:

FAILED: tools/clang/lib/AST/CMakeFiles/obj.clangAST.dir/ASTContext.cpp.o 
<clang invocation>
In file included from /llvm-project/clang/lib/AST/ASTContext.cpp:81:
In file included from /llvm-project/llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h:17:
In file included from /llvm-project/llvm/include/llvm/Analysis/MemorySSAUpdater.h:37:
In file included from /llvm-project/llvm/include/llvm/Analysis/MemorySSA.h:93:
In file included from /llvm-project/llvm/include/llvm/Analysis/AliasAnalysis.h:44:
In file included from /llvm-project/llvm/include/llvm/IR/PassManager.h:45:
In file included from /llvm-project/llvm/include/llvm/IR/Function.h:25:
In file included from /llvm-project/llvm/include/llvm/IR/Argument.h:17:
/llvm-project/llvm/include/llvm/IR/Attributes.h:90:14: fatal error: 'llvm/IR/Attributes.inc' file not found

Reproduction steps:

1. Configure to build clang using ninja:

cmake -G Ninja /path/to/llvm-project/llvm \
  -DLLVM_TARGETS_TO_BUILD="X86;ARM;AArch64" \
  -DCMAKE_BUILD_TYPE:STRING=Release \
  -DLLVM_ENABLE_PROJECTS="clang"

2. Build ASTContext.cpp.o with a clean build directory.

ninja clean && ninja tools/clang/lib/AST/CMakeFiles/obj.clangAST.dir/ASTContext.cpp.o

Are you able to take a look? 🙏

[akyrtzi]

I've reverted this change from main branch, let me know if there's anything I can do to help with addressing the build issue.

[domada]

Added changes in clang/lib/AST/CMakeLists.txt to address build issue reported by @akyrtzi .

I modified CMakeLists.txt so that it requires generation of missing Attributes.inc.

@akyrtzi Please let me know if it solves your issue

[domada]

Patch rebased

[akyrtzi]

In D141910#4111048, @domada wrote:

Added changes in clang/lib/AST/CMakeLists.txt to address build issue reported by @akyrtzi .

I modified CMakeLists.txt so that it requires generation of missing Attributes.inc.

@akyrtzi Please let me know if it solves your issue

This fixes the build issue 👍, thank you!

[domada]

@akyrtzi Thank you for your feedback. Can I land the patch?

[tschuett]

For AArch64 the default alignment is 0? I would have expected 128.

[domada]

In D141910#4112164, @tschuett wrote:

For AArch64 the default alignment is 0? I would have expected 128.

The refactored function TargetInfo::getSimdDefaultAlign is used only for calculation of default alignment for #pragma omp simd aligned(A). If user does not specify any alignment in OpenMP simd pragma, then we will assume that the alignment of A is equal to 128 for PPC, WebAssembly or for some X86 targets and we insert proper assumptions into LLVM IR (please refer to: clang test for more details. For other targets like AArch64 we don't insert any assumptions into LLVM IR code.

I just refactored the code and I return the same values as previous function.

[akyrtzi]

In D141910#4112144, @domada wrote:

@akyrtzi Thank you for your feedback. Can I land the patch?

Fine be me.

[kiranchandramohan]

LG.

clang/include/clang/Basic/TargetInfo.h

protected:
   bool HasFloat16;
   bool HasBFloat16;
   bool HasIbm128;
   bool HasLongDouble;
   bool HasFPReturn;
   bool HasStrictFP;
 
   unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
-  unsigned short SimdDefaultAlign;
   std::string DataLayoutString;
   const char *UserLabelPrefix;
   const char *MCountName;
   unsigned char RegParmMax, SSERegParmMax;
   TargetCXXABI TheCXXABI;
   const LangASMap *AddrSpaceMap;
 
   mutable StringRef PlatformName;
virtual bool hasBuiltinAtomic(uint64_t AtomicSizeInBits,
     return AtomicSizeInBits <= AlignmentInBits &&
            AtomicSizeInBits <= getMaxAtomicInlineWidth() &&
            (AtomicSizeInBits <= getCharWidth() ||
             llvm::isPowerOf2_64(AtomicSizeInBits / getCharWidth()));
   }
 
   /// Return the maximum vector alignment supported for the given target.
   unsigned getMaxVectorAlign() const { return MaxVectorAlign; }
-  /// Return default simd alignment for the given target. Generally, this
-  /// value is type-specific, but this alignment can be used for most of the
-  /// types for the given target.
-  unsigned getSimdDefaultAlign() const { return SimdDefaultAlign; }
 
   unsigned getMaxOpenCLWorkGroupSize() const { return MaxOpenCLWorkGroupSize; }
 
   /// Return the alignment (in bits) of the thrown exception object. This is
   /// only meaningful for targets that allocate C++ exceptions in a system
   /// runtime, such as those using the Itanium C++ ABI.
   virtual unsigned getExnObjectAlignment() const {
     // Itanium says that an _Unwind_Exception has to be "double-word"

clang/lib/AST/ASTContext.cpp

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
 #include "llvm/Support/Capacity.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TargetParser/Triple.h"
if (const auto *RT = T->getAs<RecordType>()) {
     UnadjustedAlign = getTypeAlign(T->getUnqualifiedDesugaredType());
   }
 
   MemoizedUnadjustedAlign[T] = UnadjustedAlign;
   return UnadjustedAlign;
 }
 
 unsigned ASTContext::getOpenMPDefaultSimdAlign(QualType T) const {
-  unsigned SimdAlign = getTargetInfo().getSimdDefaultAlign();
+  unsigned SimdAlign = llvm::OpenMPIRBuilder::getOpenMPDefaultSimdAlign(
+      getTargetInfo().getTriple(), Target->getTargetOpts().FeatureMap);
   return SimdAlign;
 }
 
 /// toCharUnitsFromBits - Convert a size in bits to a size in characters.
 CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
   return CharUnits::fromQuantity(BitSize / getCharWidth());
 }
 

clang/lib/AST/CMakeLists.txt

add_clang_library(clangAST
   LINK_LIBS
   clangBasic
   clangLex
 
   DEPENDS
   ClangAttrDocTable
   Opcodes
   omp_gen
+  intrinsics_gen
   )

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
   LongDoubleAlign = 64;
   Float128Align = 128;
   Ibm128Align = 128;
   LargeArrayMinWidth = 0;
   LargeArrayAlign = 0;
   MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
   MaxVectorAlign = 0;
   MaxTLSAlign = 0;
-  SimdDefaultAlign = 0;
   SizeType = UnsignedLong;
   PtrDiffType = SignedLong;
   IntMaxType = SignedLongLong;
   IntPtrType = SignedLong;
   WCharType = SignedInt;
   WIntType = SignedInt;
   Char16Type = UnsignedShort;
   Char32Type = UnsignedInt;

clang/lib/Basic/Targets/PPC.h

 
 protected:
   std::string ABI;
 
 public:
   PPCTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
     SuitableAlign = 128;
-    SimdDefaultAlign = 128;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
     HasStrictFP = true;
     HasIbm128 = true;
   }
 
   // Set the language option for altivec based on our value.
   void adjust(DiagnosticsEngine &Diags, LangOptions &Opts) override;

clang/lib/Basic/Targets/WebAssembly.h

 
 public:
   explicit WebAssemblyTargetInfo(const llvm::Triple &T, const TargetOptions &)
       : TargetInfo(T) {
     NoAsmVariants = true;
     SuitableAlign = 128;
     LargeArrayMinWidth = 128;
     LargeArrayAlign = 128;
-    SimdDefaultAlign = 128;
     SigAtomicType = SignedLong;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
     // size_t being unsigned long for both wasm32 and wasm64 makes mangled names
     // more consistent between the two.
     SizeType = UnsignedLong;
     PtrDiffType = SignedLong;

clang/lib/Basic/Targets/X86.cpp

bool X86TargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
   // matches the selected sse level.
   if ((FPMath == FP_SSE && SSELevel < SSE1) ||
       (FPMath == FP_387 && SSELevel >= SSE1)) {
     Diags.Report(diag::err_target_unsupported_fpmath)
         << (FPMath == FP_SSE ? "sse" : "387");
     return false;
   }
 
-  SimdDefaultAlign =
-      hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
-
   // FIXME: We should allow long double type on 32-bits to match with GCC.
   // This requires backend to be able to lower f80 without x87 first.
   if (!HasX87 && LongDoubleFormat == &llvm::APFloat::x87DoubleExtended())
     HasLongDouble = false;
 
   return true;
 }
 

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

ClangExpressionParser::ClangExpressionParser(
   m_compiler->createDiagnostics();
   // Limit the number of error diagnostics we emit.
   // A value of 0 means no limit for both LLDB and Clang.
   m_compiler->getDiagnostics().setErrorLimit(target_sp->GetExprErrorLimit());
 
   auto target_info = TargetInfo::CreateTargetInfo(
       m_compiler->getDiagnostics(), m_compiler->getInvocation().TargetOpts);
   if (log) {
-    LLDB_LOGF(log, "Using SIMD alignment: %d",
-              target_info->getSimdDefaultAlign());
     LLDB_LOGF(log, "Target datalayout string: '%s'",
               target_info->getDataLayoutString());
     LLDB_LOGF(log, "Target ABI: '%s'", target_info->getABI().str().c_str());
     LLDB_LOGF(log, "Target vector alignment: %d",
               target_info->getMaxVectorAlign());
   }
   m_compiler->setTarget(target_info);
 

llvm/include/llvm/Frontend/OpenMP/OMPIRBuilder.h

public:
   ///                  trip count. If not set, defaults to before the generated
   ///                  loop.
   ///
   /// \returns The CanonicalLoopInfo object representing the collapsed loop.
   CanonicalLoopInfo *collapseLoops(DebugLoc DL,
                                    ArrayRef<CanonicalLoopInfo *> Loops,
                                    InsertPointTy ComputeIP);
 
+  /// Get the default alignment value for given target
+  ///
+  /// \param TargetTriple   Target triple
+  /// \param Features       StringMap which describes extra CPU features
+  static unsigned getOpenMPDefaultSimdAlign(const Triple &TargetTriple,
+                                            const StringMap<bool> &Features);
+
 private:
   /// Modifies the canonical loop to be a statically-scheduled workshare loop.
   ///
   /// This takes a \p LoopInfo representing a canonical loop, such as the one
   /// created by \p createCanonicalLoop and emits additional instructions to
   /// turn it into a workshare loop. In particular, it calls to an OpenMP
   /// runtime function in the preheader to obtain the loop bounds to be used in
   /// the current thread, updates the relevant instructions in the canonical

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

for (BasicBlock *Block : L->getBlocks()) {
     NewBB->moveBefore(CanonicalLoop->getExit());
     VMap[Block] = NewBB;
     NewBlocks.push_back(NewBB);
   }
   remapInstructionsInBlocks(NewBlocks, VMap);
   Builder.CreateBr(NewBlocks.front());
 }
 
+unsigned
+OpenMPIRBuilder::getOpenMPDefaultSimdAlign(const Triple &TargetTriple,
+                                           const StringMap<bool> &Features) {
+  if (TargetTriple.isX86()) {
+    if (Features.lookup("avx512f"))
+      return 512;
+    else if (Features.lookup("avx"))
+      return 256;
+    return 128;
+  }
+  if (TargetTriple.isPPC())
+    return 128;
+  if (TargetTriple.isWasm())
+    return 128;
+  return 0;
+}
+
 void OpenMPIRBuilder::applySimd(CanonicalLoopInfo *CanonicalLoop,
                                 MapVector<Value *, Value *> AlignedVars,
                                 Value *IfCond, OrderKind Order,
                                 ConstantInt *Simdlen, ConstantInt *Safelen) {
   LLVMContext &Ctx = Builder.getContext();
 
   Function *F = CanonicalLoop->getFunction();