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

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 144 matching lines @@
       << Stats[CS_NumSpills] + Stats[CS_NumFills] << "\n";
   Str << "|" << Name << "|Memory Usage|";
   if (ssize_t MemUsed = llvm::TimeRecord::getCurrentTime(false).getMemUsed())
     Str << MemUsed;
   else
     Str << "(requires '-track-memory')";
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit,
-                             ELFStreamer *ELFStr, VerboseMask Mask,
-                             TargetArch Arch, OptLevel Opt,
-                             IceString TestPrefix, const ClFlags &Flags)
+                             ELFStreamer *ELFStr, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
-      StrEmit(OsEmit), VMask(Mask), Arch(Arch), Opt(Opt),
-      TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter(),
-      OptQ(/*Sequential=*/Flags.isSequential(),
-           /*MaxSize=*/Flags.getNumTranslationThreads()),
+      StrEmit(OsEmit), Flags(Flags), RNG(Flags.getRandomSeed(), ""),

[Jim Stichnoth, 2015/03/20 21:19:25]

The "" is a little hard to read.  How about omitting it and making it the
default parameter value in the ctor?

[jvoung (off chromium), 2015/03/20 21:46:28]

Done.

+      ObjectWriter(), OptQ(/*Sequential=*/Flags.isSequential(),
+                           /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()) {
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // free.
   GlobalContext::TlsInit();
   Cfg::TlsInit();
   // Create a new ThreadContext for the current thread.  No need to
   // lock AllThreadContexts at this point since no other threads have
@@ skipping 77 matching lines @@
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
 void lowerGlobals(GlobalContext *Ctx,
                   std::unique_ptr<VariableDeclarationList> VariableDeclarations,
                   TargetDataLowering *DataLowering) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
-  const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getVerbose() &&
+  const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getFlags().getVerbose() &&
                                    Ctx->getFlags().getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(Ctx);
     Ostream &Stream = Ctx->getStrDump();
     for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
       Global->dump(Ctx, Stream);
     }
   }
   if (Ctx->getFlags().getDisableTranslation())
     return;
@@ skipping 171 matching lines @@
 // prefix.
 IceString GlobalContext::mangleName(const IceString &Name) const {
   // An already-nested name like foo::bar() gets pushed down one
   // level, making it equivalent to Prefix::foo::bar().
   //   _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
   // A non-nested but mangled name like bar() gets nested, making it
   // equivalent to Prefix::bar().
   //   _Z3barxyz ==> ZN6Prefix3barExyz
   // An unmangled, extern "C" style name, gets a simple prefix:
   //   bar ==> Prefixbar
-  if (!ALLOW_DUMP || getTestPrefix().empty())
+  if (!ALLOW_DUMP || getFlags().getTestPrefix().empty())
     return Name;
 
-  unsigned PrefixLength = getTestPrefix().length();
+  const IceString &TestPrefix = getFlags().getTestPrefix();
+  unsigned PrefixLength = TestPrefix.length();
   ManglerVector NameBase(1 + Name.length());
   const size_t BufLen = 30 + Name.length() + PrefixLength;
   ManglerVector NewName(BufLen);
   uint32_t BaseLength = 0; // using uint32_t due to sscanf format string
 
   int ItemsParsed = sscanf(Name.c_str(), "_ZN%s", NameBase.data());
   if (ItemsParsed == 1) {
     // Transform _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
     //   (splice in "6Prefix")          ^^^^^^^
     snprintf(NewName.data(), BufLen, "_ZN%u%s%s", PrefixLength,
-             getTestPrefix().c_str(), NameBase.data());
+             TestPrefix.c_str(), NameBase.data());
     // We ignore the snprintf return value (here and below).  If we
     // somehow miscalculated the output buffer length, the output will
     // be truncated, but it will be truncated consistently for all
     // mangleName() calls on the same input string.
     incrementSubstitutions(NewName);
     return NewName.data();
   }
 
   // Artificially limit BaseLength to 9 digits (less than 1 billion)
   // because sscanf behavior is undefined on integer overflow.  If
@@ skipping 18 matching lines @@
     if (NameBase[ActualBaseLength] == 'I') {
       ++ActualBaseLength;
       while (NameBase[ActualBaseLength] != 'E' &&
              NameBase[ActualBaseLength] != '\0')
         ++ActualBaseLength;
     }
     strncpy(OrigName.data(), NameBase.data(), ActualBaseLength);
     OrigName[ActualBaseLength] = '\0';
     strcpy(OrigSuffix.data(), NameBase.data() + ActualBaseLength);
     snprintf(NewName.data(), BufLen, "_ZN%u%s%u%sE%s", PrefixLength,
-             getTestPrefix().c_str(), BaseLength, OrigName.data(),
+             TestPrefix.c_str(), BaseLength, OrigName.data(),
              OrigSuffix.data());
     incrementSubstitutions(NewName);
     return NewName.data();
   }
 
   // Transform bar ==> Prefixbar
   //                   ^^^^^^
-  return getTestPrefix() + Name;
+  return TestPrefix + Name;
 }
 
 GlobalContext::~GlobalContext() {
   llvm::DeleteContainerPointers(AllThreadContexts);
 }
 
 // TODO(stichnot): Consider adding thread-local caches of constant
 // pool entries to reduce contention.
 
 // All locking is done by the getConstantInt[0-9]+() target function.
@@ skipping 241 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice