[lld][Alignment] Use Align in ELF Sections

[gchatelet]

Summary

Follow up on D139181.
Here we assume that alignExpr contains a valid value (i.e. non zero power of 2).
It was already somewhat assumed but not checked. This will now crash if it's not the case.

[arichardson]

lld/ELF/InputSection.h

74

Moving it after partition should allow it to fit into padding bytes

[gchatelet]

lld/ELF/InputSection.h

74

I moved the field around but it didn't improve the situation
https://godbolt.org/z/vYchbnME5

[arichardson]

If you look at the -Xclang -fdump-record-layouts output you can see that it does improve the requirerd size, but due to the 8 byte alignment requirement it is still rounded up to 48 (for 64-bit architectures). However, for 32-bit arch reordering does help: 36 vs 40 bytes.

*** Dumping AST Record Layout
         0 | struct OutputSegment
     0:0-2 |   uint8_t sectionKind
     0:3-3 |   uint8_t bss
     0:4-4 |   uint8_t keepUnique
         1 |   uint8_t partition
         2 |   struct llvm::Align addralign
         2 |     uint8_t ShiftValue
         4 |   uint32_t type
         8 |   class llvm::StringRef name
         8 |     const char * Data
        16 |     size_t Length
        24 |   uint64_t flags
        32 |   uint32_t entsize
        36 |   uint32_t link
        40 |   uint32_t info
           | [sizeof=48, dsize=44, align=8,
           |  nvsize=44, nvalign=8]

Whereas the current patch has sizeof==dsize:

*** Dumping AST Record Layout
         0 | struct OutputSegment
     0:0-2 |   uint8_t sectionKind
     0:3-3 |   uint8_t bss
     0:4-4 |   uint8_t keepUnique
         1 |   uint8_t partition
         4 |   uint32_t type
         8 |   class llvm::StringRef name
         8 |     const char * Data
        16 |     size_t Length
        24 |   uint64_t flags
        32 |   struct llvm::Align addralign
        32 |     uint8_t ShiftValue
        36 |   uint32_t entsize
        40 |   uint32_t link
        44 |   uint32_t info
           | [sizeof=48, dsize=48, align=8,
           |  nvsize=48, nvalign=8]

[MaskRay]

With this patch, the final lld executable is larger and some call sites are more complex.
llvm::Align probably won't improve lld/ELF (and the extra dependency llvm/Support/Alignment.h and MathExtras.h is somewhat unnecessary).
I've checked using p2align for lld::elf::Symbol, but I think it won't decrease the struct size and will likely lead to no less code size in most call sites.

Note: I think struct size for 32-bit systems isn't really necessary. The 64-bit system behavior is much more interesting.

lld/ELF/InputFiles.cpp

if (sec.sh_type == SHT_REL || sec.sh_type == SHT_RELA) {
 
       // ELF spec allows mergeable sections with relocations, but they are rare,
       // and it is in practice hard to merge such sections by contents, because
       // applying relocations at end of linking changes section contents. So, we
       // simply handle such sections as non-mergeable ones. Degrading like this
       // is acceptable because section merging is optional.
       if (auto *ms = dyn_cast<MergeInputSection>(s)) {
         s = makeThreadLocal<InputSection>(
-            ms->file, ms->flags, ms->type, ms->addralign,
+            ms->file, ms->flags, ms->type, ms->addralign.value(),
             ms->contentMaybeDecompress(), ms->name);
         sections[info] = s;
       }
 
       if (s->relSecIdx != 0)
         error(
             toString(s) +
             ": multiple relocation sections to one section are not supported");

lld/ELF/InputSection.h

public:
 
   // The 1-indexed partition that this section is assigned to by the garbage
   // collector, or 0 if this section is dead. Normally there is only one
   // partition, so this will either be 0 or 1.
   elf::Partition &getPartition() const;
 
   // These corresponds to the fields in Elf_Shdr.
   uint64_t flags;
-  uint32_t addralign;
+  llvm::Align addralign;
   uint32_t entsize;
   uint32_t link;
   uint32_t info;
 
   OutputSection *getOutputSection();
   const OutputSection *getOutputSection() const {
     return const_cast<SectionBase *>(this)->getOutputSection();
   }
 
   // Translate an offset in the input section to an offset in the output
   // section.
   uint64_t getOffset(uint64_t offset) const;
 
   uint64_t getVA(uint64_t offset = 0) const;
 
   bool isLive() const { return partition != 0; }
   void markLive() { partition = 1; }
   void markDead() { partition = 0; }
 
 protected:
   constexpr SectionBase(Kind sectionKind, StringRef name, uint64_t flags,
-                        uint32_t entsize, uint32_t addralign, uint32_t type,
+                        uint32_t entsize, llvm::Align addralign, uint32_t type,
                         uint32_t info, uint32_t link)
       : sectionKind(sectionKind), bss(false), keepUnique(false), type(type),
         name(name), flags(flags), addralign(addralign), entsize(entsize),
         link(link), info(info) {}
 };
 
 struct RISCVRelaxAux;
 

