Simplify references to command line flags.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 194 matching lines @@
       for (SizeT TypeIndex = 0; TypeIndex < TypeToRegisterSetSize;
            ++TypeIndex) {
         if (RClass.empty() ||
             RClass == getRegClassName(static_cast<RegClass>(TypeIndex))) {
           RegSet[TypeIndex][RegIndex] = TypeToRegisterSet[TypeIndex][RegIndex];
         }
       }
     }
   };
 
-  processRegList(Ctx->getFlags().getUseRestrictedRegisters(), UseSet);
-  processRegList(Ctx->getFlags().getExcludedRegisters(), ExcludeSet);
+  processRegList(getFlags().getUseRestrictedRegisters(), UseSet);
+  processRegList(getFlags().getExcludedRegisters(), ExcludeSet);
 
   if (!BadRegNames.empty()) {
     std::string Buffer;
     llvm::raw_string_ostream StrBuf(Buffer);
     StrBuf << "Unrecognized use/exclude registers:";
     for (const auto &RegName : BadRegNames)
       StrBuf << " " << RegName;
     llvm::report_fatal_error(StrBuf.str());
   }
 
   // Apply filters.
   for (size_t TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex) {
     SmallBitVector *TypeBitSet = &TypeToRegisterSet[TypeIndex];
     SmallBitVector *UseBitSet = &UseSet[TypeIndex];
     SmallBitVector *ExcludeBitSet = &ExcludeSet[TypeIndex];
     if (UseBitSet->any())
       *TypeBitSet = *UseBitSet;
     (*TypeBitSet).reset(*ExcludeBitSet);
   }
 
   // Display filtered register sets, if requested.
   if (BuildDefs::dump() && NumRegs &&
-      (Ctx->getFlags().getVerbose() & IceV_AvailableRegs)) {
+      (getFlags().getVerbose() & IceV_AvailableRegs)) {
     Ostream &Str = Ctx->getStrDump();
     const std::string Indent = "  ";
     const std::string IndentTwice = Indent + Indent;
     Str << "Registers available for register allocation:\n";
     for (size_t TypeIndex = 0; TypeIndex < TypeToRegisterSetSize; ++TypeIndex) {
       Str << Indent << getRegClassName(static_cast<RegClass>(TypeIndex))
           << ":\n";
       printRegisterSet(Str, TypeToRegisterSet[TypeIndex], getRegName,
                        IndentTwice);
     }
     Str << "\n";
   }
 }
 
 std::unique_ptr<TargetLowering>
 TargetLowering::createLowering(TargetArch Target, Cfg *Func) {
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetLowering(Func);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 void TargetLowering::staticInit(GlobalContext *Ctx) {
-  const TargetArch Target = Ctx->getFlags().getTargetArch();
+  const TargetArch Target = getFlags().getTargetArch();
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case TARGET_LOWERING_CLASS_FOR(X): {                                         \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
     InitGuard##X = true;                                                       \
     ::X::staticInit(Ctx);                                                      \
   } break;
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 bool TargetLowering::shouldBePooled(const Constant *C) {
-  const TargetArch Target = GlobalContext::getFlags().getTargetArch();
+  const TargetArch Target = getFlags().getTargetArch();
   switch (Target) {
   default:
     return false;
 #define SUBZERO_TARGET(X)                                                      \
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::shouldBePooled(C);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetLowering::SandboxType
 TargetLowering::determineSandboxTypeFromFlags(const ClFlags &Flags) {
   assert(!Flags.getUseSandboxing() || !Flags.getUseNonsfi());
   if (Flags.getUseNonsfi()) {
     return TargetLowering::ST_Nonsfi;
   }
   if (Flags.getUseSandboxing()) {
     return TargetLowering::ST_NaCl;
   }
   return TargetLowering::ST_None;
 }
 
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()),
-      SandboxingType(determineSandboxTypeFromFlags(Ctx->getFlags())) {}
+      SandboxingType(determineSandboxTypeFromFlags(getFlags())) {}
 
 TargetLowering::AutoBundle::AutoBundle(TargetLowering *Target,
                                        InstBundleLock::Option Option)
-    : Target(Target),
-      NeedSandboxing(Target->Ctx->getFlags().getUseSandboxing()) {
+    : Target(Target), NeedSandboxing(getFlags().getUseSandboxing()) {
   assert(!Target->AutoBundling);
   Target->AutoBundling = true;
   if (NeedSandboxing) {
     Target->_bundle_lock(Option);
   }
 }
 
 TargetLowering::AutoBundle::~AutoBundle() {
   assert(Target->AutoBundling);
   Target->AutoBundling = false;
@@ skipping 22 matching lines @@
   Context.advanceCur();
   Context.advanceNext();
 }
 
 void TargetLowering::doNopInsertion(RandomNumberGenerator &RNG) {
   Inst *I = Context.getCur();
   bool ShouldSkip = llvm::isa<InstFakeUse>(I) || llvm::isa<InstFakeDef>(I) ||
                     llvm::isa<InstFakeKill>(I) || I->isRedundantAssign() ||
                     I->isDeleted();
   if (!ShouldSkip) {
-    int Probability = Ctx->getFlags().getNopProbabilityAsPercentage();
-    for (int I = 0; I < Ctx->getFlags().getMaxNopsPerInstruction(); ++I) {
+    int Probability = getFlags().getNopProbabilityAsPercentage();
+    for (int I = 0; I < getFlags().getMaxNopsPerInstruction(); ++I) {
       randomlyInsertNop(Probability / 100.0, RNG);
     }
   }
 }
 
 // Lowers a single instruction according to the information in Context, by
 // checking the Context.Cur instruction kind and calling the appropriate
 // lowering method. The lowering method should insert target instructions at
 // the Cur.Next insertion point, and should not delete the Context.Cur
 // instruction or advance Context.Cur.
@@ skipping 111 matching lines @@
 void TargetLowering::regAlloc(RegAllocKind Kind) {
   TimerMarker T(TimerStack::TT_regAlloc, Func);
   LinearScan LinearScan(Func);
   RegSetMask RegInclude = RegSet_None;
   RegSetMask RegExclude = RegSet_None;
   RegInclude |= RegSet_CallerSave;
   RegInclude |= RegSet_CalleeSave;
   if (hasFramePointer())
     RegExclude |= RegSet_FramePointer;
   SmallBitVector RegMask = getRegisterSet(RegInclude, RegExclude);
-  bool Repeat = (Kind == RAK_Global && Ctx->getFlags().getRepeatRegAlloc());
+  bool Repeat = (Kind == RAK_Global && getFlags().getRepeatRegAlloc());
   do {
     LinearScan.init(Kind);
-    LinearScan.scan(RegMask, Ctx->getFlags().getRandomizeRegisterAllocation());
+    LinearScan.scan(RegMask, getFlags().getRandomizeRegisterAllocation());
     if (!LinearScan.hasEvictions())
       Repeat = false;
     Kind = RAK_SecondChance;
   } while (Repeat);
   // TODO(stichnot): Run the register allocator one more time to do stack slot
   // coalescing.  The idea would be to initialize the Unhandled list with the
   // set of Variables that have no register and a non-empty live range, and
   // model an infinite number of registers.  Maybe use the register aliasing
   // mechanism to get better packing of narrower slots.
 }
@@ skipping 129 matching lines @@
           *SpillAreaSizeBytes = LocalsSize[NodeIndex];
         if (!*LocalsSlotsAlignmentBytes)
           *LocalsSlotsAlignmentBytes = Increment;
       }
     } else {
       *SpillAreaSizeBytes += Increment;
     }
   }
   // For testing legalization of large stack offsets on targets with limited
   // offset bits in instruction encodings, add some padding.
-  *SpillAreaSizeBytes += Ctx->getFlags().getTestStackExtra();
+  *SpillAreaSizeBytes += getFlags().getTestStackExtra();
 }
 
 void TargetLowering::alignStackSpillAreas(uint32_t SpillAreaStartOffset,
                                           uint32_t SpillAreaAlignmentBytes,
                                           size_t GlobalsSize,
                                           uint32_t LocalsSlotsAlignmentBytes,
                                           uint32_t *SpillAreaPaddingBytes,
                                           uint32_t *LocalsSlotsPaddingBytes) {
   if (SpillAreaAlignmentBytes) {
     uint32_t PaddingStart = SpillAreaStartOffset;
@@ skipping 18 matching lines @@
                                          size_t GlobalsAndSubsequentPaddingSize,
                                          bool UsesFramePointer) {
   const VariablesMetadata *VMetadata = Func->getVMetadata();
   // For testing legalization of large stack offsets on targets with limited
   // offset bits in instruction encodings, add some padding. This assumes that
   // SpillAreaSizeBytes has accounted for the extra test padding. When
   // UseFramePointer is true, the offset depends on the padding, not just the
   // SpillAreaSizeBytes. On the other hand, when UseFramePointer is false, the
   // offsets depend on the gap between SpillAreaSizeBytes and
   // SpillAreaPaddingBytes, so we don't increment that.
-  size_t TestPadding = Ctx->getFlags().getTestStackExtra();
+  size_t TestPadding = getFlags().getTestStackExtra();
   if (UsesFramePointer)
     SpillAreaPaddingBytes += TestPadding;
   size_t GlobalsSpaceUsed = SpillAreaPaddingBytes;
   size_t NextStackOffset = SpillAreaPaddingBytes;
   CfgVector<size_t> LocalsSize(Func->getNumNodes());
   const bool SimpleCoalescing = !callsReturnsTwice();
 
   for (Variable *Var : SortedSpilledVariables) {
     size_t Increment = typeWidthInBytesOnStack(Var->getType());
     if (SimpleCoalescing && VMetadata->isTracked(Var)) {
@@ skipping 20 matching lines @@
 InstCall *TargetLowering::makeHelperCall(RuntimeHelper FuncID, Variable *Dest,
                                          SizeT MaxSrcs) {
   constexpr bool HasTailCall = false;
   Constant *CallTarget = Ctx->getRuntimeHelperFunc(FuncID);
   InstCall *Call =
       InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
   return Call;
 }
 
 bool TargetLowering::shouldOptimizeMemIntrins() {
-  return Ctx->getFlags().getOptLevel() >= Opt_1 ||
-         Ctx->getFlags().getForceMemIntrinOpt();
+  return getFlags().getOptLevel() >= Opt_1 || getFlags().getForceMemIntrinOpt();
 }
 
 void TargetLowering::scalarizeArithmetic(InstArithmetic::OpKind Kind,
                                          Variable *Dest, Operand *Src0,
                                          Operand *Src1) {
   scalarizeInstruction(
       Dest, [this, Kind](Variable *Dest, Operand *Src0, Operand *Src1) {
         return Context.insert<InstArithmetic>(Kind, Dest, Src0, Src1);
       }, Src0, Src1);
 }
@@ skipping 14 matching lines @@
   RelocOffsetT Offset = C->getOffset();
   if (Offset) {
     if (Offset > 0)
       Str << "+";
     Str << Offset;
   }
 }
 
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
-  TargetArch Target = Ctx->getFlags().getTargetArch();
+  TargetArch Target = getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetDataLowering(Ctx);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
@@ skipping 23 matching lines @@
 
 } // end of anonymous namespace
 
 void TargetDataLowering::emitGlobal(const VariableDeclaration &Var,
                                     const std::string &SectionSuffix) {
   if (!BuildDefs::dump())
     return;
 
   // If external and not initialized, this must be a cross test. Don't generate
   // a declaration for such cases.
-  const bool IsExternal =
-      Var.isExternal() || Ctx->getFlags().getDisableInternal();
+  const bool IsExternal = Var.isExternal() || getFlags().getDisableInternal();
   if (IsExternal && !Var.hasInitializer())
     return;
 
   Ostream &Str = Ctx->getStrEmit();
   const bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   const bool IsConstant = Var.getIsConstant();
   const SizeT Size = Var.getNumBytes();
   const std::string Name = Var.getName().toString();
 
   Str << "\t.type\t" << Name << ",%object\n";
 
-  const bool UseDataSections = Ctx->getFlags().getDataSections();
-  const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
+  const bool UseDataSections = getFlags().getDataSections();
+  const bool UseNonsfi = getFlags().getUseNonsfi();
   const std::string Suffix =
       dataSectionSuffix(SectionSuffix, Name, UseDataSections);
   if (IsConstant && UseNonsfi)
     Str << "\t.section\t.data.rel.ro" << Suffix << ",\"aw\",%progbits\n";
   else if (IsConstant)
     Str << "\t.section\t.rodata" << Suffix << ",\"a\",%progbits\n";
   else if (HasNonzeroInitializer)
     Str << "\t.section\t.data" << Suffix << ",\"aw\",%progbits\n";
   else
     Str << "\t.section\t.bss" << Suffix << ",\"aw\",%nobits\n";
@@ skipping 52 matching lines @@
     // but the .s writer still needs this .zero and cannot simply use the .size
     // to advance offsets.
     Str << "\t.zero\t" << Size << "\n";
   }
 
   Str << "\t.size\t" << Name << ", " << Size << "\n";
 }
 
 std::unique_ptr<TargetHeaderLowering>
 TargetHeaderLowering::createLowering(GlobalContext *Ctx) {
-  TargetArch Target = Ctx->getFlags().getTargetArch();
+  TargetArch Target = getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice