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

[domada]

Summary

Currently default simd alignment is specified by Clang specific TargetInfo class. This class cannot be reused for LLVM Flang. If we move the default alignment field into TargetMachine class then we can create TargetMachine objects and query them to find SIMD alignment.

Scope of changes:

1. Added information about maximal allowed SIMD alignment to TargetMachine classes.
2. Added TargetMachineCache to store created TargetMachine items and query them to find the alignment
3. Removed getSimdDefaultAlign function from TargetInfo class.

[jsjodin]

Looking at the existing code before the patch:
  / 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; }
It is very imprecise. Which types? The smallest alignment for all vector and element types?.

If we are moving this to LLVM, can we use the data layout to infer what the default alignment is? Hopefully we can figure out what the criteria are and make the function work for any target, or maybe error out if it doesn't apply.

[jdoerfert]

The idea is good, we should properly ask the target. That said, don't we need to also provide the type?

clang/lib/AST/ASTContext.cpp

2476

Why .str() ?

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

504

Documentation please.

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

3092

3100

No llvm:: this is llvm. Do we really want to create a target machine every time? Are the features different? Can we cache the machine or is it cheap to create?

[domada]

Yes, we can extend calculations of the default alignment. My primary goal was to move code from clang into llvm without modification of the code logic.

AFAIK the default simd alignment corresponds to the maximal width of the simd instruction for given target.

[jsjodin]

In D138496#3944348, @domada wrote:

Yes, we can extend calculations of the default alignment. My primary goal was to move code from clang into llvm without modification of the code logic.

AFAIK the default simd alignment corresponds to the maximal width of the simd instruction for given target.

So maybe the function should be called getMaximumVectorTypeAlignment or something like that, and query the target with some relevant types to find the maximum, alternatively implement this at a lower level inside DataLayout, and not have to provide a type.

[jmmartinez]

clang/lib/AST/ASTContext.cpp

2468–2477

Here you're copying the entire TargetFeatures vector. Could you use a const & ?

[domada]

1. Refactored OMPIRBuilder method which calculates SIMD alignment. Added optional parameter Type *AlignedValueTy which can be used to define optimal alignment. If this parameter is not specified then, we return the maximal SIMD alignment for given target.
2. Clang still uses suboptimal value because there is no link between clang TargetInfo and LLVM-Type. More information about this decision can be found in previous review which introduced original getSimdDefaultAlign function: https://reviews.llvm.org/D10597?id=28205#inline-85925
3. TargetInfo class contains method: getMaxVectorAlign . This method returns maximal vector alignment for given target. The only difference between original: getMaxVectorAlign and getSimdDefaultAlign is that getSimdDefaultAlign returns 0 alignment for ARM target. I don't know if it is ok, that we assume 0 alignment for ARM targets.
4. Removed getSimdDefaultAlign function.

[domada]

clang/lib/AST/ASTContext.cpp

2476

Because createTargetMachine function requires target triple as the string.

[jsjodin]

If we implemented DataLayout::getMaxPreferredVectorTypeAlign something like this:

Align DataLayout::getMaxPreferredVectorTypeAlign() {
  Align max(1);
  for (auto &E : Alignments)
    if (E.AlignType == VECTOR_ALIGN && E.PrefAlign > max)
      max = E.PrefAlign;
  return max;
}

Then we could find the maximum vector type alignment, This would return Align(1) by default.
In the current implementation we return 0 by default, minimum alignment should reasonably be 1 by default, unless 0 means "unknown"?

[jdoerfert]

FWIW, align 1 and 0 should be the same and both are trivial.

[domada]

@jsjodin thanks for your remark. Let me add some more information to this patch.

Currently clang emits information about preferred simd alignment only for X86, WebAssembly and PPC targets.

If we generate code for one of these targets then we expand #pragma omp simd aligned(aligned_var) into call void @llvm.assume(i1 true) [ "align"(ptr aligned_var, i64 alignment_size) ] LLVM IR instruction . For other architectures (for example ARM) simd alignment is always set to 0 and the alignment assumption is not generated. I am not sure if it is ok, that we do not generate alignment assumptions for other architectures. That's why I raised this question during the last Flang-OpenMP meetings and I did not receive a clear answer.

