[Alignment][NFC] Use the Align type in MCSection

[gchatelet]

• Remove unneeded ctor

[courbet]

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

356

reflow

[foad]

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

256–257

The change is fine of course but there ought to be a neater way of writing this using some kind of "max" operation.

[gchatelet]

• Revert formatting comment

[gchatelet]

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

256–257

If you had access to the variable itself you could do Alignment = std::max(Alignment, Align(64)). But it's currently a private variable.
We could add a clampAlignment(Align MaxAlignment) function to MCSection though.

llvm/include/llvm/MC/MCSection.h

public:
   }
   void setBeginSymbol(MCSymbol *Sym) {
     assert(!Begin);
     Begin = Sym;
   }
   MCSymbol *getEndSymbol(MCContext &Ctx);
   bool hasEnded() const;
 
-  unsigned getAlignment() const { return Alignment.value(); }
+  Align getAlign() const { return Alignment; }
   void setAlignment(Align Value) { Alignment = Value; }
 
   unsigned getOrdinal() const { return Ordinal; }
   void setOrdinal(unsigned Value) { Ordinal = Value; }
 
   unsigned getLayoutOrder() const { return LayoutOrder; }
   void setLayoutOrder(unsigned Value) { LayoutOrder = Value; }
 

llvm/lib/MC/ELFObjectWriter.cpp

struct ELFWriter {
   // Sections in the order they are to be output in the section table.
   std::vector<const MCSectionELF *> SectionTable;
   unsigned addToSectionTable(const MCSectionELF *Sec);
 
   // TargetObjectWriter wrappers.
   bool is64Bit() const;
   bool usesRela(const MCSectionELF &Sec) const;
 
-  uint64_t align(unsigned Alignment);
+  uint64_t align(Align Alignment);
 
   bool maybeWriteCompression(uint32_t ChType, uint64_t Size,
                              SmallVectorImpl<uint8_t> &CompressedContents,
-                             unsigned Alignment);
+                             Align Alignment);
 
 public:
   ELFWriter(ELFObjectWriter &OWriter, raw_pwrite_stream &OS,
             bool IsLittleEndian, DwoMode Mode)
       : OWriter(OWriter),
         W(OS, IsLittleEndian ? support::little : support::big), Mode(Mode) {}
 
   void WriteWord(uint64_t Word) {
void writeSectionHeader(const MCAsmLayout &Layout,
                           const SectionIndexMapTy &SectionIndexMap,
                           const SectionOffsetsTy &SectionOffsets);
 
   void writeSectionData(const MCAssembler &Asm, MCSection &Sec,
                         const MCAsmLayout &Layout);
 
   void WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
                         uint64_t Address, uint64_t Offset, uint64_t Size,
-                        uint32_t Link, uint32_t Info, uint64_t Alignment,
+                        uint32_t Link, uint32_t Info, MaybeAlign Alignment,
                         uint64_t EntrySize);
 
   void writeRelocations(const MCAssembler &Asm, const MCSectionELF &Sec);
 
   uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout);
   void writeSection(const SectionIndexMapTy &SectionIndexMap,
                     uint32_t GroupSymbolIndex, uint64_t Offset, uint64_t Size,
                     const MCSectionELF &Section);
uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override {
     Size += ELFWriter(*this, DwoOS, IsLittleEndian, ELFWriter::DwoOnly)
                 .writeObject(Asm, Layout);
     return Size;
   }
 };
 
 } // end anonymous namespace
 
