reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/IR/Instructions.h

 5288     return MaybeAlign(LI->getAlignment());

include/llvm/Transforms/Scalar/GVNExpression.h

  337       Alignment = MaybeAlign(L->getAlignment());

lib/Analysis/Lint.cpp

  507                        DL->getTypeStoreSize(I.getType()), I.getAlignment(),

lib/Analysis/Loads.cpp

  206       MaybeAlign(LI->getAlignment()), LI->getType());
  312       MaybeAccessedAlign = MaybeAlign(LI->getAlignment());

lib/Analysis/MemDerefPrinter.cpp

   59               PO, LI->getType(), MaybeAlign(LI->getAlignment()), DL))

lib/Analysis/MemoryDependenceAnalysis.cpp

  279   unsigned LoadAlign = LI->getAlignment();

lib/Analysis/TargetTransformInfo.cpp

 1210                            MaybeAlign(LI->getAlignment()),

lib/Analysis/ValueTracking.cpp

 3942         LI->getPointerOperand(), LI->getType(), MaybeAlign(LI->getAlignment()),

lib/Bitcode/Writer/BitcodeWriter.cpp

 2937     Vals.push_back(Log2_32(cast<LoadInst>(I).getAlignment())+1);

lib/CodeGen/AtomicExpandPass.cpp

  156   unsigned Align = LI->getAlignment();
  385   NewLI->setAlignment(MaybeAlign(LI->getAlignment()));

lib/CodeGen/GlobalISel/IRTranslator.cpp

  250     Alignment = LI->getAlignment();

lib/CodeGen/InterleavedLoadCombinePass.cpp

 1209       Instruction::Load, ILTy, Factor, Indices, InsertionPoint->getAlignment(),
 1222   auto LI = Builder.CreateAlignedLoad(ILTy, CI, InsertionPoint->getAlignment(),

lib/CodeGen/SelectionDAG/FastISel.cpp

 2397     Alignment = LI->getAlignment();

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 4028   unsigned Alignment = I.getAlignment();
 4660       I.getAlignment() < MemVT.getSizeInBits() / 8)
 4678                            I.getAlignment() ? I.getAlignment() :
 4678                            I.getAlignment() ? I.getAlignment() :

lib/IR/AsmWriter.cpp

 4060     if (LI->getAlignment())
 4061       Out << ", align " << LI->getAlignment();

lib/IR/Core.cpp

 2000     return LI->getAlignment();

lib/IR/Instruction.cpp

  390            (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||
  390            (LI->getAlignment() == cast<LoadInst>(I2)->getAlignment() ||

lib/IR/Instructions.cpp

 1286   assert(!(isAtomic() && getAlignment() == 0) &&
 1346     assert(getAlignment() == Align->value() &&
 1349     assert(getAlignment() == 0 && "Alignment representation error!");
 4140                       MaybeAlign(getAlignment()), getOrdering(),

lib/IR/Verifier.cpp

 3380   Assert(LI.getAlignment() <= Value::MaximumAlignment,
 3387     Assert(LI.getAlignment() != 0,

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  277   unsigned Align = I.getAlignment() ?
  278                    I.getAlignment() : DL.getABITypeAlignment(Ty);

lib/Target/ARM/ARMFastISel.cpp

 1049   if (!ARMEmitLoad(VT, ResultReg, Addr, cast<LoadInst>(I)->getAlignment()))
 2941   if (!ARMEmitLoad(VT, ResultReg, Addr, LI->getAlignment(), isZExt, false))

lib/Target/ARM/ARMISelLowering.cpp

16810     Ops.push_back(Builder.getInt32(LI->getAlignment()));

lib/Target/ARM/ARMParallelDSP.cpp

  775                                              Base->getAlignment());

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2277                                           LoadBasePtr, LI->getAlignment(),
 2282                                    LoadBasePtr, LI->getAlignment(),

lib/Target/Mips/MipsFastISel.cpp

  908   if (!emitLoad(VT, ResultReg, Addr, cast<LoadInst>(I)->getAlignment()))

lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp

  116                               /* SrcAlign */ LI->getAlignment(),

lib/Target/X86/X86FastISel.cpp

 1324   unsigned Alignment = LI->getAlignment();
 3934   unsigned Alignment = LI->getAlignment();

lib/Target/X86/X86InterleavedAccess.cpp

  219         Builder.CreateAlignedLoad(VecBaseTy, NewBasePtr, LI->getAlignment());

lib/Transforms/IPO/ArgumentPromotion.cpp

  307           newLoad->setAlignment(MaybeAlign(OrigLoad->getAlignment()));

lib/Transforms/IPO/Attributor.cpp

 2714           if (LI->getAlignment() < getAssumedAlign()) {

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

  466       NewTy, NewPtr, LI.getAlignment(), LI.isVolatile(), LI.getName() + Suffix);
  645   assert(LI.getAlignment() && "Alignment must be set at this point");
  667     auto Align = LI.getAlignment();
  718     auto Align = LI.getAlignment();
  959   unsigned LoadAlign = LI.getAlignment();
 1023       const MaybeAlign Alignment(LI.getAlignment());

lib/Transforms/InstCombine/InstCombinePHI.cpp

  545   MaybeAlign LoadAlignment(FirstLI->getAlignment());
  577     if ((LoadAlignment.hasValue()) != (LI->getAlignment() != 0))
  580     LoadAlignment = std::min(LoadAlignment, MaybeAlign(LI->getAlignment()));

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1361     *Alignment = LI->getAlignment();

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 1309     Align = LI.getAlignment();

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  524     *Alignment = LI->getAlignment();

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1786     unsigned Alignment = I.getAlignment();

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  561       : cast<LoadInst>(I)->getAlignment();

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

  323       if (NewAlignment > LI->getAlignment()) {

lib/Transforms/Scalar/GVN.cpp

 1246         MaybeAlign(LI->getAlignment()), LI->getOrdering(), LI->getSyncScopeID(),

lib/Transforms/Scalar/GVNHoist.cpp

  893           ReplacementLoad->getAlignment(), cast<LoadInst>(I)->getAlignment())));
  893           ReplacementLoad->getAlignment(), cast<LoadInst>(I)->getAlignment())));

