Move some flag-like props from GlobalContext and TargetLowering to ClFlags.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the writer for ELF relocatable object files.
@@ skipping 46 matching lines @@
 uint32_t getELFFlags(TargetArch Arch) {
   if (Arch < TargetArch_NUM)
     return ELFTargetInfo[Arch].ELFFlags;
   llvm_unreachable("Invalid target arch for getELFFlags");
   return 0;
 }
 
 } // end of anonymous namespace
 
 ELFObjectWriter::ELFObjectWriter(GlobalContext &Ctx, ELFStreamer &Out)
-    : Ctx(Ctx), Str(Out), SectionNumbersAssigned(false) {
+    : Ctx(Ctx), Str(Out), SectionNumbersAssigned(false),
+      ELF64(isELF64(Ctx.getFlags().getTargetArch())) {
   // Create the special bookkeeping sections now.
   const IceString NullSectionName("");
   NullSection = new (Ctx.allocate<ELFSection>())
       ELFSection(NullSectionName, SHT_NULL, 0, 0, 0);
 
   const IceString ShStrTabName(".shstrtab");
   ShStrTab = new (Ctx.allocate<ELFStringTableSection>())
       ELFStringTableSection(ShStrTabName, SHT_STRTAB, 0, 1, 0);
   ShStrTab->add(ShStrTabName);
 
   const IceString SymTabName(".symtab");
-  bool IsELF64 = isELF64(Ctx.getTargetArch());
-  const Elf64_Xword SymTabAlign = IsELF64 ? 8 : 4;
+  const Elf64_Xword SymTabAlign = ELF64 ? 8 : 4;
   const Elf64_Xword SymTabEntSize =
-      IsELF64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);
+      ELF64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);
   static_assert(sizeof(Elf64_Sym) == 24 && sizeof(Elf32_Sym) == 16,
                 "Elf_Sym sizes cannot be derived from sizeof");
   SymTab = createSection<ELFSymbolTableSection>(SymTabName, SHT_SYMTAB, 0,
                                                 SymTabAlign, SymTabEntSize);
   SymTab->createNullSymbol(NullSection);
 
   const IceString StrTabName(".strtab");
   StrTab =
       createSection<ELFStringTableSection>(StrTabName, SHT_STRTAB, 0, 1, 0);
 }
 
 template <typename T>
 T *ELFObjectWriter::createSection(const IceString &Name, Elf64_Word ShType,
                                   Elf64_Xword ShFlags, Elf64_Xword ShAddralign,
                                   Elf64_Xword ShEntsize) {
   assert(!SectionNumbersAssigned);
   T *NewSection =
       new (Ctx.allocate<T>()) T(Name, ShType, ShFlags, ShAddralign, ShEntsize);
   ShStrTab->add(Name);
   return NewSection;
 }
 
 ELFRelocationSection *
-ELFObjectWriter::createRelocationSection(bool IsELF64,
-                                         const ELFSection *RelatedSection) {
+ELFObjectWriter::createRelocationSection(const ELFSection *RelatedSection) {
   // Choice of RELA vs REL is actually separate from elf64 vs elf32,
   // but in practice we've only had .rela for elf64 (x86-64).
   // In the future, the two properties may need to be decoupled
   // and the ShEntSize can vary more.
-  const Elf64_Word ShType = IsELF64 ? SHT_RELA : SHT_REL;
-  IceString RelPrefix = IsELF64 ? ".rela" : ".rel";
+  const Elf64_Word ShType = ELF64 ? SHT_RELA : SHT_REL;
+  IceString RelPrefix = ELF64 ? ".rela" : ".rel";
   IceString RelSectionName = RelPrefix + RelatedSection->getName();
-  const Elf64_Xword ShAlign = IsELF64 ? 8 : 4;
-  const Elf64_Xword ShEntSize =
-      IsELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
+  const Elf64_Xword ShAlign = ELF64 ? 8 : 4;
+  const Elf64_Xword ShEntSize = ELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
   static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
                 "Elf_Rel/Rela sizes cannot be derived from sizeof");
   const Elf64_Xword ShFlags = 0;
   ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
       RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
   RelSection->setRelatedSection(RelatedSection);
   return RelSection;
 }
 
 template <typename UserSectionList>
@@ skipping 85 matching lines @@
 void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
                                         bool IsInternal, const Assembler *Asm) {
   assert(!SectionNumbersAssigned);
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
   const bool FunctionSections = Ctx.getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
     IceString SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
-    bool IsELF64 = isELF64(Ctx.getTargetArch());
     const Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     const Elf64_Xword ShAlign = 1 << Asm->getBundleAlignLog2Bytes();
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
-    RelSection = createRelocationSection(IsELF64, Section);
+    RelSection = createRelocationSection(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
     RelSection = RelTextSections[0];
   }
   RelocOffsetT OffsetInSection = Section->getCurrentSize();
   // Function symbols are set to 0 size in the symbol table,
   // in contrast to data symbols which have a proper size.
   SizeT SymbolSize = 0;
   Section->appendData(Str, Asm->getBufferView());
@@ skipping 46 matching lines @@
 } // end of anonymous namespace
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind) {
   assert(!SectionNumbersAssigned);
   VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
   partitionGlobalsBySection(Vars, VarsBySection,
                             Ctx.getFlags().getTranslateOnly());
-  bool IsELF64 = isELF64(Ctx.getTargetArch());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
-    writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
-                    IsELF64);
+    writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind);
   }
 }
 
 void ELFObjectWriter::writeDataOfType(SectionType ST,
                                       const VariableDeclarationList &Vars,
-                                      FixupKind RelocationKind, bool IsELF64) {
+                                      FixupKind RelocationKind) {
   if (Vars.empty())
     return;
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   // TODO(jvoung): Handle fdata-sections.
   IceString SectionName;
   Elf64_Xword ShAddralign = 1;
   for (VariableDeclaration *Var : Vars) {
     Elf64_Xword Align = Var->getAlignment();
     ShAddralign = std::max(ShAddralign, Align);
   }
   const Elf64_Xword ShEntsize = 0; // non-uniform data element size.
   // Lift this out, so it can be re-used if we do fdata-sections?
   switch (ST) {
   case ROData: {
     SectionName = ".rodata";
     // Only expecting to write the data sections all in one shot for now.
     assert(RODataSections.empty());
     const Elf64_Xword ShFlags = SHF_ALLOC;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     RODataSections.push_back(Section);
-    RelSection = createRelocationSection(IsELF64, Section);
+    RelSection = createRelocationSection(Section);
     RelRODataSections.push_back(RelSection);
     break;
   }
   case Data: {
     SectionName = ".data";
     assert(DataSections.empty());
     const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     DataSections.push_back(Section);
-    RelSection = createRelocationSection(IsELF64, Section);
+    RelSection = createRelocationSection(Section);
     RelDataSections.push_back(RelSection);
     break;
   }
   case BSS: {
     SectionName = ".bss";
     assert(BSSSections.empty());
     const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_NOBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
@@ skipping 60 matching lines @@
       }
     }
   }
 }
 
 void ELFObjectWriter::writeInitialELFHeader() {
   assert(!SectionNumbersAssigned);
   const Elf64_Off DummySHOffset = 0;
   const SizeT DummySHStrIndex = 0;
   const SizeT DummyNumSections = 0;
-  if (isELF64(Ctx.getTargetArch())) {
+  if (ELF64) {
     writeELFHeaderInternal<true>(DummySHOffset, DummySHStrIndex,
                                  DummyNumSections);
   } else {
     writeELFHeaderInternal<false>(DummySHOffset, DummySHStrIndex,
                                   DummyNumSections);
   }
 }
 
 template <bool IsELF64>
 void ELFObjectWriter::writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
@@ skipping 10 matching lines @@
   Str.write8(ELF_ABIVersion);
   Str.writeZeroPadding(EI_NIDENT - EI_PAD);
 
   // TODO(jvoung): Handle and test > 64K sections.  See the generic ABI doc:
   // https://refspecs.linuxbase.org/elf/gabi4+/ch4.eheader.html
   // e_shnum should be 0 and then actual number of sections is
   // stored in the sh_size member of the 0th section.
   assert(NumSections < SHN_LORESERVE);
   assert(SectHeaderStrIndex < SHN_LORESERVE);
 
+  const TargetArch Arch = Ctx.getFlags().getTargetArch();
   // Write the rest of the file header, which does depend on byte order
   // and ELF class.
-  Str.writeLE16(ET_REL);                             // e_type
-  Str.writeLE16(getELFMachine(Ctx.getTargetArch())); // e_machine
-  Str.writeELFWord<IsELF64>(1);                      // e_version
+  Str.writeLE16(ET_REL);                                        // e_type
+  Str.writeLE16(getELFMachine(Ctx.getFlags().getTargetArch())); // e_machine
+  Str.writeELFWord<IsELF64>(1);                                 // e_version
   // Since this is for a relocatable object, there is no entry point,
   // and no program headers.
   Str.writeAddrOrOffset<IsELF64>(0);                                // e_entry
   Str.writeAddrOrOffset<IsELF64>(0);                                // e_phoff
   Str.writeAddrOrOffset<IsELF64>(SectionHeaderOffset);              // e_shoff
-  Str.writeELFWord<IsELF64>(getELFFlags(Ctx.getTargetArch()));      // e_flags
+  Str.writeELFWord<IsELF64>(getELFFlags(Arch));                     // e_flags
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Ehdr) : sizeof(Elf32_Ehdr)); // e_ehsize
   static_assert(sizeof(Elf64_Ehdr) == 64 && sizeof(Elf32_Ehdr) == 52,
                 "Elf_Ehdr sizes cannot be derived from sizeof");
   Str.writeLE16(0); // e_phentsize
   Str.writeLE16(0); // e_phnum
   Str.writeLE16(IsELF64 ? sizeof(Elf64_Shdr)
                         : sizeof(Elf32_Shdr)); // e_shentsize
   static_assert(sizeof(Elf64_Shdr) == 64 && sizeof(Elf32_Shdr) == 40,
                 "Elf_Shdr sizes cannot be derived from sizeof");
   Str.writeLE16(static_cast<Elf64_Half>(NumSections));        // e_shnum
@@ skipping 48 matching lines @@
 
 // Instantiate known needed versions of the template, since we are
 // defining the function in the .cpp file instead of the .h file.
 // We may need to instantiate constant pools for integers as well
 // if we do constant-pooling of large integers to remove them
 // from the instruction stream (fewer bytes controlled by an attacker).
 template void ELFObjectWriter::writeConstantPool<ConstantFloat>(Type Ty);
 
 template void ELFObjectWriter::writeConstantPool<ConstantDouble>(Type Ty);
 
-void ELFObjectWriter::writeAllRelocationSections(bool IsELF64) {
-  writeRelocationSections(IsELF64, RelTextSections);
-  writeRelocationSections(IsELF64, RelDataSections);
-  writeRelocationSections(IsELF64, RelRODataSections);
+void ELFObjectWriter::writeAllRelocationSections() {
+  writeRelocationSections(RelTextSections);
+  writeRelocationSections(RelDataSections);
+  writeRelocationSections(RelRODataSections);
 }
 
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
   for (const Constant *S : UndefSyms) {
     const auto Sym = llvm::cast<ConstantRelocatable>(S);
     const IceString &Name = Sym->getName();
     bool BadIntrinsic;
     const Intrinsics::FullIntrinsicInfo *Info =
         Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
     if (Info)
       continue;
     assert(!BadIntrinsic);
     assert(Sym->getOffset() == 0);
     assert(Sym->getSuppressMangling());
     SymTab->noteUndefinedSym(Name, NullSection);
     StrTab->add(Name);
   }
 }
 
-void ELFObjectWriter::writeRelocationSections(bool IsELF64,
-                                              RelSectionList &RelSections) {
+void ELFObjectWriter::writeRelocationSections(RelSectionList &RelSections) {
   for (ELFRelocationSection *RelSec : RelSections) {
     Elf64_Off Offset = alignFileOffset(RelSec->getSectionAlign());
     RelSec->setFileOffset(Offset);
     RelSec->setSize(RelSec->getSectionDataSize());
-    if (IsELF64) {
+    if (ELF64) {
       RelSec->writeData<true>(Ctx, Str, SymTab);
     } else {
       RelSec->writeData<false>(Ctx, Str, SymTab);
     }
   }
 }
 
 void ELFObjectWriter::writeNonUserSections() {
-  bool IsELF64 = isELF64(Ctx.getTargetArch());
-
   // Write out the shstrtab now that all sections are known.
   ShStrTab->doLayout();
   ShStrTab->setSize(ShStrTab->getSectionDataSize());
   Elf64_Off ShStrTabOffset = alignFileOffset(ShStrTab->getSectionAlign());
   ShStrTab->setFileOffset(ShStrTabOffset);
   Str.writeBytes(ShStrTab->getSectionData());
 
   SectionList AllSections;
   assignSectionNumbersInfo(AllSections);
 
   // Finalize the regular StrTab and fix up references in the SymTab.
   StrTab->doLayout();
   StrTab->setSize(StrTab->getSectionDataSize());
 
   SymTab->updateIndices(StrTab);
 
   Elf64_Off SymTabOffset = alignFileOffset(SymTab->getSectionAlign());
   SymTab->setFileOffset(SymTabOffset);
   SymTab->setSize(SymTab->getSectionDataSize());
-  SymTab->writeData(Str, IsELF64);
+  SymTab->writeData(Str, ELF64);
 
   Elf64_Off StrTabOffset = alignFileOffset(StrTab->getSectionAlign());
   StrTab->setFileOffset(StrTabOffset);
   Str.writeBytes(StrTab->getSectionData());
 
-  writeAllRelocationSections(IsELF64);
+  writeAllRelocationSections();
 
   // Write out the section headers.
-  const size_t ShdrAlign = IsELF64 ? 8 : 4;
+  const size_t ShdrAlign = ELF64 ? 8 : 4;
   Elf64_Off ShOffset = alignFileOffset(ShdrAlign);
   for (const auto S : AllSections) {
-    if (IsELF64)
+    if (ELF64)
       S->writeHeader<true>(Str);
     else
       S->writeHeader<false>(Str);
   }
 
   // Finally write the updated ELF header w/ the correct number of sections.
   Str.seek(0);
-  if (IsELF64) {
+  if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice