Simplify references to command line flags.

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 16 matching lines @@
 #include "IceLoopAnalyzer.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 
 #include <memory>
 #include <utility>
 
 namespace Ice {
 
 Cfg::Cfg(GlobalContext *Ctx, uint32_t SequenceNumber)
-    : Ctx(Ctx), SequenceNumber(SequenceNumber),
-      VMask(Ctx->getFlags().getVerbose()), FunctionName(),
-      NextInstNumber(Inst::NumberInitial), Live(nullptr) {
+    : Ctx(Ctx), SequenceNumber(SequenceNumber), VMask(getFlags().getVerbose()),
+      FunctionName(), NextInstNumber(Inst::NumberInitial), Live(nullptr) {
   Allocator.reset(new ArenaAllocator());
   NodeStrings.reset(new StringPool);
   VarStrings.reset(new StringPool);
   CfgLocalAllocatorScope _(this);
-  Target =
-      TargetLowering::createLowering(Ctx->getFlags().getTargetArch(), this);
+  Target = TargetLowering::createLowering(getFlags().getTargetArch(), this);
   VMetadata.reset(new VariablesMetadata(this));
   TargetAssembler = Target->createAssembler();
 
-  if (Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_Randomize) {
+  if (getFlags().getRandomizeAndPoolImmediatesOption() == RPI_Randomize) {
     // If -randomize-pool-immediates=randomize, create a random number
     // generator to generate a cookie for constant blinding.
-    RandomNumberGenerator RNG(Ctx->getFlags().getRandomSeed(),
-                              RPE_ConstantBlinding, this->SequenceNumber);
+    RandomNumberGenerator RNG(getFlags().getRandomSeed(), RPE_ConstantBlinding,
+                              this->SequenceNumber);
     ConstantBlindingCookie =
         (uint32_t)RNG.next((uint64_t)std::numeric_limits<uint32_t>::max() + 1);
   }
 }
 
 Cfg::~Cfg() {
   assert(CfgAllocatorTraits::current() == nullptr);
-  if (GlobalContext::getFlags().getDumpStrings()) {
+  if (getFlags().getDumpStrings()) {
     OstreamLocker _(Ctx);
     Ostream &Str = Ctx->getStrDump();
     getNodeStrings()->dump(Str);
     getVarStrings()->dump(Str);
   }
 }
 
 /// Create a string like "foo(i=123:b=9)" indicating the function name, number
 /// of high-level instructions, and number of basic blocks.  This string is only
 /// used for dumping and other diagnostics, and the idea is that given a set of
@@ skipping 121 matching lines @@
   constexpr bool HasTailCall = false;
   auto *Call =
       InstCall::create(this, NumArgs, Void, ProfileSummarySym, HasTailCall);
   getEntryNode()->getInsts().push_front(Call);
 }
 
 void Cfg::translate() {
   if (hasError())
     return;
   if (BuildDefs::dump()) {
-    const std::string TimingFocusOn =
-        getContext()->getFlags().getTimingFocusOn();
+    const std::string TimingFocusOn = getFlags().getTimingFocusOn();
     const std::string Name = getFunctionName().toString();
     if (TimingFocusOn == "*" || TimingFocusOn == Name) {
       setFocusedTiming();
       getContext()->resetTimer(GlobalContext::TSK_Default);
       getContext()->setTimerName(GlobalContext::TSK_Default, Name);
     }
     if (isVerbose(IceV_Status)) {
       getContext()->getStrDump() << ">>>Translating "
                                  << getFunctionNameAndSize() << "\n";
     }
   }
   TimerMarker T_func(getContext(), getFunctionName().toStringOrEmpty());
   TimerMarker T(TimerStack::TT_translate, this);
 
   dump("Initial CFG");
 
-  if (getContext()->getFlags().getEnableBlockProfile()) {
+  if (getFlags().getEnableBlockProfile()) {
     profileBlocks();
     // TODO(jpp): this is fragile, at best. Figure out a better way of
     // detecting exit functions.
     if (GlobalContext::matchSymbolName(getFunctionName(), "exit")) {
       addCallToProfileSummary();
     }
     dump("Profiled CFG");
   }
 
   // Create the Hi and Lo variables where a split was needed
@@ skipping 217 matching lines @@
                      [RNG](int N) { return RNG->next(N); });
   for (CfgNode *Next : Outs) {
     if (ToVisit[Next->getIndex()])
       getRandomPostOrder(Next, ToVisit, PostOrder, RNG);
   }
   PostOrder.push_back(Node);
 }
 } // end of anonymous namespace
 
 void Cfg::shuffleNodes() {
-  if (!Ctx->getFlags().getReorderBasicBlocks())
+  if (!getFlags().getReorderBasicBlocks())
     return;
 
   NodeList ReversedReachable;
   NodeList Unreachable;
   BitVector ToVisit(Nodes.size(), true);
   // Create Random number generator for function reordering
-  RandomNumberGenerator RNG(Ctx->getFlags().getRandomSeed(),
+  RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                             RPE_BasicBlockReordering, SequenceNumber);
   // Traverse from entry node.
   getRandomPostOrder(getEntryNode(), ToVisit, ReversedReachable, &RNG);
   // Collect the unreachable nodes.
   for (CfgNode *Node : Nodes)
     if (ToVisit[Node->getIndex()])
       Unreachable.push_back(Node);
   // Copy the layout list to the Nodes.
   NodeList Shuffled;
   Shuffled.reserve(ReversedReachable.size() + Unreachable.size());
@@ skipping 295 matching lines @@
   } while (FoundNewAssignment);
 }
 
 void Cfg::doAddressOpt() {
   TimerMarker T(TimerStack::TT_doAddressOpt, this);
   for (CfgNode *Node : Nodes)
     Node->doAddressOpt();
 }
 
 void Cfg::doNopInsertion() {
-  if (!Ctx->getFlags().getShouldDoNopInsertion())
+  if (!getFlags().getShouldDoNopInsertion())
     return;
   TimerMarker T(TimerStack::TT_doNopInsertion, this);
-  RandomNumberGenerator RNG(Ctx->getFlags().getRandomSeed(), RPE_NopInsertion,
+  RandomNumberGenerator RNG(getFlags().getRandomSeed(), RPE_NopInsertion,
                             SequenceNumber);
   for (CfgNode *Node : Nodes)
     Node->doNopInsertion(RNG);
 }
 
 void Cfg::genCode() {
   TimerMarker T(TimerStack::TT_genCode, this);
   for (CfgNode *Node : Nodes)
     Node->genCode();
 }
@@ skipping 157 matching lines @@
   }
   return Valid;
 }
 
 void Cfg::contractEmptyNodes() {
   // If we're decorating the asm output with register liveness info, this
   // information may become corrupted or incorrect after contracting nodes that
   // contain only redundant assignments. As such, we disable this pass when
   // DecorateAsm is specified. This may make the resulting code look more
   // branchy, but it should have no effect on the register assignments.
-  if (Ctx->getFlags().getDecorateAsm())
+  if (getFlags().getDecorateAsm())
     return;
   for (CfgNode *Node : Nodes) {
     Node->contractIfEmpty();
   }
 }
 
 void Cfg::doBranchOpt() {
   TimerMarker T(TimerStack::TT_doBranchOpt, this);
   for (auto I = Nodes.begin(), E = Nodes.end(); I != E; ++I) {
     auto NextNode = I + 1;
@@ skipping 11 matching lines @@
 
 // emitTextHeader() is not target-specific (apart from what is abstracted by
 // the Assembler), so it is defined here rather than in the target lowering
 // class.
 void Cfg::emitTextHeader(GlobalString Name, GlobalContext *Ctx,
                          const Assembler *Asm) {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.text\n";
-  if (Ctx->getFlags().getFunctionSections())
+  if (getFlags().getFunctionSections())
     Str << "\t.section\t.text." << Name << ",\"ax\",%progbits\n";
-  if (!Asm->getInternal() || Ctx->getFlags().getDisableInternal()) {
+  if (!Asm->getInternal() || getFlags().getDisableInternal()) {
     Str << "\t.globl\t" << Name << "\n";
     Str << "\t.type\t" << Name << ",%function\n";
   }
   Str << "\t" << Asm->getAlignDirective() << " "
       << Asm->getBundleAlignLog2Bytes() << ",0x";
   for (uint8_t I : Asm->getNonExecBundlePadding())
     Str.write_hex(I);
   Str << "\n";
   Str << Name << ":\n";
 }
 
 void Cfg::deleteJumpTableInsts() {
   for (InstJumpTable *JumpTable : JumpTables)
     JumpTable->setDeleted();
 }
 
 void Cfg::emitJumpTables() {
-  switch (Ctx->getFlags().getOutFileType()) {
+  switch (getFlags().getOutFileType()) {
   case FT_Elf:
   case FT_Iasm: {
     // The emission needs to be delayed until the after the text section so
     // save the offsets in the global context.
     for (const InstJumpTable *JumpTable : JumpTables) {
       SizeT NumTargets = JumpTable->getNumTargets();
       JumpTableData::TargetList TargetList;
       for (SizeT I = 0; I < NumTargets; ++I) {
         SizeT Index = JumpTable->getTarget(I)->getIndex();
         TargetList.emplace_back(
             getAssembler()->getCfgNodeLabel(Index)->getPosition());
       }
       Ctx->addJumpTable(FunctionName, JumpTable->getId(), TargetList);
     }
   } break;
   case FT_Asm: {
     // Emit the assembly directly so we don't need to hang on to all the names
     for (const InstJumpTable *JumpTable : JumpTables)
       getTarget()->emitJumpTable(this, JumpTable);
   } break;
   }
 }
 
 void Cfg::emit() {
   if (!BuildDefs::dump())
     return;
   TimerMarker T(TimerStack::TT_emitAsm, this);
-  if (Ctx->getFlags().getDecorateAsm()) {
+  if (getFlags().getDecorateAsm()) {
     renumberInstructions();
     getVMetadata()->init(VMK_Uses);
     liveness(Liveness_Basic);
     dump("After recomputing liveness for -decorate-asm");
   }
   OstreamLocker L(Ctx);
   Ostream &Str = Ctx->getStrEmit();
   const Assembler *Asm = getAssembler<>();
-  const bool NeedSandboxing = Ctx->getFlags().getUseSandboxing();
+  const bool NeedSandboxing = getFlags().getUseSandboxing();
 
   emitTextHeader(FunctionName, Ctx, Asm);
   deleteJumpTableInsts();
-  if (Ctx->getFlags().getDecorateAsm()) {
+  if (getFlags().getDecorateAsm()) {
     for (Variable *Var : getVariables()) {
       if (Var->getStackOffset() && !Var->isRematerializable()) {
         Str << "\t" << Var->getSymbolicStackOffset(this) << " = "
             << Var->getStackOffset() << "\n";
       }
     }
   }
   for (CfgNode *Node : Nodes) {
     if (NeedSandboxing && Node->needsAlignment()) {
       Str << "\t" << Asm->getAlignDirective() << " "
           << Asm->getBundleAlignLog2Bytes() << "\n";
     }
     Node->emit(this);
   }
   emitJumpTables();
   Str << "\n";
 }
 
 void Cfg::emitIAS() {
   TimerMarker T(TimerStack::TT_emitAsm, this);
   // The emitIAS() routines emit into the internal assembler buffer, so there's
   // no need to lock the streams.
   deleteJumpTableInsts();
-  const bool NeedSandboxing = Ctx->getFlags().getUseSandboxing();
+  const bool NeedSandboxing = getFlags().getUseSandboxing();
   for (CfgNode *Node : Nodes) {
     if (NeedSandboxing && Node->needsAlignment())
       getAssembler()->alignCfgNode();
     Node->emitIAS(this);
   }
   emitJumpTables();
 }
 
 size_t Cfg::getTotalMemoryMB() const {
   constexpr size_t _1MB = 1024 * 1024;
@@ skipping 20 matching lines @@
   Ostream &Str = Ctx->getStrDump();
   if (Message[0])
     Str << "================ " << Message << " ================\n";
   if (isVerbose(IceV_Mem)) {
     Str << "Memory size = " << getTotalMemoryMB() << " MB\n";
   }
   setCurrentNode(getEntryNode());
   // Print function name+args
   if (isVerbose(IceV_Instructions)) {
     Str << "define ";
-    if (getInternal() && !Ctx->getFlags().getDisableInternal())
+    if (getInternal() && !getFlags().getDisableInternal())
       Str << "internal ";
     Str << ReturnType << " @" << getFunctionName() << "(";
     for (SizeT i = 0; i < Args.size(); ++i) {
       if (i > 0)
         Str << ", ";
       Str << Args[i]->getType() << " ";
       Args[i]->dump(this);
     }
     // Append an extra copy of the function name here, in order to print its
     // size stats but not mess up lit tests.
@@ skipping 30 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice