COFF: Remove OutputSection::getPermissions() and getCharacteristics().

[pcc]

Summary

All callers can just access the header directly.

[ruiu]

LGTM

lld/COFF/Chunks.cpp

void applyBranch24T(uint8_t *Off, int32_t V) {
   // Clear out the J1 and J2 bits which may be set.
   write16le(Off + 2, (read16le(Off + 2) & 0xd000) | (J1 << 13) | (J2 << 11) | ((V >> 1) & 0x7ff));
 }
 
 void SectionChunk::applyRelARM(uint8_t *Off, uint16_t Type, OutputSection *OS,
                                uint64_t S, uint64_t P) const {
   // Pointer to thumb code must have the LSB set.
   uint64_t SX = S;
-  if (OS && (OS->getPermissions() & IMAGE_SCN_MEM_EXECUTE))
+  if (OS && (OS->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE))
     SX |= 1;
   switch (Type) {
   case IMAGE_REL_ARM_ADDR32:    add32(Off, SX + Config->ImageBase); break;
   case IMAGE_REL_ARM_ADDR32NB:  add32(Off, SX); break;
   case IMAGE_REL_ARM_MOV32T:    applyMOV32T(Off, SX + Config->ImageBase); break;
   case IMAGE_REL_ARM_BRANCH20T: applyBranch20T(Off, SX - P - 4); break;
   case IMAGE_REL_ARM_BRANCH24T: applyBranch24T(Off, SX - P - 4); break;
   case IMAGE_REL_ARM_BLX23T:    applyBranch24T(Off, SX - P - 4); break;

lld/COFF/PDB.cpp

Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       EBS, Allocator, CodeViewContainer::Pdb));
 }
 
 static void addLinkerModuleSectionSymbol(pdb::DbiModuleDescriptorBuilder &Mod,
                                          OutputSection &OS,
                                          BumpPtrAllocator &Allocator) {
   SectionSym Sym(SymbolRecordKind::SectionSym);
   Sym.Alignment = 12; // 2^12 = 4KB
-  Sym.Characteristics = OS.getCharacteristics();
+  Sym.Characteristics = OS.Header.Characteristics;
   Sym.Length = OS.getVirtualSize();
   Sym.Name = OS.Name;
   Sym.Rva = OS.getRVA();
   Sym.SectionNumber = OS.SectionIndex;
   Mod.addSymbol(codeview::SymbolSerializer::writeOneSymbol(
       Sym, Allocator, CodeViewContainer::Pdb));
 }
 