-uint64_t ELFWriter::align(unsigned Alignment) {
-  uint64_t Offset = W.OS.tell(), NewOffset = alignTo(Offset, Alignment);
+uint64_t ELFWriter::align(Align Alignment) {
+  uint64_t Offset = W.OS.tell();
+  uint64_t NewOffset = alignTo(Offset, Alignment);
   W.OS.write_zeros(NewOffset - Offset);
   return NewOffset;
 }
 
 unsigned ELFWriter::addToSectionTable(const MCSectionELF *Sec) {
   SectionTable.push_back(Sec);
   StrTabBuilder.add(Sec->getName());
   return SectionTable.size();
void ELFWriter::computeSymbolTable(
 
   // Symbol table
   unsigned EntrySize = is64Bit() ? ELF::SYMENTRY_SIZE64 : ELF::SYMENTRY_SIZE32;
   MCSectionELF *SymtabSection =
       Ctx.getELFSection(".symtab", ELF::SHT_SYMTAB, 0, EntrySize);
   SymtabSection->setAlignment(is64Bit() ? Align(8) : Align(4));
   SymbolTableIndex = addToSectionTable(SymtabSection);
 
-  uint64_t SecStart = align(SymtabSection->getAlignment());
+  uint64_t SecStart = align(SymtabSection->getAlign());
 
   // The first entry is the undefined symbol entry.
   Writer.writeSymbol(0, 0, 0, 0, 0, 0, false);
 
   std::vector<ELFSymbolData> LocalSymbolData;
   std::vector<ELFSymbolData> ExternalSymbolData;
   MutableArrayRef<std::pair<std::string, size_t>> FileNames =
       Asm.getFileNames();
MCSectionELF *RelaSection = Ctx.createELFRelSection(
       Sec.getGroup(), &Sec);
   RelaSection->setAlignment(is64Bit() ? Align(8) : Align(4));
   return RelaSection;
 }
 
 // Include the debug info compression header.
 bool ELFWriter::maybeWriteCompression(
     uint32_t ChType, uint64_t Size,
-    SmallVectorImpl<uint8_t> &CompressedContents, unsigned Alignment) {
+    SmallVectorImpl<uint8_t> &CompressedContents, Align Alignment) {
   uint64_t HdrSize =
       is64Bit() ? sizeof(ELF::Elf32_Chdr) : sizeof(ELF::Elf64_Chdr);
   if (Size <= HdrSize + CompressedContents.size())
     return false;
   // Platform specific header is followed by compressed data.
   if (is64Bit()) {
     // Write Elf64_Chdr header.
     write(static_cast<ELF::Elf64_Word>(ChType));
     write(static_cast<ELF::Elf64_Word>(0)); // ch_reserved field.
     write(static_cast<ELF::Elf64_Xword>(Size));
-    write(static_cast<ELF::Elf64_Xword>(Alignment));
+    write(static_cast<ELF::Elf64_Xword>(Alignment.value()));
   } else {
     // Write Elf32_Chdr header otherwise.
     write(static_cast<ELF::Elf32_Word>(ChType));
     write(static_cast<ELF::Elf32_Word>(Size));
-    write(static_cast<ELF::Elf32_Word>(Alignment));
+    write(static_cast<ELF::Elf32_Word>(Alignment.value()));
   }
   return true;
 }
 
 void ELFWriter::writeSectionData(const MCAssembler &Asm, MCSection &Sec,
                                  const MCAsmLayout &Layout) {
   MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
   StringRef SectionName = Section.getName();
case DebugCompressionType::Zlib:
     break;
   case DebugCompressionType::Zstd:
     ChType = ELF::ELFCOMPRESS_ZSTD;
     break;
   }
   compression::compress(compression::Params(CompressionType), Uncompressed,
                         Compressed);
   if (!maybeWriteCompression(ChType, UncompressedData.size(), Compressed,
-                             Sec.getAlignment())) {
+                             Sec.getAlign())) {
     W.OS << UncompressedData;
     return;
   }
 
   Section.setFlags(Section.getFlags() | ELF::SHF_COMPRESSED);
   // Alignment field should reflect the requirements of
   // the compressed section header.
   Section.setAlignment(is64Bit() ? Align(8) : Align(4));
   W.OS << toStringRef(Compressed);
 }
 
 void ELFWriter::WriteSecHdrEntry(uint32_t Name, uint32_t Type, uint64_t Flags,
                                  uint64_t Address, uint64_t Offset,
                                  uint64_t Size, uint32_t Link, uint32_t Info,
-                                 uint64_t Alignment, uint64_t EntrySize) {
+                                 MaybeAlign Alignment, uint64_t EntrySize) {
   W.write<uint32_t>(Name);        // sh_name: index into string table
   W.write<uint32_t>(Type);        // sh_type
   WriteWord(Flags);     // sh_flags
   WriteWord(Address);   // sh_addr
   WriteWord(Offset);    // sh_offset
   WriteWord(Size);      // sh_size
   W.write<uint32_t>(Link);        // sh_link
   W.write<uint32_t>(Info);        // sh_info
-  WriteWord(Alignment); // sh_addralign
+  WriteWord(Alignment ? Alignment->value() : 0); // sh_addralign
   WriteWord(EntrySize); // sh_entsize
 }
 
 void ELFWriter::writeRelocations(const MCAssembler &Asm,
                                        const MCSectionELF &Sec) {
   std::vector<ELFRelocationEntry> &Relocs = OWriter.Relocations[&Sec];
 
   // We record relocations by pushing to the end of a vector. Reverse the vector
if (Section.getFlags() & ELF::SHF_LINK_ORDER) {
     if (Sym && Sym->isInSection()) {
       const MCSectionELF *Sec = cast<MCSectionELF>(&Sym->getSection());
       sh_link = SectionIndexMap.lookup(Sec);
     }
   }
 
   WriteSecHdrEntry(StrTabBuilder.getOffset(Section.getName()),
                    Section.getType(), Section.getFlags(), 0, Offset, Size,
-                   sh_link, sh_info, Section.getAlignment(),
+                   sh_link, sh_info, Section.getAlign(),
                    Section.getEntrySize());
 }
 
 void ELFWriter::writeSectionHeader(
     const MCAsmLayout &Layout, const SectionIndexMapTy &SectionIndexMap,
     const SectionOffsetsTy &SectionOffsets) {
   const unsigned NumSections = SectionTable.size();
 
   // Null section first.
   uint64_t FirstSectionSize =
       (NumSections + 1) >= ELF::SHN_LORESERVE ? NumSections + 1 : 0;
-  WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, 0, 0);
+  WriteSecHdrEntry(0, 0, 0, 0, 0, FirstSectionSize, 0, 0, None, 0);
 
   for (const MCSectionELF *Section : SectionTable) {
     uint32_t GroupSymbolIndex;
     unsigned Type = Section->getType();
     if (Type != ELF::SHT_GROUP)
       GroupSymbolIndex = 0;
     else
       GroupSymbolIndex = Section->getGroup()->getIndex();
uint64_t ELFWriter::writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) {
   for (MCSection &Sec : Asm) {
     MCSectionELF &Section = static_cast<MCSectionELF &>(Sec);
     if (Mode == NonDwoOnly && isDwoSection(Section))
       continue;
     if (Mode == DwoOnly && !isDwoSection(Section))
       continue;
 
     // Remember the offset into the file for this section.
-    const uint64_t SecStart = align(Section.getAlignment());
+    const uint64_t SecStart = align(Section.getAlign());
 
     const MCSymbolELF *SignatureSymbol = Section.getGroup();
     writeSectionData(Asm, Section, Layout);
 
     uint64_t SecEnd = W.OS.tell();
     SectionOffsets[&Section] = std::make_pair(SecStart, SecEnd);
 
     MCSectionELF *RelSection = createRelocationSection(Ctx, Section);
if (RelSection) {
       Relocations.push_back(RelSection);
     }
 
     OWriter.TargetObjectWriter->addTargetSectionFlags(Ctx, Section);
   }
 
   for (MCSectionELF *Group : Groups) {
     // Remember the offset into the file for this section.
-    const uint64_t SecStart = align(Group->getAlignment());
+    const uint64_t SecStart = align(Group->getAlign());
 
     const MCSymbol *SignatureSymbol = Group->getGroup();
     assert(SignatureSymbol);
     write(uint32_t(Group->isComdat() ? unsigned(ELF::GRP_COMDAT) : 0));
     for (const MCSectionELF *Member : GroupMembers[SignatureSymbol]) {
       uint32_t SecIndex = SectionIndexMap.lookup(Member);
       write(SecIndex);
     }
if (Mode == DwoOnly) {
     }
 
     // Compute symbol table information.
     computeSymbolTable(Asm, Layout, SectionIndexMap, RevGroupMap,
                        SectionOffsets);
 
     for (MCSectionELF *RelSection : Relocations) {
       // Remember the offset into the file for this section.
-      const uint64_t SecStart = align(RelSection->getAlignment());
+      const uint64_t SecStart = align(RelSection->getAlign());
 
       writeRelocations(Asm,
                        cast<MCSectionELF>(*RelSection->getLinkedToSection()));
 
       uint64_t SecEnd = W.OS.tell();
       SectionOffsets[RelSection] = std::make_pair(SecStart, SecEnd);
     }
 
     if (OWriter.EmitAddrsigSection) {
       uint64_t SecStart = W.OS.tell();
       writeAddrsigSection();
       uint64_t SecEnd = W.OS.tell();
       SectionOffsets[AddrsigSection] = std::make_pair(SecStart, SecEnd);
     }
   }
 
   {
     uint64_t SecStart = W.OS.tell();
     StrTabBuilder.write(W.OS);
     SectionOffsets[StrtabSection] = std::make_pair(SecStart, W.OS.tell());
   }
 
-  const uint64_t SectionHeaderOffset = align(is64Bit() ? 8 : 4);
+  const uint64_t SectionHeaderOffset = align(is64Bit() ? Align(8) : Align(4));
 
   // ... then the section header table ...
   writeSectionHeader(Layout, SectionIndexMap, SectionOffsets);
 
   uint16_t NumSections = support::endian::byte_swap<uint16_t>(
       (SectionTable.size() + 1 >= ELF::SHN_LORESERVE) ? (uint16_t)ELF::SHN_UNDEF
                                                       : SectionTable.size() + 1,
       W.Endian);

llvm/lib/MC/MCELFStreamer.cpp

void MCELFStreamer::emitAssemblerFlag(MCAssemblerFlag Flag) {
   llvm_unreachable("invalid assembler flag!");
 }
 
 // If bundle alignment is used and there are any instructions in the section, it
 // needs to be aligned to at least the bundle size.
 static void setSectionAlignmentForBundling(const MCAssembler &Assembler,
                                            MCSection *Section) {
   if (Section && Assembler.isBundlingEnabled() && Section->hasInstructions() &&
-      Section->getAlignment() < Assembler.getBundleAlignSize())
+      Section->getAlign() < Assembler.getBundleAlignSize())
     Section->setAlignment(Align(Assembler.getBundleAlignSize()));
 }
 
 void MCELFStreamer::changeSection(MCSection *Section,
                                   const MCExpr *Subsection) {
   MCSection *CurSection = getCurrentSectionOnly();
   if (CurSection && isBundleLocked())
     report_fatal_error("Unterminated .bundle_lock when changing a section");

llvm/lib/MC/MCObjectStreamer.cpp

void MCObjectStreamer::emitValueToAlignment(unsigned ByteAlignment,
                                             unsigned MaxBytesToEmit) {
   if (MaxBytesToEmit == 0)
     MaxBytesToEmit = ByteAlignment;
   insert(new MCAlignFragment(Align(ByteAlignment), Value, ValueSize,
                              MaxBytesToEmit));
 
   // Update the maximum alignment on the current section if necessary.
   MCSection *CurSec = getCurrentSectionOnly();
-  if (ByteAlignment > CurSec->getAlignment())
+  if (CurSec->getAlign() < ByteAlignment)
     CurSec->setAlignment(Align(ByteAlignment));
 }
 
 void MCObjectStreamer::emitCodeAlignment(unsigned ByteAlignment,
                                          const MCSubtargetInfo *STI,
                                          unsigned MaxBytesToEmit) {
   emitValueToAlignment(ByteAlignment, 0, 1, MaxBytesToEmit);
   cast<MCAlignFragment>(getCurrentFragment())->setEmitNops(true, STI);

llvm/lib/MC/MCSectionXCOFF.cpp

 class Triple;
 } // namespace llvm
 
 using namespace llvm;
 
 MCSectionXCOFF::~MCSectionXCOFF() = default;
 
 void MCSectionXCOFF::printCsectDirective(raw_ostream &OS) const {
-  OS << "\t.csect " << QualName->getName() << "," << Log2_32(getAlignment())
-     << '\n';
+  OS << "\t.csect " << QualName->getName() << "," << Log2(getAlign()) << '\n';
 }
 
 void MCSectionXCOFF::printSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                                           raw_ostream &OS,
                                           const MCExpr *Subsection) const {
   if (getKind().isText()) {
     if (getMappingClass() != XCOFF::XMC_PR)
       report_fatal_error("Unhandled storage-mapping class for .text csect");

llvm/lib/MC/MCWinCOFFStreamer.cpp

if (getContext().getTargetTriple().getArch() != Triple::x86)
     return;
 
   const MCSymbolCOFF *CSymbol = cast<MCSymbolCOFF>(Symbol);
   if (CSymbol->isSafeSEH())
     return;
 
   MCSection *SXData = getContext().getObjectFileInfo()->getSXDataSection();
   getAssembler().registerSection(*SXData);
-  if (SXData->getAlignment() < 4)
+  if (SXData->getAlign() < 4)
     SXData->setAlignment(Align(4));
 
   new MCSymbolIdFragment(Symbol, SXData);
 
   getAssembler().registerSymbol(*Symbol);
   CSymbol->setIsSafeSEH();
 
   // The Microsoft linker requires that the symbol type of a handler be
   // function. Go ahead and oblige it here.
   CSymbol->setType(COFF::IMAGE_SYM_DTYPE_FUNCTION
                    << COFF::SCT_COMPLEX_TYPE_SHIFT);
 }
 
 void MCWinCOFFStreamer::emitCOFFSymbolIndex(MCSymbol const *Symbol) {
   MCSection *Sec = getCurrentSectionOnly();
   getAssembler().registerSection(*Sec);
-  if (Sec->getAlignment() < 4)
+  if (Sec->getAlign() < 4)
     Sec->setAlignment(Align(4));
 
   new MCSymbolIdFragment(Symbol, getCurrentSectionOnly());
 
   getAssembler().registerSymbol(*Symbol);
 }
 
 void MCWinCOFFStreamer::emitCOFFSectionIndex(const MCSymbol *Symbol) {

llvm/lib/MC/MachObjectWriter.cpp

uint64_t MachObjectWriter::getPaddingSize(const MCSection *Sec,
   uint64_t EndAddr = getSectionAddress(Sec) + Layout.getSectionAddressSize(Sec);
   unsigned Next = Sec->getLayoutOrder() + 1;
   if (Next >= Layout.getSectionOrder().size())
     return 0;
 
   const MCSection &NextSec = *Layout.getSectionOrder()[Next];
   if (NextSec.isVirtualSection())
     return 0;
-  return offsetToAlignment(EndAddr, Align(NextSec.getAlignment()));
+  return offsetToAlignment(EndAddr, NextSec.getAlign());
 }
 
 void MachObjectWriter::writeHeader(MachO::HeaderFileType Type,
                                    unsigned NumLoadCommands,
                                    unsigned LoadCommandsSize,
                                    bool SubsectionsViaSymbols) {
   uint32_t Flags = 0;
 
if (is64Bit()) {
     W.write<uint64_t>(VMAddr);      // address
     W.write<uint64_t>(SectionSize); // size
   } else {
     W.write<uint32_t>(VMAddr);      // address
     W.write<uint32_t>(SectionSize); // size
   }
   W.write<uint32_t>(FileOffset);
 
-  assert(isPowerOf2_32(Section.getAlignment()) && "Invalid alignment!");
-  W.write<uint32_t>(Log2_32(Section.getAlignment()));
+  W.write<uint32_t>(Log2(Section.getAlign()));
   W.write<uint32_t>(NumRelocations ? RelocationsStart : 0);
   W.write<uint32_t>(NumRelocations);
   W.write<uint32_t>(Flags);
   W.write<uint32_t>(IndirectSymBase.lookup(&Sec)); // reserved1
   W.write<uint32_t>(Section.getStubSize()); // reserved2
   if (is64Bit())
     W.write<uint32_t>(0); // reserved3
 
for (const MCSection &Section : Asm) {
     }
   }
 }
 
 void MachObjectWriter::computeSectionAddresses(const MCAssembler &Asm,
                                                const MCAsmLayout &Layout) {
   uint64_t StartAddress = 0;
   for (const MCSection *Sec : Layout.getSectionOrder()) {
-    StartAddress = alignTo(StartAddress, Sec->getAlignment());
+    StartAddress = alignTo(StartAddress, Sec->getAlign());
     SectionAddress[Sec] = StartAddress;
     StartAddress += Layout.getSectionAddressSize(Sec);
 
     // Explicitly pad the section to match the alignment requirements of the
     // following one. This is for 'gas' compatibility, it shouldn't
     /// strictly be necessary.
     StartAddress += getPaddingSize(Sec, Layout);
   }

llvm/lib/MC/WasmObjectWriter.cpp

default:
     llvm_unreachable("invalid relocation type");
   }
 }
 
 static void addData(SmallVectorImpl<char> &DataBytes,
                     MCSectionWasm &DataSection) {
   LLVM_DEBUG(errs() << "addData: " << DataSection.getName() << "\n");
 
-  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
+  DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlign()));
 
   for (const MCFragment &Frag : DataSection) {
     if (Frag.hasInstructions())
       report_fatal_error("only data supported in data sections");
 
     if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
       if (Align->getValueSize() != 1)
         report_fatal_error("only byte values supported for alignment");
if (SectionName.startswith(".init_array"))
       continue;
 
     // Code is handled separately
     if (Section.getKind().isText())
       continue;
 
     if (Section.isWasmData()) {
       uint32_t SegmentIndex = DataSegments.size();
-      DataSize = alignTo(DataSize, Section.getAlignment());
+      DataSize = alignTo(DataSize, Section.getAlign());
       DataSegments.emplace_back();
       WasmDataSegment &Segment = DataSegments.back();
       Segment.Name = SectionName;
       Segment.InitFlags = Section.getPassive()
                               ? (uint32_t)wasm::WASM_DATA_SEGMENT_IS_PASSIVE
                               : 0;
       Segment.Offset = DataSize;
       Segment.Section = &Section;
       addData(Segment.Data, Section);
-      Segment.Alignment = Log2_32(Section.getAlignment());
+      Segment.Alignment = Log2(Section.getAlign());
       Segment.LinkingFlags = Section.getSegmentFlags();
       DataSize += Segment.Data.size();
       Section.setSegmentIndex(SegmentIndex);
 
       if (const MCSymbolWasm *C = Section.getGroup()) {
         Comdats[C->getName()].emplace_back(
             WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
       }

llvm/lib/MC/WinCOFFObjectWriter.cpp

 }
 
 COFFSection *WinCOFFObjectWriter::createSection(StringRef Name) {
   Sections.emplace_back(std::make_unique<COFFSection>(Name));
   return Sections.back().get();
 }
 
 static uint32_t getAlignment(const MCSectionCOFF &Sec) {
-  switch (Sec.getAlignment()) {
+  switch (Sec.getAlign().value()) {
   case 1:
     return COFF::IMAGE_SCN_ALIGN_1BYTES;
   case 2:
     return COFF::IMAGE_SCN_ALIGN_2BYTES;
   case 4:
     return COFF::IMAGE_SCN_ALIGN_4BYTES;
   case 8:
     return COFF::IMAGE_SCN_ALIGN_8BYTES;

llvm/lib/MC/XCOFFObjectWriter.cpp

if ((Section->Flags == XCOFF::STYP_TBSS) && !HasTDataSection)
       Address = 0;
 
     for (auto *Group : Section->Groups) {
       if (Group->empty())
         continue;
 
       for (auto &Csect : *Group) {
         const MCSectionXCOFF *MCSec = Csect.MCSec;
-        Csect.Address = alignTo(Address, MCSec->getAlignment());
+        Csect.Address = alignTo(Address, MCSec->getAlign());
         Csect.Size = Layout.getSectionAddressSize(MCSec);
         Address = Csect.Address + Csect.Size;
         Csect.SymbolTableIndex = SymbolTableIndex;
         SymbolIndexMap[MCSec->getQualNameSymbol()] = Csect.SymbolTableIndex;
         // 1 main and 1 auxiliary symbol table entry for the csect.
         SymbolTableIndex += 2;
 
         for (auto &Sym : Csect.Syms) {
void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // Start to generate DWARF sections. Sections other than DWARF section use
   // DefaultSectionAlign as the default alignment, while DWARF sections have
   // their own alignments. If these two alignments are not the same, we need
   // some paddings here and record the paddings bytes for FileOffsetToData
   // calculation.
   if (!DwarfSections.empty())
     PaddingsBeforeDwarf =
         alignTo(Address,
-                (*DwarfSections.begin()).DwarfSect->MCSec->getAlignment()) -
+                (*DwarfSections.begin()).DwarfSect->MCSec->getAlign()) -
         Address;
 
   DwarfSectionEntry *LastDwarfSection = nullptr;
 
   for (auto &DwarfSection : DwarfSections) {
     assert((SectionIndex <= MaxSectionIndex) && "Section index overflow!");
 
     XCOFFSection &DwarfSect = *DwarfSection.DwarfSect;
for (auto &DwarfSection : DwarfSections) {
     // 1 main and 1 auxiliary symbol table entry for the csect.
     SymbolTableIndex += 2;
 
     // Section address. Make it align to section alignment.
     // We use address 0 for DWARF sections' Physical and Virtual Addresses.
     // This address is used to tell where is the section in the final object.
     // See writeSectionForDwarfSectionEntry().
     DwarfSection.Address = DwarfSect.Address =
-        alignTo(Address, MCSec->getAlignment());
+        alignTo(Address, MCSec->getAlign());
 
     // Section size.
     // For DWARF section, we must use the real size which may be not aligned.
     DwarfSection.Size = DwarfSect.Size = Layout.getSectionAddressSize(MCSec);
 
     Address = DwarfSection.Address + DwarfSection.Size;
 
     if (LastDwarfSection)
void XCOFFObjectWriter::writeSectionForExceptionSectionEntry(
 
   CurrentAddressLocation += getExceptionSectionSize();
 }
 
 // Takes the log base 2 of the alignment and shifts the result into the 5 most
 // significant bits of a byte, then or's in the csect type into the least
 // significant 3 bits.
 uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
-  unsigned Align = Sec->getAlignment();
-  assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
-  unsigned Log2Align = Log2_32(Align);
+  unsigned Log2Align = Log2(Sec->getAlign());
   // Result is a number in the range [0, 31] which fits in the 5 least
   // significant bits. Shift this value into the 5 most significant bits, and
   // bitwise-or in the csect type.
   uint8_t EncodedAlign = Log2Align << 3;
   return EncodedAlign | Sec->getCSectType();
 }
 
 } // end anonymous namespace
 
 std::unique_ptr<MCObjectWriter>
 llvm::createXCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                               raw_pwrite_stream &OS) {
   return std::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);
 }

llvm/lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp

void AMDGPUAsmPrinter::emitFunctionBodyEnd() {
   auto &ReadOnlySection = *ObjectFileInfo.getReadOnlySection();
 
   Streamer.pushSection();
   Streamer.switchSection(&ReadOnlySection);
 
   // CP microcode requires the kernel descriptor to be allocated on 64 byte
   // alignment.
   Streamer.emitValueToAlignment(64, 0, 1, 0);
-  if (ReadOnlySection.getAlignment() < 64)
+  if (ReadOnlySection.getAlign() < 64)
     ReadOnlySection.setAlignment(Align(64));
 
   const GCNSubtarget &STM = MF->getSubtarget<GCNSubtarget>();
 
   SmallString<128> KernelName;
   getNameWithPrefix(KernelName, &MF->getFunction());
   getTargetStreamer()->EmitAmdhsaKernelDescriptor(
       STM, KernelName, getAmdhsaKernelDescriptor(*MF, CurrentProgramInfo),
       CurrentProgramInfo.NumVGPRsForWavesPerEU,

llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCELFStreamer.cpp

if (ELFSymbol->getBinding() == ELF::STB_LOCAL) {
 
     if (ELFSymbol->isUndefined()) {
       emitValueToAlignment(ByteAlignment, 0, 1, 0);
       emitLabel(Symbol);
       emitZeros(Size);
     }
 
     // Update the maximum alignment of the section if necessary.
-    if (Align(ByteAlignment) > Section.getAlignment())
+    if (Section.getAlign() < ByteAlignment)
       Section.setAlignment(Align(ByteAlignment));
 
     switchSection(P.first, P.second);
   } else {
     if (ELFSymbol->declareCommon(Size, ByteAlignment))
       report_fatal_error("Symbol: " + Symbol->getName() +
                          " redeclared as different type");
     if ((AccessSize) && (Size <= GPSize)) {

llvm/lib/Target/Mips/MCTargetDesc/MipsTargetStreamer.cpp

void MipsTargetELFStreamer::finish() {
   // .bss, .text and .data are always at least 16-byte aligned.
   MCSection &TextSection = *OFI.getTextSection();
   MCA.registerSection(TextSection);
   MCSection &DataSection = *OFI.getDataSection();
   MCA.registerSection(DataSection);
   MCSection &BSSSection = *OFI.getBSSSection();
   MCA.registerSection(BSSSection);
 
-  TextSection.setAlignment(Align(std::max(16u, TextSection.getAlignment())));
-  DataSection.setAlignment(Align(std::max(16u, DataSection.getAlignment())));
-  BSSSection.setAlignment(Align(std::max(16u, BSSSection.getAlignment())));
+  TextSection.setAlignment(std::max(Align(16), TextSection.getAlign()));
+  DataSection.setAlignment(std::max(Align(16), DataSection.getAlign()));
+  BSSSection.setAlignment(std::max(Align(16), BSSSection.getAlign()));
 
   if (RoundSectionSizes) {
     // Make sections sizes a multiple of the alignment. This is useful for
     // verifying the output of IAS against the output of other assemblers but
     // it's not necessary to produce a correct object and increases section
     // size.
     MCStreamer &OS = getStreamer();
     for (MCSection &S : MCA) {
       MCSectionELF &Section = static_cast<MCSectionELF &>(S);
 
-      unsigned Alignment = Section.getAlignment();
-      if (Alignment) {
-        OS.switchSection(&Section);
-        if (Section.useCodeAlign())
-          OS.emitCodeAlignment(Alignment, &STI, Alignment);
-        else
-          OS.emitValueToAlignment(Alignment, 0, 1, Alignment);
-      }
+      Align Alignment = Section.getAlign();
+        OS.emitCodeAlignment(Alignment.value(), &STI, Alignment.value());
+        OS.emitValueToAlignment(Alignment.value(), 0, 1, Alignment.value());
     }
   }
 
   const FeatureBitset &Features = STI.getFeatureBits();
 
   // Update e_header flags. See the FIXME and comment above in
   // the constructor for a full rundown on this.
   unsigned EFlags = MCA.getELFHeaderEFlags();

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

auto setCsectAlignment = [this](const GlobalObject *GO) {
     if (GO->isDeclarationForLinker())
       return;
 
     SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO, TM);
     MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
         getObjFileLowering().SectionForGlobal(GO, GOKind, TM));
 
     Align GOAlign = getGVAlignment(GO, GO->getParent()->getDataLayout());
-    if (GOAlign > Csect->getAlignment())
+    if (GOAlign > Csect->getAlign())
       Csect->setAlignment(GOAlign);
   };
 
   // We need to know, up front, the alignment of csects for the assembly path,
   // because once a .csect directive gets emitted, we could not change the
   // alignment value on it.
   for (const auto &G : M.globals()) {
     if (isSpecialLLVMGlobalArrayToSkip(&G))

llvm/lib/Target/X86/MCTargetDesc/X86AsmBackend.cpp

void X86AsmBackend::emitInstructionEnd(MCObjectStreamer &OS, const MCInst &Inst) {
   // DataFragment, so that we can get the size of instructions later in
   // MCAssembler::relaxBoundaryAlign. The easiest way is to insert a new empty
   // DataFragment.
   if (isa_and_nonnull<MCDataFragment>(CF))
     OS.insert(new MCDataFragment());
 
   // Update the maximum alignment on the current section if necessary.
   MCSection *Sec = OS.getCurrentSectionOnly();
-  if (AlignBoundary.value() > Sec->getAlignment())
+  if (Sec->getAlign() < AlignBoundary)
     Sec->setAlignment(AlignBoundary);
 }
 
 Optional<MCFixupKind> X86AsmBackend::getFixupKind(StringRef Name) const {
   if (STI.getTargetTriple().isOSBinFormatELF()) {
     unsigned Type;
     if (STI.getTargetTriple().getArch() == Triple::x86_64) {
       Type = llvm::StringSwitch<unsigned>(Name)

llvm/lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

private:
   /// This struct defines the shadow mapping using the rule:
   ///   shadow = (mem >> Scale) + Offset.
   /// If InGlobal is true, then
   ///   extern char __hwasan_shadow[];
   ///   shadow = (mem >> Scale) + &__hwasan_shadow
   /// If InTls is true, then
   ///   extern char *__hwasan_tls;
   ///   shadow = (mem>>Scale) + align_up(__hwasan_shadow, kShadowBaseAlignment)
   ///
   /// If WithFrameRecord is true, then __hwasan_tls will be used to access the
   /// ring buffer for storing stack allocations on targets that support it.
   struct ShadowMapping {
-    int Scale;
+    uint8_t Scale;
     uint64_t Offset;
     bool InGlobal;
     bool InTls;
     bool WithFrameRecord;
 
     void init(Triple &TargetTriple, bool InstrumentWithCalls);
-    uint64_t getObjectAlignment() const { return 1ULL << Scale; }
+    Align getObjectAlignment() const { return Align(1ULL << Scale); }
   };
 
   ShadowMapping Mapping;
 
   Type *VoidTy = Type::getVoidTy(M.getContext());
   Type *IntptrTy;
   Type *Int8PtrTy;
   Type *Int8Ty;
bool HWAddressSanitizer::instrumentMemAccess(InterestingMemoryOperand &O) {
   LLVM_DEBUG(dbgs() << "Instrumenting: " << O.getInsn() << "\n");
 
   if (O.MaybeMask)
     return false; // FIXME
 
   IRBuilder<> IRB(O.getInsn());
   if (isPowerOf2_64(O.TypeSize) &&
       (O.TypeSize / 8 <= (1ULL << (kNumberOfAccessSizes - 1))) &&
-      (!O.Alignment || *O.Alignment >= (1ULL << Mapping.Scale) ||
+      (!O.Alignment || *O.Alignment >= Mapping.getObjectAlignment() ||
        *O.Alignment >= O.TypeSize / 8)) {
     size_t AccessSizeIndex = TypeSizeToSizeIndex(O.TypeSize);
     if (InstrumentWithCalls) {
       IRB.CreateCall(HwasanMemoryAccessCallback[O.IsWrite][AccessSizeIndex],
                      IRB.CreatePointerCast(Addr, IntptrTy));
     } else if (OutlinedChecks) {
       instrumentMemAccessOutline(Addr, O.IsWrite, AccessSizeIndex, O.getInsn());
     } else {
if (InstrumentWithCalls) {
     // runtime library. That's OK, because the interceptor skips the checks if
     // the address is in the shadow region.
     // FIXME: the interceptor is not as fast as real memset. Consider lowering
     // llvm.memset right here into either a sequence of stores, or a call to
     // hwasan_tag_memory.
     if (ShadowSize)
       IRB.CreateMemSet(ShadowPtr, JustTag, ShadowSize, Align(1));
     if (Size != AlignedSize) {
-      IRB.CreateStore(
-          ConstantInt::get(Int8Ty, Size % Mapping.getObjectAlignment()),
+      const uint8_t SizeRemainder = Size % Mapping.getObjectAlignment().value();
+      IRB.CreateStore(ConstantInt::get(Int8Ty, SizeRemainder),
                       IRB.CreateConstGEP1_32(Int8Ty, ShadowPtr, ShadowSize));
       IRB.CreateStore(JustTag, IRB.CreateConstGEP1_32(
                                    Int8Ty, IRB.CreateBitCast(AI, Int8PtrTy),
                                    AlignedSize - 1));
     }
   }
 }
 
 unsigned HWAddressSanitizer::retagMask(unsigned AllocaNo) {
if (DetectUseAfterScope && StandardLifetime) {
         TagEnd(RI);
       // We inserted tagging outside of the lifetimes, so we have to remove
       // them.
       for (auto &II : Info.LifetimeStart)
         II->eraseFromParent();
       for (auto &II : Info.LifetimeEnd)
         II->eraseFromParent();
     }
-    memtag::alignAndPadAlloca(Info, Align(Mapping.getObjectAlignment()));
+    memtag::alignAndPadAlloca(Info, Mapping.getObjectAlignment());
   }
   for (auto &I : SInfo.UnrecognizedLifetimes)
     I->eraseFromParent();
   return true;
 }
 
 bool HWAddressSanitizer::sanitizeFunction(Function &F,
                                           FunctionAnalysisManager &FAM) {
void HWAddressSanitizer::instrumentGlobal(GlobalVariable *GV, uint8_t Tag) {
 
   auto *NewGV = new GlobalVariable(M, Initializer->getType(), GV->isConstant(),
                                    GlobalValue::ExternalLinkage, Initializer,
                                    GV->getName() + ".hwasan");
   NewGV->copyAttributesFrom(GV);
   NewGV->setLinkage(GlobalValue::PrivateLinkage);
   NewGV->copyMetadata(GV, 0);
   NewGV->setAlignment(
-      MaybeAlign(std::max(GV->getAlignment(), Mapping.getObjectAlignment())));
+      std::max(GV->getAlign().valueOrOne(), Mapping.getObjectAlignment()));
 
   // It is invalid to ICF two globals that have different tags. In the case
   // where the size of the global is a multiple of the tag granularity the
   // contents of the globals may be the same but the tags (i.e. symbol values)
   // may be different, and the symbols are not considered during ICF. In the
   // case where the size is not a multiple of the granularity, the short granule
   // tags would discriminate two globals with different tags, but there would
   // otherwise be nothing stopping such a global from being incorrectly ICF'd

llvm/tools/dsymutil/MachOUtils.cpp

Writer.writeSegmentLoadCommand("__DWARF", NumSections, VMAddr,
                                  FileSize, /* MaxProt */ 7,
                                  /* InitProt =*/3);
 
   for (unsigned int i = 0, n = Layout.getSectionOrder().size(); i != n; ++i) {
     MCSection *Sec = Layout.getSectionOrder()[i];
     if (Sec->begin() == Sec->end() || !Layout.getSectionFileSize(Sec))
       continue;
 
-    unsigned Align = Sec->getAlignment();
-    if (Align > 1) {
-      VMAddr = alignTo(VMAddr, Align);
-      FileOffset = alignTo(FileOffset, Align);
+    Align Alignment = Sec->getAlign();
+    if (Alignment > 1) {
+      VMAddr = alignTo(VMAddr, Alignment);
+      FileOffset = alignTo(FileOffset, Alignment);
       if (FileOffset > UINT32_MAX)
         return error("section " + Sec->getName() + "'s file offset exceeds 4GB."
             " Refusing to produce an invalid Mach-O file.");
     }
     Writer.writeSection(Layout, *Sec, VMAddr, FileOffset, 0, 0, 0);
 
     FileOffset += Layout.getSectionAddressSize(Sec);
     VMAddr += Layout.getSectionAddressSize(Sec);
bool generateDsymCompanion(
   uint64_t DwarfSegmentSize = 0;
 
   for (unsigned int i = 0, n = Layout.getSectionOrder().size(); i != n; ++i) {
     MCSection *Sec = Layout.getSectionOrder()[i];
     if (Sec->begin() == Sec->end())
       continue;
 
     if (uint64_t Size = Layout.getSectionFileSize(Sec)) {
-      DwarfSegmentSize = alignTo(DwarfSegmentSize, Sec->getAlignment());
+      DwarfSegmentSize = alignTo(DwarfSegmentSize, Sec->getAlign());
       DwarfSegmentSize += Size;
       ++NumDwarfSections;
     }
   }
 
   if (NumDwarfSections) {
     ++NumLoadCommands;
     LoadCommandSize += segmentLoadCommandSize(Is64Bit, NumDwarfSections);
bool generateDsymCompanion(
   assert(OutFile.tell() == DwarfSegmentStart);
 
   // Emit the Dwarf sections contents.
   for (const MCSection &Sec : MCAsm) {
     if (Sec.begin() == Sec.end())
       continue;
 
     uint64_t Pos = OutFile.tell();
-    OutFile.write_zeros(alignTo(Pos, Sec.getAlignment()) - Pos);
+    OutFile.write_zeros(alignTo(Pos, Sec.getAlign()) - Pos);
     MCAsm.writeSectionData(OutFile, &Sec, Layout);
   }
 
   // Apply relocations to the contents of the DWARF segment.
   // We do this here because the final value written depend on the DWARF vm
   // addr, which is only calculated in this function.
   if (!RelocationsToApply.empty()) {
     if (!OutFile.supportsSeeking())