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

References

include/llvm/Analysis/VectorUtils.h
  399   uint32_t getAlignment() const { return Alignment.value(); }
include/llvm/CodeGen/CallingConvLower.h
  438       MF.getFrameInfo().ensureMaxAlignment(Alignment.value());
include/llvm/CodeGen/MachineFrameInfo.h
  467     return Objects[ObjectIdx + NumFixedObjects].Alignment.value();
  566   unsigned getMaxAlignment() const { return MaxAlignment.value(); }
include/llvm/CodeGen/TargetCallingConv.h
  130       return A ? A->value() : 0;
  134       assert(getByValAlign() == A.value() && "bitfield overflow");
  139       return A ? A->value() : 0;
  143       assert(getOrigAlign() == A.value() && "bitfield overflow");
include/llvm/CodeGen/TargetFrameLowering.h
   80   unsigned getStackAlignment() const { return StackAlignment.value(); }
   99     return TransientStackAlignment.value();
include/llvm/IR/Function.h
  348       return MA->value();
  440       return MA->value();
include/llvm/IR/GlobalObject.h
   77     return Align ? Align->value() : 0;
include/llvm/IR/InstrTypes.h
 1577       return MA->value();
 1584       return MA->value();
include/llvm/IR/Instructions.h
  114       return MA->value();
  245       return MA->value();
  371       return MA->value();
include/llvm/MC/MCSection.h
  121   unsigned getAlignment() const { return Alignment.value(); }
include/llvm/Support/Alignment.h
  147   return SizeInBytes % Lhs.value() == 0;
  154   return SizeInBytes % (*Lhs).value() == 0;
  164   const uint64_t value = A.value();
  186   assert(static_cast<uintptr_t>(ArithAddr + Alignment.value() - 1) >=
  220   return Align(MinAlign(A.value(), Offset));
  232   return MaybeAlign(MinAlign((*A).value(), Offset));
  254   return Lhs.value() == Rhs;
  258   return Lhs.value() != Rhs;
  262   return Lhs.value() <= Rhs;
  266   return Lhs.value() >= Rhs;
  270   return Lhs.value() < Rhs;
  274   return Lhs.value() > Rhs;
  279   return Lhs ? (*Lhs).value() == Rhs : Rhs == 0;
  282   return Lhs ? (*Lhs).value() != Rhs : Rhs != 0;
  287   return (*Lhs).value() <= Rhs;
  292   return (*Lhs).value() >= Rhs;
  297   return (*Lhs).value() < Rhs;
  302   return (*Lhs).value() > Rhs;
  328   return Lhs.value() == (*Rhs).value();
  328   return Lhs.value() == (*Rhs).value();
  332   return Lhs.value() != (*Rhs).value();
  332   return Lhs.value() != (*Rhs).value();
  336   return Lhs.value() <= (*Rhs).value();
  336   return Lhs.value() <= (*Rhs).value();
  340   return Lhs.value() >= (*Rhs).value();
  340   return Lhs.value() >= (*Rhs).value();
  344   return Lhs.value() < (*Rhs).value();
  344   return Lhs.value() < (*Rhs).value();
  348   return Lhs.value() > (*Rhs).value();
  348   return Lhs.value() > (*Rhs).value();
  354   return Lhs && (*Lhs).value() == Rhs.value();
  354   return Lhs && (*Lhs).value() == Rhs.value();
  358   return Lhs && (*Lhs).value() != Rhs.value();
  358   return Lhs && (*Lhs).value() != Rhs.value();
  362   return Lhs && (*Lhs).value() <= Rhs.value();
  362   return Lhs && (*Lhs).value() <= Rhs.value();
  366   return Lhs && (*Lhs).value() >= Rhs.value();
  366   return Lhs && (*Lhs).value() >= Rhs.value();
  370   return Lhs && (*Lhs).value() < Rhs.value();
  370   return Lhs && (*Lhs).value() < Rhs.value();
  374   return Lhs && (*Lhs).value() > Rhs.value();
  374   return Lhs && (*Lhs).value() > Rhs.value();
  381   return Align(Lhs.value() / Divisor);
include/llvm/Support/Allocator.h
  242     size_t PaddedSize = SizeToAllocate + Alignment.value() - 1;
lib/Analysis/Loads.cpp
   42     const APInt APBaseAlign(Offset.getBitWidth(), BA->value());
   43     const APInt APAlign(Offset.getBitWidth(), Alignment.value());
   88         !Offset.urem(APInt(Offset.getBitWidth(), Alignment.value()))
  245   if (EltSize.urem(Alignment.value()) != 0)
lib/Analysis/ValueTracking.cpp
 1726       Known.Zero.setLowBits(countTrailingZeros(Align->value()));
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  521                                   SupportsAlignment ? Alignment.value() : 0);
  536     OutStreamer->EmitZerofill(TheSection, GVSym, Size, Alignment.value());
  555       OutStreamer->EmitLocalCommonSymbol(GVSym, Size, Alignment.value());
  565                                   SupportsAlignment ? Alignment.value() : 0);
  586       OutStreamer->EmitTBSSSymbol(TheSection, MangSym, Size, Alignment.value());
 2156     OutStreamer->EmitCodeAlignment(Alignment.value());
 2158     OutStreamer->EmitValueToAlignment(Alignment.value());
