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

References

include/llvm/ADT/BitVector.h
  426     I = alignTo(I, BITWORD_SIZE);
  465     I = alignTo(I, BITWORD_SIZE);
include/llvm/DebugInfo/CodeView/DebugSubsectionRecord.h
   89     Length = alignTo(Info.getRecordLength(), 4);
include/llvm/DebugInfo/PDB/Native/HashTable.h
  164     uint32_t NumWordsP = alignTo(NumBitsP, BitsPerWord) / BitsPerWord;
  165     uint32_t NumWordsD = alignTo(NumBitsD, BitsPerWord) / BitsPerWord;
include/llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h
  232         LocalAddr = alignTo(LocalAddr, Align);
  272         NextAddr = alignTo(NextAddr, Alloc.getAlign());
include/llvm/Support/MathExtras.h
  732   return alignTo(Numerator, Denominator) / Denominator;
lib/CodeGen/GlobalISel/CallLowering.cpp
  366                                       : alignTo(VT.getSizeInBits(), 8) / 8;
lib/CodeGen/PrologEpilogInserter.cpp
  648   Offset = alignTo(Offset, Align, Skew);
  731     if (alignTo(ObjStart, ObjAlign) != ObjStart)
  850       Offset = alignTo(Offset, Align, Skew);
  867       Offset = alignTo(Offset, Align, Skew);
  904     Offset = alignTo(Offset, Align, Skew);
 1080     Offset = alignTo(Offset, StackAlign, Skew);
lib/CodeGen/SafeStack.cpp
  626   unsigned FrameSize = alignTo(SSL.getFrameSize(), StackAlignment);
lib/CodeGen/SafeStackLayout.cpp
   50   return alignTo(Offset + Size, Alignment) - Size;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 3618     unsigned PaddedMaskNumElts = alignTo(MaskNumElts, SrcNumElts);
lib/DebugInfo/CodeView/DebugChecksumsSubsection.cpp
   47   Len = alignTo(Header->ChecksumSize + sizeof(FileChecksumEntryHeader), 4);
   86   uint32_t Len = alignTo(sizeof(FileChecksumEntryHeader) + Bytes.size(), 4);
lib/DebugInfo/CodeView/DebugSubsectionRecord.cpp
   68   return sizeof(DebugSubsectionHeader) + alignTo(DataSize, 4);
   81   Header.Length = alignTo(DataSize, alignOf(Container));
lib/DebugInfo/DWARF/DWARFAcceleratorTable.cpp
  395   AugmentationStringSize = alignTo(AS.getU32(Offset), 4);
lib/DebugInfo/DWARF/DWARFUnit.cpp
  783   uint64_t ValidationSize = alignTo(Size, EntrySize);
lib/DebugInfo/GSYM/GsymReader.cpp
  142   uint64_t Offset = alignTo(sizeof(Header), Hdr->AddrOffSize);
  174     Offset = alignTo(Offset, 4);
lib/DebugInfo/MSF/MSFBuilder.cpp
  114     uint32_t NextFpmBlock = alignTo(OldBlockCount, BlockSize) + 1;
lib/DebugInfo/MSF/MappedBlockStream.cpp
  213       alignTo(Size - BytesFromFirstBlock, BlockSize) / BlockSize;
lib/DebugInfo/PDB/Native/DbiModuleDescriptor.cpp
   91   Size = alignTo(Size, 4);
lib/DebugInfo/PDB/Native/DbiModuleDescriptorBuilder.cpp
   31   Size += alignTo(SymbolByteSize, 4); // Symbol Data
  102   return alignTo(L + M + O, sizeof(uint32_t));
lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp
  173   return alignTo(Size, sizeof(uint32_t));
lib/DebugInfo/PDB/Native/GlobalsStream.cpp
  138   size_t BitmapSizeInBits = alignTo(IPHR_HASH + 1, 32);
lib/DebugInfo/PDB/Native/HashTable.cpp
   51   uint32_t ReqWords = alignTo(ReqBits, BitsPerWord) / BitsPerWord;
lib/ExecutionEngine/ExecutionEngine.cpp
  111         alignTo(sizeof(GVMemoryBlock), TD.getPreferredAlignment(GV)) + GVSize);