lib/Transforms/Scalar/JumpThreading.cpp

 1474         LoadI->getName() + ".pr", false, MaybeAlign(LoadI->getAlignment()),

lib/Transforms/Scalar/LICM.cpp

 1975         unsigned InstAlignment = Load->getAlignment();

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1147                                    LoadBasePtr, LI->getAlignment(), NumBytes);
 1151     unsigned Align = std::min(SI->getAlignment(), LI->getAlignment());
 1166         StoreBasePtr, SI->getAlignment(), LoadBasePtr, LI->getAlignment(),

lib/Transforms/Scalar/LoopLoadElimination.cpp

  438         /* isVolatile */ false, MaybeAlign(Cand.Load->getAlignment()),

lib/Transforms/Scalar/MemCpyOptimizer.cpp

  427   unsigned LoadAlign = LI->getAlignment();

lib/Transforms/Scalar/NewGVN.cpp

 1337     E->setAlignment(MaybeAlign(LI->getAlignment()));

lib/Transforms/Scalar/SROA.cpp

 1224     MaxAlign = std::max(MaxAlign, MaybeAlign(LI->getAlignment()));
 1275   const MaybeAlign Align = MaybeAlign(SomeLoad->getAlignment());
 1344                                      MaybeAlign(LI->getAlignment()), DL, LI))
 1347                                      MaybeAlign(LI->getAlignment()), DL, LI))
 1373     TL->setAlignment(MaybeAlign(LI->getAlignment()));
 1374     FL->setAlignment(MaybeAlign(LI->getAlignment()));
 1688     Alignment = LI->getAlignment();
 3120         unsigned LoadAlign = LI->getAlignment();

lib/Transforms/Scalar/Scalarizer.cpp

  773   if (!getVectorLayout(LI.getType(), LI.getAlignment(), Layout,

lib/Transforms/Scalar/TailRecursionElimination.cpp

  344                                        MaybeAlign(L->getAlignment()), DL, L))

lib/Transforms/Utils/FunctionComparator.cpp

  546             cmpNumbers(LI->getAlignment(), cast<LoadInst>(R)->getAlignment()))
  546             cmpNumbers(LI->getAlignment(), cast<LoadInst>(R)->getAlignment()))

lib/Transforms/Utils/VNCoercion.cpp

  434     NewLoad->setAlignment(MaybeAlign(SrcVal->getAlignment()));

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  132     unsigned Align = LI->getAlignment();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3165       MaybeAlign alignment(cast<LoadInst>(VL0)->getAlignment());
 3831         LoadInst *V = Builder.CreateAlignedLoad(VecTy, Ptr, LI->getAlignment());
 4031       MaybeAlign Alignment = MaybeAlign(LI->getAlignment());

tools/polly/include/polly/Support/ScopHelper.h

  195       return asLoad()->getAlignment();

tools/polly/lib/Analysis/ScopBuilder.cpp

 2893                                   MaybeAlign(LI->getAlignment()), DL)) {
 2945           MaybeAlign(LInst->getAlignment()), DL))

tools/polly/lib/Analysis/ScopDetection.cpp

  472                                       MaybeAlign(Load->getAlignment()), DL))

tools/polly/lib/CodeGen/BlockGenerators.cpp

  320       NewPointer, Load->getAlignment(), Load->getName() + "_p_scalar_");

tools/polly/lib/CodeGen/IslNodeBuilder.cpp

 1217         MaybeAlign(dyn_cast<LoadInst>(AccInst)->getAlignment()));

tools/polly/lib/Exchange/JSONExporter.cpp

  451               LoadI->getAlignment() &&
  452               DL.getABITypeAlignment(LoadI->getType()) != LoadI->getAlignment();