lib/CodeGen/BranchRelaxation.cpp
   78       return PO + Alignment.value() + offsetToAlignment(PO, Alignment);
lib/CodeGen/CallingConvLower.cpp
   55                                                      Alignment.value());
   57   unsigned Offset = AllocateStack(Size, Alignment.value());
lib/CodeGen/GlobalISel/IRTranslator.cpp
 1182                                DL->getPointerABIAlignment(0).value());
 1663         MachinePointerInfo(Info.ptrVal), Info.flags, Size, Align->value()));
lib/CodeGen/MIRPrinter.cpp
  200   YamlMF.Alignment = MF.getAlignment().value();
  634     OS << "align " << MBB.getAlignment().value();
lib/CodeGen/MachineFrameInfo.cpp
   44   LLVM_DEBUG(dbgs() << "Warning: requested alignment " << Alignment.value()
   45                     << " exceeds the stack alignment " << StackAlignment.value()
  237     OS << ", align=" << SO.Alignment.value();
lib/CodeGen/MachineFunction.cpp
  890     return TD.getPointerABIAlignment(0).value();
  892     return TD.getABIIntegerTypeAlignment(64).value();
  896     return TD.getABIIntegerTypeAlignment(32).value();
lib/CodeGen/PrologEpilogInserter.cpp
  901     unsigned Align = MFI.getLocalFrameMaxAlign().value();
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
 1911                      getConstant(MA->value() - 1, dl, VAList.getValueType()));
 1915                 getConstant(-(int64_t)MA->value(), dl, VAList.getValueType()));
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 4830         Info.align ? Info.align->value() : 0, Info.flags, Info.size, AAInfo);
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
  380   Streamer.EmitValueToAlignment(DL.getPointerABIAlignment(0).value());
lib/IR/Attributes.cpp
  147   return get(Context, Alignment, A.value());
  152   return get(Context, StackAlignment, A.value());
lib/IR/DataLayout.cpp
  756   return getAlignment(Ty, true).value();
  766   return getAlignment(Ty, false).value();
lib/IR/Instructions.cpp
 1255     assert(getAlignment() == Align->value() &&
 1346     assert(getAlignment() == Align->value() &&
 1425     assert(getAlignment() == Align->value() &&
lib/Support/Unix/Memory.inc
  187   uintptr_t Start = alignAddr((const uint8_t *)M.Address - PageSize.value() + 1, PageSize);
lib/Target/AArch64/AArch64CallingConvention.cpp
   50         Size, std::max((unsigned)Align.value(), SlotAlign)));
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp
  227       std::max(MaxKernArgAlign, Align(4)).value();
  895       Kern.getDocument()->getNode(std::max(Align(4), MaxKernArgAlign).value());
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
  163         Builder.CreateAlignedLoad(AdjustedArgTy, ArgPtr, AdjustedAlign.value());
lib/Target/AMDGPU/AMDGPUMachineFunction.h
   50   unsigned getMaxKernArgAlign() const { return MaxKernArgAlign.value(); }
lib/Target/AMDGPU/SIISelLowering.cpp
 2870                                      Alignment ? Alignment->value() : 0);
10771       LoopSize += MBB->getAlignment().value() / 2;
lib/Target/ARM/ARMBasicBlockInfo.h
   35     return Alignment.value() - (1ull << KnownBits);