Your code looks elegant but in my opinion it will generate different code for ARM architecture where the vector alignment is set to 64 ( https://github.com/llvm-mirror/clang/blob/master/lib/Basic/Targets/ARM.cpp#L311 ), but simd default alignment is set to 0.

[jsjodin]

In D138496#3970344, @domada wrote:

@jsjodin thanks for your remark. Let me add some more information to this patch.

Currently clang emits information about preferred simd alignment only for X86, WebAssembly and PPC targets.

[snip]

Your code looks elegant but in my opinion it will generate different code for ARM architecture where the vector alignment is set to 64 ( https://github.com/llvm-mirror/clang/blob/master/lib/Basic/Targets/ARM.cpp#L311 ), but simd default alignment is set to 0.

I wasn't exactly proposing to eliminate the TargetMachine function. We would need a default implementation in that returns 0, and override it in X86, WebAssembly and PPC to call the DataLayout function. The only difference is that we don't re-encode the sizes. It will only make a difference in the future e.g. if newer x86 targets have larger max alignment.

[domada]

I think we cannot not rely on DataLayout to find the maximal SIMD alignment.

Developer can specify that given functions are targeted to different subtargets (source: https://clang.llvm.org/docs/AttributeReference.html#target ). That's why information about target subtype is stored in function attribute not in the data layout string which is common for the whole Module.

[jdoerfert]

In D138496#3984775, @domada wrote:

I think we cannot not rely on DataLayout to find the maximal SIMD alignment.

Developer can specify that given functions are targeted to different subtargets (source: https://clang.llvm.org/docs/AttributeReference.html#target ). That's why information about target subtype is stored in function attribute not in the data layout string which is common for the whole Module.

The subtarget can only "improve" our information, right? We need to involve the target, provide it with the type, the datalayout, and the function attributes to make a decision. No?

[domada]

Hi Johannes,
I was referring to Jan's idea. He proposes to move part of the functionality to the DataLayout class. IMO this option is not the best approach, because DataLayout object does not contain information about subtarget and we cannot determine if SIMD extensions (avx options) are enabled.

My current patch uses information about subtarget and type of the aligned value to determine the default alignment. If the type of the aligned value is provided I ask DataLayout about preferred alignment (OMPIRBuilder.cpp line 3113).. If this information is not provided I base only on subtarget information.

[jdoerfert]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

3096

No static variables here, please.
These should be members of the class or a helper class.
Should we have a map of these to the respective TargetMachine?

[domada]

Applied review remarks.

Scope of changes:

1. Removed static function for finding the default alignment from OMPIRBuilder
2. Added new helper class for storing cached TargetMachine objects

[domada]

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

3096

I added a new helper class TargetMachineCache for storing TargetMachine items.

Please let me know if it is ok, that this class is located in OMPContext.h.

Storing TargetMachine objects required modification of ASTContext class.

[jdoerfert]

I think this is fine, with two nits. @jsjodin Please finish the review as you see fit.

clang/include/clang/AST/ASTContext.h

460 ↗

(On Diff #483157)

Move it into the OpenMPIRBuilder please.

llvm/lib/Frontend/OpenMP/OMPContext.cpp

587 ↗

(On Diff #483157)

You lookup Key in Targets 3 times. Maybe we can reduce that a little. Can the pointer ever be nullptr (the one returned by createTargetMachine?

[domada]

clang/include/clang/AST/ASTContext.h

460 ↗

(On Diff #483157)

We cannot move it into the OpenMPIRBuilder because OpenMPIRBuilder is not created inside ASTContext. OpenMPIRBuilder is created inside clang LLVM IR codegen part (clang/lib/CodeGen/CGOpenMPRuntime) and I prefer not to modify this part.

That's why I initially proposed static function inside OpenMPIRBuilder. I think that we need to choose one option:

• Less efficient static function inside OpenMPIRBuilder which creates TargetMachine items every time (advantage: no binding to LLVM objects inside clang ASTContext)
• TargetMachineCache object inside ASTContext and more efficient function for default alignment calculation

Personally I opt for the first option. IMO OpenMP pragma: omp simd aligned(A) is not very common and we can spend more time to determine the default alignment.

[domada]

llvm/lib/Frontend/OpenMP/OMPContext.cpp

587 ↗

(On Diff #483157)

createTargetMachine can return nullptr. Test scenario:

1. build clang without support of one target arch (for example build only x86 target: `cmake "-DLLVM_TARGETS_TO_BUILD="X86;")
2. try to generate LLVM IR and specify target which hasn't been mentioned in cmake configuration: (for example: clang --target=arm -S -emit-llvm -fopenmp test.c)

We can reduce number of lookups in the best scenario (given Key has been inserted earlier):

// find the corresponding target
 auto  TargetsIter = Targets.find(Key);
//if not found - insert it and update TargetsIter 
if (TargetsIter==Targets.end()) {
    // some initialization code
   Targets[Key] = TheTarget->createTargetMachine(..);
   TargetsIter = Targets.find(Key);
}
//check if TargetMachine is not nullptr:
if (!TargetsIter->getValue())
   return 0;

[jsjodin]

llvm/include/llvm/Frontend/OpenMP/OMPContext.h

233 ↗

(On Diff #483157)

We can remove the AlignedValueTy parameter since it is not used and we determined that the DataLayout in the module is incomplete anyway.

[jsjodin]

llvm/include/llvm/Target/TargetMachine.h

212

This will be clearer if we put OpenMP in the function name as well getOpenMPMaximalSimdAlignment or something like that.

[domada]

Scope of changes:

1. Refactored createTargetMachine function.

Reuse existing code.

2. Removed caching.

The existing comment about caching in createTargetMachine clearly indicates implementation obstacles. In my opinion we are allowed to create TargetMachine objects on demand because simd aligned pragma with default alignment is used rarely (very few usage in OpenMP benchmarks).

[domada]

Rename OMPIRBuilder function to query SIMD alignment

[jsjodin]

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/Optional.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/ADT/Triple.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 <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <map>
 #include <memory>
+#include <numeric>
 #include <optional>
 #include <string>
 #include <tuple>
 #include <utility>
 
 using namespace clang;
 
 enum FloatingRank {
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();
+  const std::vector<std::string> &TargetFeatures =
+      Target->getTargetOpts().Features;
+  std::string TargetFeaturesString = std::accumulate(
+      TargetFeatures.cbegin(), TargetFeatures.cend(), std::string(),
+      [](const std::string &s1, const std::string &s2) {
+        return s1.empty() ? s2 : s1 + "," + s2;
+      });
+  unsigned SimdAlign = llvm::OpenMPIRBuilder ::getSimdDefaultAlignment(
+      getTargetInfo().getTriple().str(), Target->getTargetOpts().CPU,
+      TargetFeaturesString);
   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/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:
   /// \param ComputeIP Where additional instruction that compute the collapsed
   ///                  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 alignment value for given target
+  ///
+  /// \param Triple         String which describes target triple
+  /// \param CPU            String which describes target CPU
+  /// \param Features       String which describes extra CPU features
+  static unsigned getSimdDefaultAlignment(const std::string &Triple,
+                                          StringRef CPU, StringRef 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/include/llvm/Target/TargetMachine.h

protected: // Can only create subclasses.
   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
 
   /// Contains target specific asm information.
   std::unique_ptr<const MCAsmInfo> AsmInfo;
   std::unique_ptr<const MCRegisterInfo> MRI;
   std::unique_ptr<const MCInstrInfo> MII;
   std::unique_ptr<const MCSubtargetInfo> STI;
 
+  /// Simd target specific information
+  unsigned SimdDefaultAlignment = 0;
+
   unsigned RequireStructuredCFG : 1;
   unsigned O0WantsFastISel : 1;
 
   // PGO related tunables.
   std::optional<PGOOptions> PGOOption;
 
 public:
   const TargetOptions DefaultOptions;
public:
   unsigned getProgramPointerSize() const {
     return DL.getPointerSize(DL.getProgramAddressSpace());
   }
 
   unsigned getAllocaPointerSize() const {
     return DL.getPointerSize(DL.getAllocaAddrSpace());
   }
 
+  /// Return default SIMD alignment
+  unsigned getSimdDefaultAlignment() const { return SimdDefaultAlignment; }
+
   /// Reset the target options based on the function's attributes.
   // FIXME: Remove TargetOptions that affect per-function code generation
   // from TargetMachine.
   void resetTargetOptions(const Function &F) const;
 
   /// Return target specific asm information.
   const MCAsmInfo *getMCAsmInfo() const { return AsmInfo.get(); }
 

llvm/lib/Frontend/OpenMP/OMPIRBuilder.cpp

if (Instruction *Term = Source->getTerminator()) {
     Br->setSuccessor(0, Target);
     return;
   }
 
   auto *NewBr = BranchInst::Create(Target, Source);
   NewBr->setDebugLoc(DL);
 }
 
+/// Create the TargetMachine object to query the backend for optimization
+/// preferences.
+///
+/// Ideally, this would be passed from the front-end to the OpenMPBuilder, but
+/// e.g. Clang does not pass it to its CodeGen layer and creates it only when
+/// needed for the LLVM pass pipline. We use some default options to avoid
+/// having to pass too many settings from the frontend that probably do not
+/// matter.
+///
+/// Currently, TargetMachine is only used sometimes by the unrollLoopPartial
+/// and getVectorTypeAlignment methods. If we are going to use TargetMachine
+/// for more purposes, especially those that are sensitive to TargetOptions,
+/// RelocModel and CodeModel, it might become be worth requiring front-ends to
+/// pass on their TargetMachine, or at least cache it between methods.
+/// Note that while fontends such as Clang have just a single main
+/// TargetMachine per translation unit, "target-cpu" and "target-features"
+/// that determine the TargetMachine are per-function and can be overrided
+/// using __attribute__((target("OPTIONS"))).
+static std::unique_ptr<TargetMachine>
+createTargetMachine(const std::string &Triple, StringRef CPU,
+                    StringRef Features, CodeGenOpt::Level OptLevel) {
+  std::string Error;
+  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
+  if (!TheTarget)
+    return {};
+
+  llvm::TargetOptions Options;
+  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
+      Triple, CPU, Features, Options, /*RelocModel=*/std::nullopt,
+      /*CodeModel=*/std::nullopt, OptLevel));
+}
+
+/// Create the TargetMachine object to query the backend for optimization
+/// preferences.
+static std::unique_ptr<TargetMachine>
+createTargetMachine(Function *F, CodeGenOpt::Level OptLevel) {
+  Module *M = F->getParent();
+
+  StringRef CPU = F->getFnAttribute("target-cpu").getValueAsString();
+  StringRef Features = F->getFnAttribute("target-features").getValueAsString();
+  const std::string &Triple = M->getTargetTriple();
+  return createTargetMachine(Triple, CPU, Features, OptLevel);
+}
+
 void llvm::spliceBB(IRBuilderBase::InsertPoint IP, BasicBlock *New,
                     bool CreateBranch) {
   assert(New->getFirstInsertionPt() == New->begin() &&
          "Target BB must not have PHI nodes");
 
   // Move instructions to new block.
   BasicBlock *Old = IP.getBlock();
   New->splice(New->begin(), Old, IP.getPoint(), Old->end());
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::getSimdDefaultAlignment(const std::string &Triple,
+                                                  StringRef CPU,
+                                                  StringRef Features) {
+  std::unique_ptr<TargetMachine> TgtInfo(
+      createTargetMachine(Triple, CPU, Features, CodeGenOpt::Default));
+  if (!TgtInfo) {
+    return 0;
+  }
+
+  return TgtInfo->getSimdDefaultAlignment();
+}
+
 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();
 
   // TODO: We should not rely on pass manager. Currently we use pass manager
   // only for getting llvm::Loop which corresponds to given CanonicalLoopInfo
   // object. We should have a method  which returns all blocks between
if (Simdlen || Safelen) {
     LoopMDList.push_back(
         MDNode::get(Ctx, {MDString::get(Ctx, "llvm.loop.vectorize.width"),
                           ConstantAsMetadata::get(VectorizeWidth)}));
   }
 
   addLoopMetadata(CanonicalLoop, LoopMDList);
 }
 
-/// Create the TargetMachine object to query the backend for optimization
-/// preferences.
-///
-/// Ideally, this would be passed from the front-end to the OpenMPBuilder, but
-/// e.g. Clang does not pass it to its CodeGen layer and creates it only when
-/// needed for the LLVM pass pipline. We use some default options to avoid
-/// having to pass too many settings from the frontend that probably do not
-/// matter.
-///
-/// Currently, TargetMachine is only used sometimes by the unrollLoopPartial
-/// method. If we are going to use TargetMachine for more purposes, especially
-/// those that are sensitive to TargetOptions, RelocModel and CodeModel, it
-/// might become be worth requiring front-ends to pass on their TargetMachine,
-/// or at least cache it between methods. Note that while fontends such as Clang
-/// have just a single main TargetMachine per translation unit, "target-cpu" and
-/// "target-features" that determine the TargetMachine are per-function and can
-/// be overrided using __attribute__((target("OPTIONS"))).
-static std::unique_ptr<TargetMachine>
-createTargetMachine(Function *F, CodeGenOpt::Level OptLevel) {
-  Module *M = F->getParent();
-
-  StringRef CPU = F->getFnAttribute("target-cpu").getValueAsString();
-  StringRef Features = F->getFnAttribute("target-features").getValueAsString();
-  const std::string &Triple = M->getTargetTriple();
-
-  std::string Error;
-  const llvm::Target *TheTarget = TargetRegistry::lookupTarget(Triple, Error);
-  if (!TheTarget)
-    return {};
-
-  llvm::TargetOptions Options;
-  return std::unique_ptr<TargetMachine>(TheTarget->createTargetMachine(
-      Triple, CPU, Features, Options, /*RelocModel=*/std::nullopt,
-      /*CodeModel=*/std::nullopt, OptLevel));
-}
-
 /// Heuristically determine the best-performant unroll factor for \p CLI. This
 /// depends on the target processor. We are re-using the same heuristics as the
 /// LoopUnrollPass.
 static int32_t computeHeuristicUnrollFactor(CanonicalLoopInfo *CLI) {
   Function *F = CLI->getFunction();
 
   // Assume the user requests the most aggressive unrolling, even if the rest of
   // the code is optimized using a lower setting.

llvm/lib/Target/PowerPC/PPCTargetMachine.cpp

PPCTargetMachine::PPCTargetMachine(const Target &T, const Triple &TT,
                                    CodeGenOpt::Level OL, bool JIT)
     : LLVMTargetMachine(T, getDataLayoutString(TT), TT, CPU,
                         computeFSAdditions(FS, OL, TT), Options,
                         getEffectiveRelocModel(TT, RM),
                         getEffectivePPCCodeModel(TT, CM, JIT), OL),
       TLOF(createTLOF(getTargetTriple())),
       TargetABI(computeTargetABI(TT, Options)),
       Endianness(isLittleEndianTriple(TT) ? Endian::LITTLE : Endian::BIG) {
+  SimdDefaultAlignment = 128;
   initAsmInfo();
 }
 
 PPCTargetMachine::~PPCTargetMachine() = default;
 
 const PPCSubtarget *
 PPCTargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");

llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp

WebAssemblyTargetMachine::WebAssemblyTargetMachine(
   // 'unreachable' instructions which is meant for that case.
   this->Options.TrapUnreachable = true;
 
   // WebAssembly treats each function as an independent unit. Force
   // -ffunction-sections, effectively, so that we can emit them independently.
   this->Options.FunctionSections = true;
   this->Options.DataSections = true;
   this->Options.UniqueSectionNames = true;
+  SimdDefaultAlignment = 128;
 
   initAsmInfo();
 
   // Note that we don't use setRequiresStructuredCFG(true). It disables
   // optimizations than we're ok with, and want, such as critical edge
   // splitting and tail merging.
 }
 

llvm/lib/Target/X86/X86TargetMachine.cpp

X86TargetMachine::X86TargetMachine(const Target &T, const Triple &TT,
   }
 
   setMachineOutliner(true);
 
   // x86 supports the debug entry values.
   setSupportsDebugEntryValues(true);
 
   initAsmInfo();
+
+  if (FS.contains("+avx512f"))
+    SimdDefaultAlignment = 512;
+  else if (FS.contains("+avx"))
+    SimdDefaultAlignment = 256;
+  else
+    SimdDefaultAlignment = 128;
 }
 
 X86TargetMachine::~X86TargetMachine() = default;
 
 const X86Subtarget *
 X86TargetMachine::getSubtargetImpl(const Function &F) const {
   Attribute CPUAttr = F.getFnAttribute("target-cpu");
   Attribute TuneAttr = F.getFnAttribute("tune-cpu");