lld/ELF/InputSection.cpp

static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &file,
   return check(file.getObj().getSectionContents(hdr));
 }
 
 InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags,
                                    uint32_t type, uint64_t entsize,
                                    uint32_t link, uint32_t info,
                                    uint32_t addralign, ArrayRef<uint8_t> data,
                                    StringRef name, Kind sectionKind)
-    : SectionBase(sectionKind, name, flags, entsize, addralign, type, info,
-                  link),
+    : SectionBase(sectionKind, name, flags, entsize,
+                  /*overrode below after validation*/ llvm::Align(1), type,
+                  info, link),
       file(file), content_(data.data()), size(data.size()) {
+  // The ELF spec states that a value of 0 means the section has
+  // no alignment constraints.
+  if (addralign != 0 && !isPowerOf2_64(addralign))
+    fatal(toString(this) + ": sh_addralign is not a power of 2");
+  this->addralign = llvm::MaybeAlign(addralign).valueOrOne();
+
   // In order to reduce memory allocation, we assume that mergeable
   // sections are smaller than 4 GiB, which is not an unreasonable
   // assumption as of 2017.
   if (sectionKind == SectionBase::Merge && content().size() > UINT32_MAX)
     error(toString(this) + ": section too large");
 
-  // The ELF spec states that a value of 0 means the section has
-  // no alignment constraints.
-  uint32_t v = std::max<uint32_t>(addralign, 1);
-  if (!isPowerOf2_64(v))
-    fatal(toString(this) + ": sh_addralign is not a power of 2");
-  this->addralign = v;
-
   // If SHF_COMPRESSED is set, parse the header. The legacy .zdebug format is no
   // longer supported.
   if (flags & SHF_COMPRESSED)
     invokeELFT(parseCompressedHeader);
 }
 
 // Drop SHF_GROUP bit unless we are producing a re-linkable object file.
 // SHF_GROUP is a marker that a section belongs to some comdat group.
if (hdr->ch_type == ELFCOMPRESS_ZLIB) {
     error(toString(this) + ": unsupported compression type (" +
           Twine(hdr->ch_type) + ")");
     return;
   }
 
   compressed = true;
   compressedSize = size;
   size = hdr->ch_size;
-  addralign = std::max<uint32_t>(hdr->ch_addralign, 1);
+  addralign = llvm::MaybeAlign(hdr->ch_addralign).valueOrOne();
 }
 
 InputSection *InputSectionBase::getLinkOrderDep() const {
   assert(flags & SHF_LINK_ORDER);
   if (!link)
     return nullptr;
   return cast<InputSection>(file->getSections()[link]);
 }

lld/ELF/LinkerScript.h