lib/Target/ARM/ARMCallingConv.cpp
  196   unsigned StackAlign = DL.getStackAlignment().value();
lib/Target/ARM/ARMConstantIslandPass.cpp
 1393         BaseInsertOffset -= Align.value();
 1394         EndInsertOffset -= Align.value();
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp
  176       unsigned AlignWidth = 8 * Alignment->value();
  188     unsigned AlignWidth = 8 * BoundAlignment.value();
lib/Target/Mips/MipsConstantIslandPass.cpp
 1290         BaseInsertOffset -= Align.value();
 1291         EndInsertOffset -= Align.value();
lib/Target/Mips/MipsISelLowering.cpp
 2170         DAG.getConstant(Align.value() - 1, DL, VAList.getValueType()));
 2174         DAG.getConstant(-(int64_t)Align.value(), DL, VAList.getValueType()));
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
 1400     return DL.getPointerPrefAlignment().value();
 1480         O << "\t.param .align " << align.value() << " .b8 ";
 1577       O << "\t.param .align " << align.value() << " .b8 ";
lib/Target/NVPTX/NVPTXPrologEpilogPass.cpp
  181     unsigned Align = MFI.getLocalFrameMaxAlign().value();
lib/Target/PowerPC/PPCBranchSelector.cpp
   97   return Alignment.value() + offsetToAlignment(Offset, Alignment);
  258     BranchSize += MaxAlign.value() - 4;
lib/Target/PowerPC/PPCTargetTransformInfo.cpp
  897   Cost += LT.first * ((SrcBytes / Alignment->value()) - 1);
lib/Target/SystemZ/SystemZLongBranch.cpp
  186         (Block.Alignment.value() - (uint64_t(1) << Position.KnownBits));
lib/Transforms/IPO/Attributor.cpp
 2761         T.takeKnownMaximum(PA ? PA->value() : 0);
lib/Transforms/Vectorize/LoopVectorize.cpp
 2432                                             Alignment.value(), MaskPart);
 2444                                             Alignment.value(), Mask[Part]);
 2447               Builder.CreateAlignedStore(StoredVal, VecPtr, Alignment.value());
 2462       NewLI = Builder.CreateMaskedGather(VectorGep, Alignment.value(), MaskPart,
 2468         NewLI = Builder.CreateMaskedLoad(VecPtr, Alignment.value(), Mask[Part],
 2472         NewLI = Builder.CreateAlignedLoad(DataTy, VecPtr, Alignment.value(),
 5784                                       Alignment ? Alignment->value() : 0, AS);
 5826                                     Alignment ? Alignment->value() : 0);
tools/clang/lib/CodeGen/CGCall.cpp
 4155                 (unsigned)layout->getAlignment().value(), scalarAlign)),
unittests/Support/AlignmentTest.cpp
   54   EXPECT_EQ(Align().value(), 1ULL);
   55   EXPECT_EQ(Align::None().value(), 1ULL);
   64     EXPECT_EQ(Align(Value).value(), Value);
   65     EXPECT_EQ((*MaybeAlign(Value)).value(), Value);
  247     EXPECT_EQ(A, A.value());
  248     EXPECT_NE(A, B.value());
  249     EXPECT_LT(A, B.value());
  250     EXPECT_GT(B, A.value());
  251     EXPECT_LE(A, B.value());
  252     EXPECT_GE(B, A.value());
  253     EXPECT_LE(A, A.value());
  254     EXPECT_GE(A, A.value());
  270     EXPECT_EQ(MA, MA ? (*MA).value() : 0);
  271     EXPECT_NE(MA, MB ? (*MB).value() : 0);
  272     EXPECT_LT(MA, MB ? (*MB).value() : 0);
  273     EXPECT_GT(MB, MA ? (*MA).value() : 0);
  274     EXPECT_LE(MA, MB ? (*MB).value() : 0);
  275     EXPECT_GE(MB, MA ? (*MA).value() : 0);
  276     EXPECT_LE(MA, MA ? (*MA).value() : 0);
  277     EXPECT_GE(MA, MA ? (*MA).value() : 0);
unittests/Support/AllocatorTest.cpp
  149     void *MemBase = safe_malloc(Size + Alignment.value() - 1 + sizeof(void *));