if (auto *SecChunk = dyn_cast<SectionChunk>(C)) {
     SC.Imod = SecChunk->File->ModuleDBI->getModuleIndex();
     ArrayRef<uint8_t> Contents = SecChunk->getContents();
     JamCRC CRC(0);
     ArrayRef<char> CharContents = makeArrayRef(
         reinterpret_cast<const char *>(Contents.data()), Contents.size());
     CRC.update(CharContents);
     SC.DataCrc = CRC.getCRC();
   } else {
-    SC.Characteristics = OS->getCharacteristics();
+    SC.Characteristics = OS->Header.Characteristics;
     // FIXME: When we start creating DBI for import libraries, use those here.
     SC.Imod = LinkerModule.getModuleIndex();
   }
   SC.RelocCrc = 0; // FIXME
   Builder.getDbiBuilder().addSectionContrib(SC);
 }
 
 void PDBLinker::addSections(ArrayRef<OutputSection *> OutputSections,

lld/COFF/Writer.h

 // non-overlapping file offsets and RVAs.
 class OutputSection {
 public:
   OutputSection(llvm::StringRef N) : Name(N), Header({}) {}
   void addChunk(Chunk *C);
   ArrayRef<Chunk *> getChunks() { return Chunks; }
   void addPermissions(uint32_t C);
   void setPermissions(uint32_t C);
-  uint32_t getPermissions() { return Header.Characteristics & PermMask; }
-  uint32_t getCharacteristics() { return Header.Characteristics; }
   uint64_t getRVA() { return Header.VirtualAddress; }
   uint64_t getFileOff() { return Header.PointerToRawData; }
   void writeHeaderTo(uint8_t *Buf);
 
   // Returns the size of this section in an executable memory image.
   // This may be smaller than the raw size (the raw size is multiple
   // of disk sector size, so there may be padding at end), or may be
   // larger (if that's the case, the loader reserves spaces after end

lld/COFF/Writer.cpp

void Writer::createSections() {
   // Finally, move some output sections to the end.
   auto SectionOrder = [&](OutputSection *S) {
     // .reloc should come last of all since it refers to RVAs of data in the
     // previous sections.
     if (S == RelocSec)
       return 3;
     // Move DISCARDABLE (or non-memory-mapped) sections to the end of file because
     // the loader cannot handle holes.
-    if (S->getPermissions() & IMAGE_SCN_MEM_DISCARDABLE)
+    if (S->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE)
       return 2;
     // .rsrc should come at the end of the non-discardable sections because its
     // size may change by the Win32 UpdateResources() function, causing
     // subsequent sections to move (see https://crbug.com/827082).
     if (S == RsrcSec)
       return 1;
     return 0;
   };
void Writer::createSymbolAndStringTable() {
   // link.exe always truncates section names to 8 bytes, whereas binutils always
   // preserves long section names via the string table. LLD adopts a hybrid
   // solution where discardable sections have long names preserved and
   // non-discardable sections have their names truncated, to ensure that any
   // section which is mapped at runtime also has its name mapped at runtime.
   for (OutputSection *Sec : OutputSections) {
     if (Sec->Name.size() <= COFF::NameSize)
       continue;
-    if ((Sec->getPermissions() & IMAGE_SCN_MEM_DISCARDABLE) == 0)
+    if ((Sec->Header.Characteristics & IMAGE_SCN_MEM_DISCARDABLE) == 0)
       continue;
     Sec->setStringTableOff(addEntryToStringTable(Sec->Name));
   }
 
   if (Config->DebugDwarf) {
     for (ObjFile *File : ObjFile::Instances) {
       for (Symbol *B : File->getSymbols()) {
         auto *D = dyn_cast_or_null<Defined>(B);
for (Chunk *C : File->getChunks()) {
     // sections.
     for (Symbol *Ref : SC->symbols()) {
       // FIXME: Do further testing to see if the relocation type matters,
       // especially for 32-bit where taking the address of something usually
       // uses an absolute relocation instead of a relative one.
       if (auto *D = dyn_cast_or_null<Defined>(Ref)) {
         Chunk *RefChunk = D->getChunk();
         OutputSection *OS = RefChunk ? RefChunk->getOutputSection() : nullptr;
-        if (OS && OS->getPermissions() & IMAGE_SCN_MEM_EXECUTE)
+        if (OS && OS->Header.Characteristics & IMAGE_SCN_MEM_EXECUTE)
           addSymbolToRVASet(UsedSymbols, D);
       }
     }
   }
 }
 
 // Create the guard function id table. This is a table of RVAs of all
 // address-taken functions. It is sorted and uniqued, just like the safe SEH
void Writer::writeSections() {
   DefinedAbsolute::NumOutputSections = OutputSections.size();
 
   uint8_t *Buf = Buffer->getBufferStart();
   for (OutputSection *Sec : OutputSections) {
     uint8_t *SecBuf = Buf + Sec->getFileOff();
     // Fill gaps between functions in .text with INT3 instructions
     // instead of leaving as NUL bytes (which can be interpreted as
     // ADD instructions).
-    if (Sec->getPermissions() & IMAGE_SCN_CNT_CODE)
+    if (Sec->Header.Characteristics & IMAGE_SCN_CNT_CODE)
       memset(SecBuf, 0xCC, Sec->getRawSize());
     for_each(parallel::par, Sec->getChunks().begin(), Sec->getChunks().end(),
              [&](Chunk *C) { C->writeTo(SecBuf); });
   }
 }
 
 void Writer::writeBuildId() {
   // There are two important parts to the build ID.
for (OutputSection *Sec : OutputSections)
     if (Sec->Name == Name)
       return Sec;
   return nullptr;
 }
 
 uint32_t Writer::getSizeOfInitializedData() {
   uint32_t Res = 0;
   for (OutputSection *S : OutputSections)
-    if (S->getPermissions() & IMAGE_SCN_CNT_INITIALIZED_DATA)
+    if (S->Header.Characteristics & IMAGE_SCN_CNT_INITIALIZED_DATA)
       Res += S->getRawSize();
   return Res;
 }
 
 // Add base relocations to .reloc section.
 void Writer::addBaserels() {
   if (!Config->Relocatable)
     return;