struct ExprValue {
   ExprValue(SectionBase *sec, bool forceAbsolute, uint64_t val,
             const Twine &loc)
       : sec(sec), val(val), forceAbsolute(forceAbsolute), loc(loc.str()) {}
 
   ExprValue(uint64_t val) : ExprValue(nullptr, false, val, "") {}
 
   bool isAbsolute() const { return forceAbsolute || sec == nullptr; }
   uint64_t getValue() const;
+  llvm::Align getValueAsAlign() const { return llvm::Align(getValue()); }
   uint64_t getSecAddr() const;
   uint64_t getSectionOffset() const;
 
   // If a value is relative to a section, it has a non-null Sec.
   SectionBase *sec;
 
   uint64_t val;
   uint64_t alignment = 1;

lld/ELF/LinkerScript.cpp

if (!matchConstraints(v, osec->constraint)) {
       osec->commands.clear();
       return false;
     }
 
     // Handle subalign (e.g. ".foo : SUBALIGN(32) { ... }"). If subalign
     // is given, input sections are aligned to that value, whether the
     // given value is larger or smaller than the original section alignment.
     if (osec->subalignExpr) {
-      uint32_t subalign = osec->subalignExpr().getValue();
+      llvm::Align subalign = osec->subalignExpr().getValueAsAlign();
       for (InputSectionBase *s : v)
         s->addralign = subalign;
     }
 
     // Set the partition field the same way OutputSection::recordSection()
     // does. Partitions cannot be used with the SECTIONS command, so this is
     // always 1.
     osec->partition = 1;
void LinkerScript::assignOffsets(OutputSection *sec) {
   state->outSec = sec;
   if (sec->addrExpr && script->hasSectionsCommand) {
     // The alignment is ignored.
     sec->addr = dot;
   } else {
     // sec->alignment is the max of ALIGN and the maximum of input
     // section alignments.
     const uint64_t pos = dot;
-    dot = alignToPowerOf2(dot, sec->addralign);
+    dot = alignTo(dot, sec->addralign);
     sec->addr = dot;
     expandMemoryRegions(dot - pos);
   }
 
   // state->lmaOffset is LMA minus VMA. If LMA is explicitly specified via AT()
   // or AT>, recompute state->lmaOffset; otherwise, if both previous/current LMA
   // region is the default, and the two sections are in the same memory region,
   // reuse previous lmaOffset; otherwise, reset lmaOffset to 0. This emulates
   // heuristics described in
   // https://sourceware.org/binutils/docs/ld/Output-Section-LMA.html
   if (sec->lmaExpr) {
     state->lmaOffset = sec->lmaExpr().getValue() - dot;
   } else if (MemoryRegion *mr = sec->lmaRegion) {
-    uint64_t lmaStart = alignToPowerOf2(mr->curPos, sec->addralign);
+    uint64_t lmaStart = alignTo(mr->curPos, sec->addralign);
     if (mr->curPos < lmaStart)
       expandMemoryRegion(mr, lmaStart - mr->curPos, sec->name);
     state->lmaOffset = lmaStart - dot;
   } else if (!sameMemRegion || !prevLMARegionIsDefault) {
     state->lmaOffset = 0;
   }
 
   // Propagate state->lmaOffset to the first "non-header" section.
for (SectionCommand *cmd : sec->commands) {
     }
 
     // Handle a single input section description command.
     // It calculates and assigns the offsets for each section and also
     // updates the output section size.
     for (InputSection *isec : cast<InputSectionDescription>(cmd)->sections) {
       assert(isec->getParent() == sec);
       const uint64_t pos = dot;
-      dot = alignToPowerOf2(dot, isec->addralign);
+      dot = alignTo(dot, isec->addralign);
       isec->outSecOff = dot - sec->addr;
       dot += isec->getSize();
 
       // Update output section size after adding each section. This is so that
       // SIZEOF works correctly in the case below:
       // .foo { *(.aaa) a = SIZEOF(.foo); *(.bbb) }
       expandOutputSection(dot - pos);
     }
void LinkerScript::adjustOutputSections() {
   for (SectionCommand *&cmd : sectionCommands) {
     if (!isa<OutputDesc>(cmd))
       continue;
     auto *sec = &cast<OutputDesc>(cmd)->osec;
 
     // Handle align (e.g. ".foo : ALIGN(16) { ... }").
     if (sec->alignExpr)
       sec->addralign =
-          std::max<uint32_t>(sec->addralign, sec->alignExpr().getValue());
+          std::max(sec->addralign, sec->alignExpr().getValueAsAlign());
 
     bool isEmpty = (getFirstInputSection(sec) == nullptr);
     bool discardable = isEmpty && isDiscardable(*sec);
     // If sec has at least one input section and not discarded, remember its
     // flags to be inherited by subsequent output sections. (sec may contain
     // just one empty synthetic section.)
     if (sec->hasInputSections && !discardable)
       flags = sec->flags;

lld/ELF/MapFile.cpp

if (auto *assign = dyn_cast<SymbolAssignment>(cmd)) {
         continue;
       uint64_t lma = osec ? osec->getLMA() + assign->addr - osec->getVA(0) : 0;
       writeHeader(os, assign->addr, lma, assign->size, 1);
       os << assign->commandString << '\n';
       continue;
     }
 
     osec = &cast<OutputDesc>(cmd)->osec;
-    writeHeader(os, osec->addr, osec->getLMA(), osec->size, osec->addralign);
+    writeHeader(os, osec->addr, osec->getLMA(), osec->size,
+                osec->addralign.value());
     os << osec->name << '\n';
 
     // Dump symbols for each input section.
     for (SectionCommand *subCmd : osec->commands) {
       if (auto *isd = dyn_cast<InputSectionDescription>(subCmd)) {
         for (InputSection *isec : isd->sections) {
           if (auto *ehSec = dyn_cast<EhFrameSection>(isec)) {
             printEhFrame(os, ehSec);
             continue;
           }
 
           writeHeader(os, isec->getVA(), osec->getLMA() + isec->outSecOff,
-                      isec->getSize(), isec->addralign);
+                      isec->getSize(), isec->addralign.value());
           os << indent8 << toString(isec) << '\n';
           for (Symbol *sym : llvm::make_first_range(sectionSyms[isec]))
             os << symStr[sym] << '\n';
         }
         continue;
       }
 
       if (auto *data = dyn_cast<ByteCommand>(subCmd)) {

lld/ELF/OutputSections.cpp

uint32_t OutputSection::getPhdrFlags() const {
   if (flags & SHF_EXECINSTR)
     ret |= PF_X;
   return ret;
 }
 
 template <class ELFT>
 void OutputSection::writeHeaderTo(typename ELFT::Shdr *shdr) {
   shdr->sh_entsize = entsize;
-  shdr->sh_addralign = addralign;
+  shdr->sh_addralign = addralign.value();
   shdr->sh_type = type;
   shdr->sh_offset = offset;
   shdr->sh_flags = flags;
   shdr->sh_info = info;
   shdr->sh_link = link;
   shdr->sh_addr = addr;
   shdr->sh_size = size;
   shdr->sh_name = shName;
 }
 
 OutputSection::OutputSection(StringRef name, uint32_t type, uint64_t flags)
-    : SectionBase(Output, name, flags, /*Entsize*/ 0, /*Alignment*/ 1, type,
+    : SectionBase(Output, name, flags, /*Entsize*/ 0, llvm::Align(1), type,
                   /*Info*/ 0, /*Link*/ 0) {}
 
 // We allow sections of types listed below to merged into a
 // single progbits section. This is typically done by linker
 // scripts. Merging nobits and progbits will force disk space
 // to be allocated for nobits sections. Other ones don't require
 // any special treatment on top of progbits, so there doesn't
 // seem to be a harm in merging them.
for (InputSectionBase *s : isd->sectionBases) {
         // Using Entsize in here also allows us to propagate it to the synthetic
         // section.
         //
         // SHF_STRINGS section with different alignments should not be merged.
         return sec->flags == ms->flags && sec->entsize == ms->entsize &&
                (sec->addralign == ms->addralign || !(sec->flags & SHF_STRINGS));
       });
       if (i == mergeSections.end()) {
-        MergeSyntheticSection *syn =
-            createMergeSynthetic(name, ms->type, ms->flags, ms->addralign);
+        MergeSyntheticSection *syn = createMergeSynthetic(
+            name, ms->type, ms->flags, ms->addralign.value());
         mergeSections.push_back(syn);
         i = std::prev(mergeSections.end());
         syn->entsize = ms->entsize;
         isd->sections.push_back(syn);
       }
       (*i)->addSection(ms);
     }
 
if (type == SHT_NOBITS)
     return;
 
   // If --compress-debug-section is specified and if this is a debug section,
   // we've already compressed section contents. If that's the case,
   // just write it down.
   if (compressed.shards) {
     auto *chdr = reinterpret_cast<typename ELFT::Chdr *>(buf);
     chdr->ch_size = compressed.uncompressedSize;
-    chdr->ch_addralign = addralign;
+    chdr->ch_addralign = addralign.value();
     buf += sizeof(*chdr);
     if (config->compressDebugSections == DebugCompressionType::Zstd) {
       chdr->ch_type = ELFCOMPRESS_ZSTD;
       memcpy(buf, compressed.shards[0].data(), compressed.shards[0].size());
       return;
     }
     chdr->ch_type = ELFCOMPRESS_ZLIB;
 

lld/ELF/ScriptParser.cpp

return [=] {
       return v;
     };
   }
   if (tok == "ALIGNOF") {
     StringRef name = readParenLiteral();
     OutputSection *osec = &script->getOrCreateOutputSection(name)->osec;
     return [=] {
       checkIfExists(*osec, location);
-      return osec->addralign;
+      return osec->addralign.value();
     };
   }
   if (tok == "ASSERT")
     return readAssert();
   if (tok == "CONSTANT")
     return readConstant();
   if (tok == "DATA_SEGMENT_ALIGN") {
     expect("(");

lld/ELF/SyntheticSections.cpp

void MipsGotSection::build() {
   for (FileGot &got : gots) {
     for (std::pair<const OutputSection *, FileGot::PageBlock> &p :
          got.pagesMap) {
       const OutputSection *os = p.first;
       uint64_t secSize = 0;
       for (SectionCommand *cmd : os->commands) {
         if (auto *isd = dyn_cast<InputSectionDescription>(cmd))
           for (InputSection *isec : isd->sections) {
-            uint64_t off = alignToPowerOf2(secSize, isec->addralign);
+            uint64_t off = alignTo(secSize, isec->addralign);
             secSize = off + isec->getSize();
           }
       }
       p.second.count = getMipsPageCount(secSize);
     }
   }
 
   // Merge GOTs. Try to join as much as possible GOTs but do not exceed
for (SymbolTableEntry &ent : symbols) {
     eSym->st_name = ent.strTabOffset;
     eSym->setBindingAndType(sym->binding, sym->type);
     eSym->st_other = sym->stOther;
 
     if (BssSection *commonSec = getCommonSec(sym)) {
       // When -r is specified, a COMMON symbol is not allocated. Its st_shndx
       // holds SHN_COMMON and st_value holds the alignment.
       eSym->st_shndx = SHN_COMMON;
-      eSym->st_value = commonSec->addralign;
+      eSym->st_value = commonSec->addralign.value();
       eSym->st_size = cast<Defined>(sym)->size;
     } else {
       const uint32_t shndx = getSymSectionIndex(sym);
       if (isDefinedHere) {
         eSym->st_shndx = shndx;
         eSym->st_value = sym->getVA();
         // Copy symbol size if it is a defined symbol. st_size is not
         // significant for undefined symbols, so whether copying it or not is up

 }
 
 PltSection::PltSection()
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".plt"),
       headerSize(target->pltHeaderSize) {
   // On PowerPC, this section contains lazy symbol resolvers.
   if (config->emachine == EM_PPC64) {
     name = ".glink";
-    addralign = 4;
+    addralign = llvm::Align(4);
   }
 
   // On x86 when IBT is enabled, this section contains the second PLT (lazy
   // symbol resolvers).
   if ((config->emachine == EM_386 || config->emachine == EM_X86_64) &&
       (config->andFeatures & GNU_PROPERTY_X86_FEATURE_1_IBT))
     name = ".plt.sec";
 
for (size_t i = 0; i < entries.size(); ++i) {
     off += target->pltEntrySize;
   }
 }
 
 IpltSection::IpltSection()
     : SyntheticSection(SHF_ALLOC | SHF_EXECINSTR, SHT_PROGBITS, 16, ".iplt") {
   if (config->emachine == EM_PPC || config->emachine == EM_PPC64) {
     name = ".glink";
-    addralign = 4;
+    addralign = llvm::Align(4);
   }
 }
 
 void IpltSection::writeTo(uint8_t *buf) {
   uint32_t off = 0;
   for (const Symbol *sym : entries) {
     target->writeIplt(buf + off, *sym, getVA() + off);
     off += target->ipltEntrySize;
void IpltSection::addSymbols() {
   for (size_t i = 0, e = entries.size(); i != e; ++i) {
     target->addPltSymbols(*this, off);
     off += target->pltEntrySize;
   }
 }
 
 PPC32GlinkSection::PPC32GlinkSection() {
   name = ".glink";
-  addralign = 4;
+  addralign = llvm::Align(4);
 }
 
 void PPC32GlinkSection::writeTo(uint8_t *buf) {
   writePPC32GlinkSection(buf, entries.size());
 }
 
 size_t PPC32GlinkSection::getSize() const {
   return headerSize + entries.size() * target->pltEntrySize + footerSize;
parallelFor(0, concurrency, [&](size_t threadId) {
     }
   });
 
   // Compute an in-section offset for each shard.
   size_t off = 0;
   for (size_t i = 0; i < numShards; ++i) {
     shards[i].finalizeInOrder();
     if (shards[i].getSize() > 0)
-      off = alignToPowerOf2(off, addralign);
+      off = alignTo(off, addralign);
     shardOffsets[i] = off;
     off += shards[i].getSize();
   }
   size = off;
 
   // So far, section pieces have offsets from beginning of shards, but
   // we want offsets from beginning of the whole section. Fix them.
   parallelForEach(sections, [&](MergeInputSection *sec) {

lld/ELF/Writer.cpp

if (needsInterpSection()) {
     }
   }
 
   auto add = [](SyntheticSection &sec) { ctx.inputSections.push_back(&sec); };
 
   in.shStrTab = std::make_unique<StringTableSection>(".shstrtab", false);
 
   Out::programHeaders = make<OutputSection>("", 0, SHF_ALLOC);
-  Out::programHeaders->addralign = config->wordsize;
+  Out::programHeaders->addralign = llvm::Align(config->wordsize);
 
   if (config->strip != StripPolicy::All) {
     in.strTab = std::make_unique<StringTableSection>(".strtab", false);
     in.symTab = std::make_unique<SymbolTableSection<ELFT>>(*in.strTab);
     in.symTabShndx = std::make_unique<SymtabShndxSection>();
   }
 
   in.bss = std::make_unique<BssSection>(".bss", 0, 1);
return config->sectionStartMap.lookup(a->name) <
            config->sectionStartMap.lookup(b->name);
   return false;
 }
 
 void PhdrEntry::add(OutputSection *sec) {
   lastSec = sec;
   if (!firstSec)
     firstSec = sec;
-  p_align = std::max(p_align, sec->addralign);
+  p_align = std::max(p_align, (uint32_t)sec->addralign.value());
   if (p_type == PT_LOAD)
     sec->ptLoad = this;
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
if (config->relocatable)
     for (OutputSection *sec : outputSections)
       sec->addr = 0;
 
   // If addrExpr is set, the address may not be a multiple of the alignment.
   // Warn because this is error-prone.
   for (SectionCommand *cmd : script->sectionCommands)
     if (auto *osd = dyn_cast<OutputDesc>(cmd)) {
       OutputSection *osec = &osd->osec;
-      if (osec->addr % osec->addralign != 0)
+      if (!isAligned(osec->addralign, osec->addr))
         warn("address (0x" + Twine::utohexstr(osec->addr) + ") of section " +
              osec->name + " is not a multiple of alignment (" +
-             Twine(osec->addralign) + ")");
+             Twine(osec->addralign.value()) + ")");
     }
 }
 
 // If Input Sections have been shrunk (basic block sections) then
 // update symbol values and sizes associated with these sections.  With basic
 // block sections, input sections can shrink when the jump instructions at
 // the end of the section are relaxed.
 static void fixSymbolsAfterShrinking() {

 // This is achieved by assigning an alignment expression to addrExpr of each
 // such section.
 template <class ELFT> void Writer<ELFT>::fixSectionAlignments() {
   const PhdrEntry *prev;
   auto pageAlign = [&](const PhdrEntry *p) {
     OutputSection *cmd = p->firstSec;
     if (!cmd)
       return;
-    cmd->alignExpr = [align = cmd->addralign]() { return align; };
+    cmd->alignExpr = [align = cmd->addralign]() { return align.value(); };
     if (!cmd->addrExpr) {
       // Prefer advancing to align(dot, maxPageSize) + dot%maxPageSize to avoid
       // padding in the file contents.
       //
       // When -z separate-code is used we must not have any overlap in pages
       // between an executable segment and a non-executable segment. We align to
       // the next maximum page size boundary on transitions between executable
       // and non-executable segments.
static uint64_t computeFileOffset(OutputSection *os, uint64_t off) {
   // in a PT_LOAD/PT_TLS. By convention, we keep section offsets monotonically
   // increasing rather than setting to zero.
   if (os->type == SHT_NOBITS &&
       (!Out::tlsPhdr || Out::tlsPhdr->firstSec != os))
      return off;
 
   // If the section is not in a PT_LOAD, we just have to align it.
   if (!os->ptLoad)
-     return alignToPowerOf2(off, os->addralign);
+     return alignTo(off, os->addralign);
 
   // If two sections share the same PT_LOAD the file offset is calculated
   // using this formula: Off2 = Off1 + (VA2 - VA1).
   OutputSection *first = os->ptLoad->firstSec;
   return first->offset + os->addr - first->addr;
 }
 
 template <class ELFT> void Writer<ELFT>::assignFileOffsetsBinary() {
for (OutputSection *sec : outputSections) {
     // segment is the last loadable segment, align the offset of the
     // following section to avoid loading non-segments parts of the file.
     if (config->zSeparate != SeparateSegmentKind::None && lastRX &&
         lastRX->lastSec == sec)
       off = alignToPowerOf2(off, config->maxPageSize);
   }
   for (OutputSection *osec : outputSections)
     if (!(osec->flags & SHF_ALLOC)) {
-      osec->offset = alignToPowerOf2(off, osec->addralign);
+      osec->offset = alignTo(off, osec->addralign);
       off = osec->offset + osec->size;
     }
 
   sectionHeaderOff = alignToPowerOf2(off, config->wordsize);
   fileSize = sectionHeaderOff + (outputSections.size() + 1) * sizeof(Elf_Shdr);
 
   // Our logic assumes that sections have rising VA within the same segment.
   // With use of linker scripts it is possible to violate this rule and get file