lib/ExecutionEngine/JITLink/JITLinkMemoryManager.cpp
   95     TotalSize = alignTo(TotalSize, sys::Process::getPageSizeEstimate());
  113     uint64_t SegmentSize = alignTo(Seg.getContentSize() + Seg.getZeroFillSize(),
lib/ExecutionEngine/Orc/OrcABISupport.cpp
  106   unsigned OffsetToPtr = alignTo(NumTrampolines * TrampolineSize, 8);
lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp
  285         CommonSize = alignTo(CommonSize, Align) + Size;
  604       CommonSize = alignTo(CommonSize, Align) + Size;
lib/IR/Metadata.cpp
  484   OpSize = alignTo(OpSize, alignof(uint64_t));
  495   OpSize = alignTo(OpSize, alignof(uint64_t));
lib/MC/MCAsmStreamer.cpp
  952   for (size_t I = 0, EI = alignTo(Data.size(), Cols); I < EI; I += Cols) {
lib/MC/MCCodePadder.cpp
  290   return alignTo(InstByte + UINT64_C(1) + Offset, WindowSize) - Offset;
lib/MC/MCCodeView.cpp
  221       CurrentOffset = alignTo(CurrentOffset, 4);
lib/MC/MachObjectWriter.cpp
  427   return alignTo(Size, is64Bit ? 8 : 4);
  646     StartAddress = alignTo(StartAddress, Sec->getAlignment());
  791   uint64_t LOHSize = alignTo(LOHRawSize, is64Bit() ? 8 : 4);
lib/MC/StringTableBuilder.cpp
  154       Size = alignTo(Size, Alignment);
  165     Size = alignTo(Size, 4); // Pad to multiple of 4.
  194     size_t Start = alignTo(Size, Alignment);
lib/MC/WasmObjectWriter.cpp
  590   DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
  602           std::min<uint64_t>(alignTo(DataBytes.size(), Align->getAlignment()),
 1232       DataSize = alignTo(DataSize, Section.getAlignment());
lib/MC/XCOFFObjectWriter.cpp
  578         Csect.Address = alignTo(Address, MCSec->getAlignment());
  604     Address = alignTo(Address, DefaultSectionAlign);
lib/Object/WindowsResource.cpp
  682   SectionOneSize += alignTo(TotalStringTableSize, sizeof(uint32_t));
  689   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
  699     SectionTwoSize += alignTo(Entry.size(), sizeof(uint64_t));
  702   FileSize = alignTo(FileSize, SECTION_ALIGNMENT);
  786   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
  793     CurrentOffset += alignTo(RawDataEntry.size(), sizeof(uint64_t));
  796   CurrentOffset = alignTo(CurrentOffset, SECTION_ALIGNMENT);
  967       alignTo(TotalStringTableSize, sizeof(uint32_t)) - TotalStringTableSize;
lib/ObjectYAML/COFFEmitter.cpp
  253       CurrentSectionDataOffset = alignTo(CurrentSectionDataOffset,
  258             alignTo(S.Header.SizeOfRawData, CP.getFileAlignment());
  356   uint32_t SizeOfHeaders = alignTo(CP.SectionTableStart + CP.SectionTableSize,
  358   uint32_t SizeOfImage = alignTo(SizeOfHeaders, Header->SectionAlignment);
  372       SizeOfImage += alignTo(S.Header.VirtualSize, Header->SectionAlignment);
lib/ObjectYAML/DWARFEmitter.cpp
  104     auto FirstDescriptor = alignTo(HeaderSize, Range.AddrSize * 2);
lib/ObjectYAML/ELFEmitter.cpp
   54     uint64_t AlignedOffset = alignTo(CurrentOffset, Align);
lib/Support/BinaryStreamReader.cpp
  156   uint32_t NewOffset = alignTo(Offset, Align);
lib/Support/BinaryStreamWriter.cpp
   96   uint32_t NewOffset = alignTo(Offset, Align);
lib/Support/MemoryBuffer.cpp
  282   size_t AlignedStringLen = alignTo(sizeof(MemBuffer) + NameRef.size() + 1, 16);
lib/Support/TarWriter.cpp
   84   OS.seek(alignTo(Pos, BlockSize));
lib/Support/raw_ostream.cpp
  420     OffsetWidth = std::max<uint64_t>(4, llvm::alignTo(Power, 4) / 4);
  425       alignTo(FB.NumPerLine, FB.ByteGroupSize) / FB.ByteGroupSize;
lib/Target/AArch64/AArch64CallLowering.cpp
  459     StackOffset = alignTo(Handler.StackUsed, Subtarget.isTargetILP32() ? 4 : 8);
  469     StackOffset = alignTo(StackOffset, 16);
  848     NumBytes = alignTo(OutInfo.getNextStackOffset(), 16);
 1020           ? alignTo(Handler.StackSize, 16)
lib/Target/AArch64/AArch64CallingConvention.cpp
  120       RegList, alignTo(PendingMembers.size(), EltsPerReg) / EltsPerReg);
lib/Target/AArch64/AArch64FrameLowering.cpp
  287     Amount = alignTo(Amount, Align);
  945                          alignTo(AFI->getVarArgsGPRSize(), 16) : 0;
 1407       (IsWin64 && !IsFunclet) ? alignTo(AFI->getVarArgsGPRSize(), 16) : 0;
 1590   unsigned FixedObject = IsWin64 ? alignTo(AFI->getVarArgsGPRSize(), 16) : 0;
 2254       alignTo(determineSVEStackSize(MFI, MaxAlign), MaxAlign);
 2303   unsigned AlignedCSStackSize = alignTo(CSStackSize, 16);
 2352   AFI->setStackSizeSVE(alignTo(SVEStackSize, MaxAlign));
 2413   return alignTo(CSSize + MF.getFrameInfo().getMaxCallFrameSize(),
lib/Target/AArch64/AArch64ISelLowering.cpp
 3324     StackOffset = alignTo(StackOffset, Subtarget->isTargetILP32() ? 4 : 8);
 3371     StackArgSize = alignTo(StackArgSize, 16);
 3416         MFI.CreateFixedObject(16 - (GPRSaveSize & 15), -(int)alignTo(GPRSaveSize, 16), false);
 3823     NumBytes = alignTo(NumBytes, 16);
 4133       DoesCalleeRestoreStack(CallConv, TailCallOpt) ? alignTo(NumBytes, 16) : 0;
lib/Target/AArch64/AArch64LegalizerInfo.cpp
  759   auto Size = MIRBuilder.buildConstant(IntPtrTy, alignTo(ValSize, PtrSize));
lib/Target/AArch64/AArch64MachineFunctionInfo.h
  206       unsigned Size = alignTo(MaxOffset - MinOffset, 16);
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
 1053       alignTo(ProgInfo.LDSSize, 1ULL << LDSAlignShift) >> LDSAlignShift;
 1061       alignTo(ProgInfo.ScratchSize * STM.getWavefrontSize(),
 1188   MD->setScratchSize(CC, alignTo(CurrentProgramInfo.ScratchSize, 16));
lib/Target/AMDGPU/AMDGPUCallLowering.cpp
  468     uint64_t ArgOffset = alignTo(ExplicitArgOffset, ABIAlign) + BaseOffset;
  469     ExplicitArgOffset = alignTo(ExplicitArgOffset, ABIAlign) + AllocSize;
  477     ArgOffset = alignTo(ArgOffset, DL.getABITypeAlignment(ArgTy));
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp
  796   Offset = alignTo(Offset, Align);
lib/Target/AMDGPU/AMDGPUISelLowering.cpp
  930     uint64_t ArgOffset = alignTo(ExplicitArgOffset, Align) + ExplicitOffset;
  931     ExplicitArgOffset = alignTo(ExplicitArgOffset, Align) + AllocSize;
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
  101     uint64_t EltOffset = alignTo(ExplicitArgOffset, ABITypeAlign) + BaseOffset;
  102     ExplicitArgOffset = alignTo(ExplicitArgOffset, ABITypeAlign) + AllocSize;
lib/Target/AMDGPU/AMDGPUMachineFunction.cpp
   57   unsigned Offset = LDSSize = alignTo(LDSSize, Align);
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
  669         CurrentLocalMemUsage = alignTo(CurrentLocalMemUsage, Align);
  772   uint32_t NewSize = alignTo(CurrentLocalMemUsage, Align);
lib/Target/AMDGPU/AMDGPUSubtarget.cpp
  529   return alignTo(TotalSize, 4);
lib/Target/AMDGPU/R600AsmPrinter.cpp
   99     OutStreamer->EmitIntValue(alignTo(MFI->getLDSSize(), 4) >> 2, 4);
lib/Target/AMDGPU/R600ControlFlowFinalizer.cpp
  163       CurrentEntries + (alignTo(CurrentSubEntries, 4) / 4);
lib/Target/AMDGPU/R600FrameLowering.cpp
   38     OffsetBytes = alignTo(OffsetBytes, MFI.getObjectAlignment(i));
   42     OffsetBytes = alignTo(OffsetBytes, 4);
   46     OffsetBytes = alignTo(OffsetBytes, MFI.getObjectAlignment(FI));
lib/Target/AMDGPU/SIFrameLowering.cpp
 1115     Amount = alignTo(Amount, Align);
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
  306   return alignTo(getMaxWavesPerCU(STI, FlatWorkGroupSize),
  320   return alignTo(FlatWorkGroupSize, getWavefrontSize(STI)) /
  421   NumSGPRs = alignTo(std::max(1u, NumSGPRs), getSGPREncodingGranule(STI));
  471   NumVGPRs = alignTo(std::max(1u, NumVGPRs),
lib/Target/ARM/ARMBaseInstrInfo.cpp
  751       Size = alignTo(Size, 4);
lib/Target/ARM/ARMCallingConv.cpp
  207     unsigned RegAlign = alignTo(Align, 4) / 4;
lib/Target/ARM/Thumb1FrameLowering.cpp
  130       Amount = alignTo(Amount, getStackAlignment());
lib/Target/ARM/ThumbRegisterInfo.cpp
  290     RequiredExtraInstrs = alignTo(RangeAfterCopy, ExtraRange) / ExtraRange;
lib/Target/BPF/BPFSelectionDAGInfo.cpp
   30   unsigned StoresNumEstimate = alignTo(CopyLen, Align) >> Log2_32(Align);
lib/Target/Hexagon/HexagonFrameLowering.cpp
  597   unsigned MaxCFA = alignTo(MFI.getMaxCallFrameSize(), MaxAlign);
  600   FrameSize = MaxCFA + alignTo(FrameSize, MaxAlign);
  639     assert(alignTo(NumBytes, 8) == NumBytes);
 1375     LFS = alignTo(LFS+S, A);
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
 1327     return alignTo(V, (uint64_t)1 << LogAlign) == V;
 1371     return alignTo(V, (uint64_t)1 << LogAlign) == V;
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp
  177       unsigned NumLoads = alignTo(VecWidth, AlignWidth) / AlignWidth;
  189     unsigned NumLoads = alignTo(VecWidth, AlignWidth) / AlignWidth;
lib/Target/Lanai/LanaiFrameLowering.cpp
   44     MaxCallFrameSize = alignTo(MaxCallFrameSize, StackAlign);
   54   FrameSize = alignTo(FrameSize, StackAlign);
lib/Target/MSP430/MCTargetDesc/MSP430AsmBackend.cpp
  147   unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
lib/Target/Mips/MipsCallLowering.cpp
  183   unsigned Size = alignTo(VA.getValVT().getSizeInBits(), 8) / 8;
  306   unsigned Size = alignTo(VA.getValVT().getSizeInBits(), 8) / 8;
  507       VaArgOffset = alignTo(CCInfo.getNextStackOffset(), RegSize);
  628   NextStackOffset = alignTo(NextStackOffset, StackAlignment);
lib/Target/Mips/MipsFastISel.cpp
 1255       unsigned ArgSize = alignTo(ArgVT.getSizeInBits(), 4);
lib/Target/Mips/MipsFrameLowering.cpp
  128     Size = alignTo(Size + RegSize, RegSize);
lib/Target/Mips/MipsISelLowering.cpp
 2183                   DAG.getConstant(alignTo(ArgSizeInBytes, ArgSlotSizeInBytes),
 3110   NextStackOffset = alignTo(NextStackOffset, StackAlignment);
 4339     VaArgOffset = alignTo(State.getNextStackOffset(), RegSizeInBytes);
 4405     Size = alignTo(Size, RegSizeInBytes);
lib/Target/RISCV/MCTargetDesc/RISCVAsmBackend.cpp
  299   unsigned NumBytes = alignTo(Info.TargetSize + Info.TargetOffset, 8) / 8;
lib/Target/RISCV/RISCVFrameLowering.cpp
   52   uint64_t MaxCallSize = alignTo(MFI.getMaxCallFrameSize(), StackAlign);
   56   FrameSize = alignTo(FrameSize, StackAlign);
lib/Target/Sparc/SparcFrameLowering.cpp
  150     NumBytes = alignTo(NumBytes, MFI.getMaxAlignment());
lib/Target/Sparc/SparcISelLowering.cpp
 1116   ArgsSize = alignTo(ArgsSize, 16);
lib/Target/Sparc/SparcSubtarget.cpp
   82     frameSize = alignTo(frameSize, 16);
   95     frameSize = alignTo(frameSize, 8);
lib/Target/WebAssembly/MCTargetDesc/WebAssemblyAsmBackend.cpp
  110   unsigned NumBytes = alignTo(Info.TargetSize, 8) / 8;
lib/Target/X86/X86FrameLowering.cpp
 1107       NumBytes = alignTo(NumBytes, MaxAlign);
 1240     AlignedNumBytes = alignTo(AlignedNumBytes, MaxAlign);
 1577   unsigned FrameSizeMinusRBP = alignTo(CSSize + UsedSize, getStackAlignment());
 1633       NumBytes = alignTo(FrameSize, MaxAlign);
 1865   return alignTo(MFI.getMaxCallFrameSize(), getStackAlignment()) + it->second;
 2046     SpillSlotOffset = -alignTo(-SpillSlotOffset, Align);
 2813     Amount = alignTo(Amount, StackAlign);
lib/Target/X86/X86InstrInfo.cpp
  144     int SPAdj = alignTo(getFrameSize(MI), StackAlign);
lib/Target/X86/X86TargetTransformInfo.cpp
 2946     ImmVal = Imm.sext(alignTo(BitSize, 64));
lib/Target/XCore/XCoreISelLowering.cpp
  374   int32_t HighOffset = alignTo(Offset, 4);
lib/Transforms/Coroutines/CoroEarly.cpp
   73   int64_t Offset = alignTo(
lib/Transforms/Coroutines/CoroFrame.cpp
  354       StructSize = alignTo(StructSize, TyAlign);
  366     auto Natural = alignTo(StructSize, TyAlign);
  367     auto Forced = alignTo(StructSize, ForcedAlignment);
lib/Transforms/IPO/LowerTypeTests.cpp
  854       DesiredPadding = alignTo(InitSize, 32) - InitSize;
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  776   size_t AlignedSize = alignTo(Size, Mapping.getObjectAlignment());
 1080       tagAlloca(IRB, AI, Tag, alignTo(Size, Mapping.getObjectAlignment()));
 1185     uint64_t AlignedSize = alignTo(Size, Mapping.getObjectAlignment());
 1251   uint64_t NewSize = alignTo(SizeInBytes, Mapping.getObjectAlignment());
lib/Transforms/Instrumentation/MemorySanitizer.cpp
 1664         ArgOffset += alignTo(Size, kShadowTLSAlignment);
 3342       ArgOffset += alignTo(Size, 8);
 3809             RealTy, IRB, OverflowOffset, alignTo(ArgSize, 8));
 3813         OverflowOffset += alignTo(ArgSize, 8);
 3859             OverflowOffset += alignTo(ArgSize, 8);
 4035       VAArgOffset = alignTo(VAArgOffset, 8);
 4199                                            alignTo(ArgSize, 8));
 4200           OverflowOffset += alignTo(ArgSize, 8);
 4425         VAArgOffset = alignTo(VAArgOffset, ArgAlign);
 4439         VAArgOffset += alignTo(ArgSize, 8);
 4456         VAArgOffset = alignTo(VAArgOffset, ArgAlign);
 4470         VAArgOffset = alignTo(VAArgOffset, 8);
lib/Transforms/Utils/ASanStackFrameLayout.cpp
   50   return alignTo(std::max(Res, 2 * Granularity), Alignment);
lib/Transforms/Utils/VNCoercion.cpp
   30   if (llvm::alignTo(StoreSize, 8) != StoreSize)
tools/clang/include/clang/AST/CharUnits.h
  189         return CharUnits(llvm::alignTo(Quantity, Align.Quantity));
tools/clang/include/clang/AST/StmtOpenMP.h
   73         ClausesOffset(llvm::alignTo(sizeof(T), alignof(OMPClause *))) {}
tools/clang/include/clang/AST/TypeLoc.h
  281     dataInt = llvm::alignTo(dataInt, align);
  382     size = llvm::alignTo(size, extraAlign);
  428     size = llvm::alignTo(size, extraAlign);
  435     data = llvm::alignTo(data, getNextTypeAlign());
tools/clang/lib/AST/ASTContext.cpp
 1730     Width = llvm::alignTo(Width, Align);
 1839       Width = llvm::alignTo(Width, Align);
 1852       Width = llvm::alignTo(Width, Align);
tools/clang/lib/AST/Mangle.cpp
  191         llvm::alignTo(ASTContext.getTypeSize(AT), TI.getPointerWidth(0)) /
tools/clang/lib/AST/MicrosoftCXXABI.cpp
  254     MPI.Width = llvm::alignTo(MPI.Width, MPI.Align);
tools/clang/lib/AST/RecordLayoutBuilder.cpp
 1322       llvm::alignTo(getSizeInBits(), Context.getTargetInfo().getCharAlign()));
 1393   return llvm::alignTo(Size, CharAlignment);
 1440     FieldOffset = llvm::alignTo(getDataSizeInBits(), Context.toBits(TypeAlign));
 1445         llvm::alignTo(NewSizeInBits, Context.getTargetInfo().getCharAlign()));
 1619       FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);
 1621           llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);
 1633       FieldOffset = llvm::alignTo(FieldOffset, FieldAlign);
 1640       FieldOffset = llvm::alignTo(FieldOffset, ExplicitFieldAlign);
 1648           llvm::alignTo(UnpackedFieldOffset, UnpackedFieldAlign);
 1654           llvm::alignTo(UnpackedFieldOffset, ExplicitFieldAlign);
 1715     setDataSize(llvm::alignTo(NewSizeInBits, CharAlignment));
 1938       llvm::alignTo(getSizeInBits(), Context.toBits(UnpackedAlignment));
 1940       llvm::alignTo(getSizeInBits(), Context.toBits(Alignment));
tools/clang/lib/AST/Stmt.cpp
 1204   unsigned FirstCaptureOffset = llvm::alignTo(Size, alignof(Capture));
 1261     Size = llvm::alignTo(Size, alignof(Capture));
 1274     Size = llvm::alignTo(Size, alignof(Capture));
tools/clang/lib/AST/StmtOpenMP.cpp
   98       llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
  113       llvm::alignTo(sizeof(OMPParallelDirective), alignof(OMPClause *));
  124   unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
  155   unsigned Size = llvm::alignTo(sizeof(OMPSimdDirective), alignof(OMPClause *));
  167   unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
  207   unsigned Size = llvm::alignTo(sizeof(OMPForDirective), alignof(OMPClause *));
  220       llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
  260       llvm::alignTo(sizeof(OMPForSimdDirective), alignof(OMPClause *));
  271       llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
  286       llvm::alignTo(sizeof(OMPSectionsDirective), alignof(OMPClause *));
  297   unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
  307   unsigned Size = llvm::alignTo(sizeof(OMPSectionDirective), alignof(Stmt *));
  318       llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
  332       llvm::alignTo(sizeof(OMPSingleDirective), alignof(OMPClause *));
  342   unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
  351   unsigned Size = llvm::alignTo(sizeof(OMPMasterDirective), alignof(Stmt *));
  361       llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
  375       llvm::alignTo(sizeof(OMPCriticalDirective), alignof(OMPClause *));
  386       llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
  426       llvm::alignTo(sizeof(OMPParallelForDirective), alignof(OMPClause *));
  438       llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
  478       llvm::alignTo(sizeof(OMPParallelForSimdDirective), alignof(OMPClause *));
  489       llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
  504       llvm::alignTo(sizeof(OMPParallelSectionsDirective), alignof(OMPClause *));
  514   unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
  528   unsigned Size = llvm::alignTo(sizeof(OMPTaskDirective), alignof(OMPClause *));
  580   unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
  595   unsigned Size = llvm::alignTo(sizeof(OMPTaskgroupDirective) +
  606       llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
  617       llvm::alignTo(sizeof(OMPCancellationPointDirective), alignof(Stmt *));
  626   unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
  640   unsigned Size = llvm::alignTo(sizeof(OMPCancelDirective) +
  652       llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
  664       llvm::alignTo(sizeof(OMPFlushDirective), alignof(OMPClause *));
  675       llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
  689       llvm::alignTo(sizeof(OMPOrderedDirective), alignof(OMPClause *));
  700       llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
  720       llvm::alignTo(sizeof(OMPAtomicDirective), alignof(OMPClause *));
  732       llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
  746       llvm::alignTo(sizeof(OMPTargetDirective), alignof(OMPClause *));
  756       llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
  770       llvm::alignTo(sizeof(OMPTargetParallelDirective), alignof(OMPClause *));
  780   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
  821   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForDirective),
  833       llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
  846       llvm::alignTo(sizeof(OMPTargetDataDirective), alignof(OMPClause *)) +
  855       llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
  868       llvm::alignTo(sizeof(OMPTargetEnterDataDirective), alignof(OMPClause *)) +
  877       llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
  890       llvm::alignTo(sizeof(OMPTargetExitDataDirective), alignof(OMPClause *)) +
  901       llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
  915       llvm::alignTo(sizeof(OMPTeamsDirective), alignof(OMPClause *));
  926       llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
  966       llvm::alignTo(sizeof(OMPTaskLoopDirective), alignof(OMPClause *));
  978       llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
 1017       llvm::alignTo(sizeof(OMPTaskLoopSimdDirective), alignof(OMPClause *));
 1029       llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
 1069       llvm::alignTo(sizeof(OMPMasterTaskLoopDirective), alignof(OMPClause *));
 1080   unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
 1121   unsigned Size = llvm::alignTo(sizeof(OMPMasterTaskLoopSimdDirective),
 1134   unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
 1176   unsigned Size = llvm::alignTo(sizeof(OMPParallelMasterTaskLoopDirective),
 1190       llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
 1229       llvm::alignTo(sizeof(OMPDistributeDirective), alignof(OMPClause *));
 1240       llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
 1254       llvm::alignTo(sizeof(OMPTargetUpdateDirective), alignof(OMPClause *));
 1264   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
 1321   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForDirective),
 1335   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
 1391   unsigned Size = llvm::alignTo(sizeof(OMPDistributeParallelForSimdDirective),
 1406       llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
 1447       llvm::alignTo(sizeof(OMPDistributeSimdDirective), alignof(OMPClause *));
 1459   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
 1502   unsigned Size = llvm::alignTo(sizeof(OMPTargetParallelForSimdDirective),
 1517       llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
 1548       llvm::alignTo(sizeof(OMPTargetSimdDirective), alignof(OMPClause *));
 1560       llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
 1600       llvm::alignTo(sizeof(OMPTeamsDistributeDirective), alignof(OMPClause *));
 1611   unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
 1652   unsigned Size = llvm::alignTo(sizeof(OMPTeamsDistributeSimdDirective),
 1666   auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
 1723   auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForSimdDirective),
 1739   auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
 1796   auto Size = llvm::alignTo(sizeof(OMPTeamsDistributeParallelForDirective),
 1810       llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
 1824       llvm::alignTo(sizeof(OMPTargetTeamsDirective), alignof(OMPClause *));
 1834   auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
 1877   auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeDirective),
 1892       llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
 1951       llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForDirective),
 1968       llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective),
 2025       llvm::alignTo(sizeof(OMPTargetTeamsDistributeParallelForSimdDirective),
 2041   auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
 2084   auto Size = llvm::alignTo(sizeof(OMPTargetTeamsDistributeSimdDirective),
tools/clang/lib/AST/TypeLoc.cpp
   98     Total = llvm::alignTo(Total, Align);
  102   Total = llvm::alignTo(Total, MaxAlign);
  172           llvm::alignTo(reinterpret_cast<uintptr_t>(Data),
  175           llvm::alignTo(reinterpret_cast<uintptr_t>(other.Data),
tools/clang/lib/CodeGen/CGCleanup.cpp
  107   Size = llvm::alignTo(Size, ScopeStackAlignment);
  138   StartOfData += llvm::alignTo(Size, ScopeStackAlignment);
tools/clang/lib/CodeGen/CGCleanup.h
  543     Ptr += llvm::alignTo(Size, ScopeStackAlignment);
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp
  119     uint64_t RoundedFEnd = llvm::alignTo(FEndInBits, Ctx.getCharWidth());
tools/clang/lib/CodeGen/CGObjCRuntime.cpp
   94       llvm::alignTo(BitOffset + BitFieldSize, AlignmentBits));
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
 2132     GlobalRecordSize = llvm::alignTo(GlobalRecordSize, Alignment);
 2178         GlobalRecordSize = llvm::alignTo(GlobalRecordSize, Alignment);
 2211             llvm::alignTo(llvm::alignTo(Offset, Alignment) + Size, Alignment);
 2211             llvm::alignTo(llvm::alignTo(Offset, Alignment) + Size, Alignment);
 2215       Offset = llvm::alignTo(Offset, Alignment);
 5080             llvm::alignTo(llvm::alignTo(Size, Alignment) + RecSize, Alignment);
 5080             llvm::alignTo(llvm::alignTo(Size, Alignment) + RecSize, Alignment);
 5082       Size = llvm::alignTo(Size, RecAlignment);
tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp
  123                                  (unsigned)llvm::alignTo(NumBits, 8));
  599         Prior->Data = getByteArrayType(bitsToCharUnits(llvm::alignTo(
tools/clang/lib/CodeGen/TargetInfo.cpp
 3258   unsigned HiStart = llvm::alignTo(LoSize, HiAlign);
 4779             llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
 4784         uint64_t NumRegs = llvm::alignTo(Bits, RegBits) / RegBits;
 4845             llvm::IntegerType::get(getVMContext(), llvm::alignTo(Bits, 8));
 5189     Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
 5239     Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
 5346     RegSize = llvm::alignTo(RegSize, 8);
 6168         llvm::ArrayType::get(Int32Ty, llvm::alignTo(Size, 32) / 32);
 7114   unsigned CurrOffset = llvm::alignTo(Offset, Align);
 7115   Offset = CurrOffset + llvm::alignTo(TySize, Align * 8) / 8;
 7580   unsigned SizeInRegs = llvm::alignTo(Size, 32U) / 32U;
 8223       uint64_t Aligned = llvm::alignTo(Size, 64);
 8550   auto SizeInRegs = llvm::alignTo(getContext().getTypeSize(Ty), 32) / 32;
 8584   auto RetSize = llvm::alignTo(getContext().getTypeSize(RetTy), 32) / 32;
tools/dsymutil/MachOUtils.cpp
  254     Segment.vmsize = alignTo(LinkeditSize, 0x1000);
  261   EndAddress = alignTo(EndAddress, 0x1000);
  287                                  alignTo(FileSize, 0x1000), FileOffset,
  298       VMAddr = alignTo(VMAddr, Align);
  299       FileOffset = alignTo(FileOffset, Align);
  433       DwarfSegmentSize = alignTo(DwarfSegmentSize, Sec->getAlignment());
  457   SymtabStart = alignTo(SymtabStart, 0x1000);
  486   DwarfSegmentStart = alignTo(DwarfSegmentStart, 0x1000);
  505   uint64_t DwarfVMAddr = alignTo(EndAddress, 0x1000);
  556     OutFile.write_zeros(alignTo(Pos, Sec.getAlignment()) - Pos);
tools/lld/COFF/Chunks.cpp
  835   data.resize(alignTo((end - begin) * 2 + 8, 4));
tools/lld/COFF/DLL.cpp
   45     return alignTo(name.size() + 3, 2);
tools/lld/COFF/DriverUtils.cpp
  452   size_t resSize = alignTo(
tools/lld/COFF/PDB.cpp
  701   size_t size = alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
  838             alignTo(sym.length(), alignOf(CodeViewContainer::Pdb));
tools/lld/COFF/Writer.cpp
 1176   fileSize = alignTo(fileOff, config->fileAlign);
 1218   sizeOfHeaders = alignTo(sizeOfHeaders, config->fileAlign);
 1222   uint64_t rva = alignTo(sizeOfHeaders, config->align);
 1241       virtualSize = alignTo(virtualSize, c->getAlignment());
 1245         rawSize = alignTo(virtualSize, config->fileAlign);
 1253     rva += alignTo(virtualSize, config->align);
 1254     fileSize += alignTo(rawSize, config->fileAlign);
 1256   sizeOfImage = alignTo(rva, config->align);
tools/lld/ELF/ARMErrataFix.cpp
  249   off = alignTo(isecAddr + off, 0x1000, 0xffa) - isecAddr;
tools/lld/ELF/Arch/ARM.cpp
  450       val = alignTo(val, 4);
tools/lld/ELF/InputFiles.cpp
  752         size = alignTo(size, 8);
tools/lld/ELF/LinkerScript.cpp
   59     return alignTo(sec->getOffset(val) + getOutputSectionVA(sec),
   61   return alignTo(val, alignment);
  734   start = alignTo(start, alignment);
tools/lld/ELF/ScriptParser.cpp
 1164       return [=] { return alignTo(script->getDot(), e().getValue()); };
 1194       return alignTo(script->getDot(), std::max((uint64_t)1, e().getValue()));
 1213     return [=] { return alignTo(script->getDot(), e().getValue()); };
tools/lld/ELF/SyntheticSections.cpp
  451   size_t aligned = alignTo(d.size(), config->wordsize);
  487     off += alignTo(rec->cie->size, config->wordsize);
  491       off += alignTo(fde->size, config->wordsize);
  862             uint64_t off = alignTo(secSize, isec->alignment);
 3109       off = alignTo(off, alignment);
 3380     off = alignTo(off, t->alignment);
tools/lld/ELF/Writer.cpp
 2249           return alignTo(script->getDot(), config->maxPageSize);
 2266           return alignTo(script->getDot(), config->maxPageSize) +
 2267                  alignTo(script->getDot() % config->maxPageSize,
 2272           return alignTo(script->getDot(), config->maxPageSize) +
 2295     return alignTo(off, os->ptLoad->p_align, os->addr);
 2305     return alignTo(off, os->alignment);
 2329   fileSize = alignTo(off, config->wordsize);
 2356       off = alignTo(off, config->commonPageSize);
 2359   sectionHeaderOff = alignTo(off, config->wordsize);
 2411       p->p_memsz = alignTo(p->p_offset + p->p_memsz, config->commonPageSize) -
 2633                  Out::bufferStart + alignTo(p->firstSec->offset + p->p_filesz,
 2646           alignTo(last->p_filesz, config->commonPageSize);
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp
  246   return llvm::alignTo(value, _is64 ? 8 : 4);
  292         offset = llvm::alignTo(offset, sect.alignment);
  566       _segInfo[&sg].fileSize = llvm::alignTo(segFileSize, _file.pageSize);
  567       fileOffset = llvm::alignTo(fileOffset + segFileSize, _file.pageSize);
  684       cmd->vmsize   = llvm::alignTo(linkeditSize, _file.pageSize);
tools/lld/lib/ReaderWriter/MachO/MachONormalizedFileFromAtoms.cpp
  559     sect->address = llvm::alignTo(addr, sect->alignment);
  562   seg->size = llvm::alignTo(addr - seg->address, _ctx.pageSize());
  582     sect->address = llvm::alignTo(addr, sect->alignment);
  585   seg->size = llvm::alignTo(addr - seg->address, _ctx.pageSize());
  606     address = llvm::alignTo(address, _ctx.pageSize());
 1374   for (unsigned i = size, e = llvm::alignTo(size, _ctx.is64Bit() ? 8 : 4);
tools/lld/wasm/OutputSegment.h
   28     size = llvm::alignTo(size, 1ULL << inSeg->getAlignment());
tools/lld/wasm/Writer.cpp
  209     memoryPtr = alignTo(memoryPtr, stackAlignment);
  210     if (config->zStackSize != alignTo(config->zStackSize, stackAlignment))
  242     memoryPtr = alignTo(memoryPtr, 1ULL << seg->alignment);
  259     memoryPtr = alignTo(memoryPtr, 4);
  287     if (config->initialMemory != alignTo(config->initialMemory, WasmPageSize))
  296       alignTo(memoryPtr, WasmPageSize) / WasmPageSize;
  301     if (config->maxMemory != alignTo(config->maxMemory, WasmPageSize))
tools/lldb/source/Expression/IRMemoryMap.cpp
   91     ret = llvm::alignTo(addr + alloc_size, 4096);
  158     ret = llvm::alignTo(addr + alloc_size, 4096);
  307     allocation_size = llvm::alignTo(size, alignment);
tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp
  173   return llvm::alignTo(size_in_bytes, word_size);
tools/lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp
  123       llvm::alignTo(sizeof(ptr_t) * 3, uint64_align_bytes) + sizeof(uint64_t);
  138   offset = llvm::alignTo(offset, uint64_align_bytes);
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp
  231   const char *cstr = data.GetCStr(offset, llvm::alignTo(n_namesz, 4));
 1487             gnu_debuglink_offset = llvm::alignTo(gnu_debuglink_offset, 4);
 1687           llvm::alignTo(NextVMAddress, std::max<addr_t>(H.sh_addralign, 1));
 2384           ? llvm::alignTo(plt_hdr->sh_entsize, plt_hdr->sh_addralign)
tools/lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.h
   48     return 12 + llvm::alignTo(n_namesz, 4) + llvm::alignTo(n_descsz, 4);
   48     return 12 + llvm::alignTo(n_namesz, 4) + llvm::alignTo(n_descsz, 4);
tools/lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp
  511     size_t note_size = llvm::alignTo(note.n_descsz, 4);
tools/llvm-lipo/llvm-lipo.cpp
  659     Offset = alignTo(Offset, 1ull << S.getP2Alignment());
tools/llvm-objcopy/COFF/COFFObjcopy.cpp
   39   return alignTo(Last.Header.VirtualAddress + Last.Header.VirtualSize,
   52   size_t CRCPos = alignTo(FileName.size() + 1, 4);
   71       NeedVA ? alignTo(Sec.Header.VirtualSize,
tools/llvm-objcopy/COFF/Writer.cpp
  104     FileSize = alignTo(FileSize, FileAlignment);
  151           alignTo(S.AuxFile.size(), sizeof(SymbolTy)) / sizeof(SymbolTy);
  188   SizeOfHeaders = alignTo(SizeOfHeaders, FileAlignment);
  205           alignTo(S.Header.VirtualAddress + S.Header.VirtualSize,
  230   FileSize = alignTo(FileSize, FileAlignment);
tools/llvm-objcopy/ELF/Object.cpp
 1006   Size = alignTo(FileName.size() + 1, 4) + 4;
 1910           alignTo(Offset, std::max<uint64_t>(Seg->Align, 1), Seg->VAddr);
 1939       Offset = alignTo(Offset, Sec.Align == 0 ? 1 : Sec.Align);
 1977     Offset = alignTo(Offset, sizeof(Elf_Addr));
tools/llvm-objcopy/MachO/MachOLayoutBuilder.cpp
  172       Offset = alignTo(Offset + SegFileSize, PageSize);
  173       SegFileSize = alignTo(SegFileSize, PageSize);
  176           Segname == "__PAGEZERO" ? SegmentVmSize : alignTo(VMSize, PageSize);
  249       MLC->segment_command_data.vmsize = alignTo(LinkEditSize, PageSize);
  255       MLC->segment_command_64_data.vmsize = alignTo(LinkEditSize, PageSize);
tools/llvm-readobj/COFFDumper.cpp
  936     uint32_t PaddedSize = alignTo(SubSectionSize, 4);
  996     NextOffset = alignTo(NextOffset, 4);
tools/llvm-readobj/ELFDumper.cpp
 4385     uint64_t PaddedSize = alignTo(DataSize, sizeof(typename ELFT::uint));
tools/llvm-rtdyld/llvm-rtdyld.cpp
  262     Size = alignTo(Size, Alignment);
unittests/DebugInfo/GSYM/GSYMTest.cpp
  719   Offset = alignTo(Offset, 16);
unittests/Support/MathExtrasTest.cpp
  274   EXPECT_EQ(8u, alignTo(5, 8));
  275   EXPECT_EQ(24u, alignTo(17, 8));
  276   EXPECT_EQ(0u, alignTo(~0LL, 8));
  278   EXPECT_EQ(7u, alignTo(5, 8, 7));
  279   EXPECT_EQ(17u, alignTo(17, 8, 1));
  280   EXPECT_EQ(3u, alignTo(~0LL, 8, 3));
  281   EXPECT_EQ(552u, alignTo(321, 255, 42));
unittests/Support/TrailingObjectsTest.cpp
  117             llvm::alignTo(Class1::totalSizeToAlloc<short>(1), alignof(Class1)));
  123             llvm::alignTo(Class1::totalSizeToAlloc<short>(3), alignof(Class1)));
  137   EXPECT_EQ(sizeof(Class2), llvm::alignTo(sizeof(bool) * 2, alignof(double)));
  153       llvm::alignTo(Class2::totalSizeToAlloc<double, short>(1, 1),
  188   EXPECT_EQ(sizeof(Class3), llvm::alignTo(1, alignof(double)));
  197       llvm::alignTo(Class3::totalSizeToAlloc<double, short, bool>(1, 1, 3),
  219             llvm::alignTo(sizeof(long) + 1, alignof(long)));
  220   EXPECT_EQ(sizeof(Class4), llvm::alignTo(1, alignof(long)));
  227       llvm::alignTo(Class4::totalSizeToAlloc<char, long>(1, 1),
utils/TableGen/GlobalISelEmitter.cpp
 3588             llvm::alignTo(MemTyOrNone->get().getSizeInBits(), 8);