Simplify references to command line flags.

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 56 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), ELF64(isELF64(Ctx.getFlags())) {
+    : Ctx(Ctx), Str(Out), ELF64(isELF64(getFlags())) {
   // Create the special bookkeeping sections now.
   constexpr char NullSectionName[] = "";
   NullSection = new (Ctx.allocate<ELFSection>())
       ELFSection(NullSectionName, SHT_NULL, 0, 0, 0);
 
   constexpr char ShStrTabName[] = ".shstrtab";
   ShStrTab = new (Ctx.allocate<ELFStringTableSection>())
       ELFStringTableSection(ShStrTabName, SHT_STRTAB, 0, 1, 0);
   ShStrTab->add(ShStrTabName);
 
@@ skipping 128 matching lines @@
   return OffsetInFile;
 }
 
 void ELFObjectWriter::writeFunctionCode(GlobalString FuncName, bool IsInternal,
                                         Assembler *Asm) {
   assert(!SectionNumbersAssigned);
   TimerMarker T_func(&Ctx, FuncName.toStringOrEmpty());
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
-  const bool FunctionSections = Ctx.getFlags().getFunctionSections();
+  const bool FunctionSections = getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
     std::string SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
     constexpr 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(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
     RelSection = RelTextSections[0];
   }
   const 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.
   constexpr SizeT SymbolSize = 0;
   uint8_t SymbolType;
   uint8_t SymbolBinding;
-  if (IsInternal && !Ctx.getFlags().getDisableInternal()) {
+  if (IsInternal && !getFlags().getDisableInternal()) {
     SymbolType = STT_NOTYPE;
     SymbolBinding = STB_LOCAL;
   } else {
     SymbolType = STT_FUNC;
     SymbolBinding = STB_GLOBAL;
   }
   SymTab->createDefinedSym(FuncName, SymbolType, SymbolBinding, Section,
                            OffsetInSection, SymbolSize);
   StrTab->add(FuncName);
 
@@ skipping 42 matching lines @@
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind,
                                        const std::string &SectionSuffix,
                                        bool IsPIC) {
   TimerMarker Timer(TimerStack::TT_writeELF, &Ctx);
   assert(!SectionNumbersAssigned);
   VariableDeclarationPartition VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
-  partitionGlobalsBySection(Vars, VarsBySection,
-                            Ctx.getFlags().getTranslateOnly());
+  partitionGlobalsBySection(Vars, VarsBySection, getFlags().getTranslateOnly());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
                     SectionSuffix, IsPIC);
   }
 }
 
 namespace {
 std::string MangleSectionName(const char Base[], const std::string &Suffix) {
   if (Suffix.empty())
@@ skipping 60 matching lines @@
   constexpr uint8_t SymbolType = STT_OBJECT;
   for (VariableDeclaration *Var : Vars) {
     // If the variable declaration does not have an initializer, its symtab
     // entry will be created separately.
     if (!Var->hasInitializer())
       continue;
     constexpr Elf64_Xword MinAlign = 1;
     const auto Align = std::max<Elf64_Xword>(MinAlign, Var->getAlignment());
     Section->padToAlignment(Str, Align);
     SizeT SymbolSize = Var->getNumBytes();
-    bool IsExternal = Var->isExternal() || Ctx.getFlags().getDisableInternal();
+    bool IsExternal = Var->isExternal() || getFlags().getDisableInternal();
     const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
     GlobalString Name = Var->getName();
     SymTab->createDefinedSym(Name, SymbolType, SymbolBinding, Section,
                              Section->getCurrentSize(), SymbolSize);
     StrTab->add(Name);
     if (!Var->hasNonzeroInitializer()) {
       assert(ST == BSS || ST == ROData);
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
@@ skipping 63 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();
+  const TargetArch Arch = 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.getFlags().getTargetArch())); // e_machine
-  Str.writeELFWord<IsELF64>(1);                                 // e_version
+  Str.writeLE16(ET_REL);                                    // e_type
+  Str.writeLE16(getELFMachine(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(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
@@ skipping 29 matching lines @@
       SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
   RODataSections.push_back(Section);
   SizeT OffsetInSection = 0;
   // The symbol table entry doesn't need to know the defined symbol's size
   // since this is in a section with a fixed Entry Size.
   constexpr SizeT SymbolSize = 0;
   Section->setFileOffset(alignFileOffset(Align));
 
   // If the -reorder-pooled-constant option is set to true, we should shuffle
   // the constants before we emit them.
-  if (Ctx.getFlags().getReorderPooledConstants() && !Pool.empty()) {
+  if (getFlags().getReorderPooledConstants() && !Pool.empty()) {
     // Use the constant's kind value as the salt for creating random number
     // generator.
     Operand::OperandKind K = (*Pool.begin())->getKind();
-    RandomNumberGenerator RNG(Ctx.getFlags().getRandomSeed(),
+    RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering, K);
     RandomShuffle(Pool.begin(), Pool.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   // Write the data.
   for (Constant *C : Pool) {
     if (!C->getShouldBePooled())
       continue;
     auto *Const = llvm::cast<ConstType>(C);
     GlobalString SymName = Const->getLabelName();
@@ skipping 41 matching lines @@
           "$jumptable");
   Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, SHF_ALLOC,
                                           ShAddralign, ShEntsize);
   Section->setFileOffset(alignFileOffset(ShAddralign));
   RODataSections.push_back(Section);
   RelSection = createRelocationSection(Section);
   RelRODataSections.push_back(RelSection);
 
   constexpr uint8_t SymbolType = STT_OBJECT;
   Section->padToAlignment(Str, PointerSize);
-  const bool IsExternal = Ctx.getFlags().getDisableInternal();
+  const bool IsExternal = getFlags().getDisableInternal();
   const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
   GlobalString JumpTableName = Ctx.getGlobalString(
       InstJumpTable::makeName(JT.getFunctionName(), JT.getId()));
   SymTab->createDefinedSym(JumpTableName, SymbolType, SymbolBinding, Section,
                            Section->getCurrentSize(), PointerSize);
   StrTab->add(JumpTableName);
 
   for (intptr_t TargetOffset : JT.getTargetOffsets()) {
     AssemblerFixup NewFixup;
     NewFixup.set_position(Section->getCurrentSize());
@@ skipping 82 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice