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

src/main.cpp

 //===- subzero/src/main.cpp - Driver for bitcode translation --------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver for translating PNaCl bitcode into native code.
@@ skipping 51 matching lines @@
     cl::values(
         clEnumValN(Ice::Target_X8632, "x8632", "x86-32"),
         clEnumValN(Ice::Target_X8632, "x86-32", "x86-32 (same as x8632)"),
         clEnumValN(Ice::Target_X8632, "x86_32", "x86-32 (same as x8632)"),
         clEnumValN(Ice::Target_X8664, "x8664", "x86-64"),
         clEnumValN(Ice::Target_X8664, "x86-64", "x86-64 (same as x8664)"),
         clEnumValN(Ice::Target_X8664, "x86_64", "x86-64 (same as x8664)"),
         clEnumValN(Ice::Target_ARM32, "arm", "arm32"),
         clEnumValN(Ice::Target_ARM32, "arm32", "arm32 (same as arm)"),
         clEnumValN(Ice::Target_ARM64, "arm64", "arm64"), clEnumValEnd));
+
+cl::opt<Ice::TargetInstructionSet> InstructionSet(
+    "mattr", cl::desc("Target architecture attributes"),
+    cl::init(Ice::X86InstructionSet_SSE2),
+    cl::values(clEnumValN(Ice::X86InstructionSet_SSE2, "sse2",
+                          "Enable SSE2 instructions (default)"),
+               clEnumValN(Ice::X86InstructionSet_SSE4_1, "sse4.1",
+                          "Enable SSE 4.1 instructions"),
+               clEnumValEnd));
+
 static cl::opt<bool> UseSandboxing("sandbox", cl::desc("Use sandboxing"));
 static cl::opt<bool>
     FunctionSections("ffunction-sections",
                      cl::desc("Emit functions into separate sections"));
 static cl::opt<bool>
     DataSections("fdata-sections",
                  cl::desc("Emit (global) data into separate sections"));
 static cl::opt<Ice::OptLevel>
     OptLevel(cl::desc("Optimization level"), cl::init(Ice::Opt_m1),
              cl::value_desc("level"),
@@ skipping 122 matching lines @@
 // sequential, i.e. parser, translator, and emitter all within the
 // same single thread.  (This may need a slight rework if we expand to
 // multiple parser or emitter threads.)
 static cl::opt<uint32_t> NumThreads(
     "threads",
     cl::desc("Number of translation threads (0 for purely sequential)"),
     // TODO(stichnot): Settle on a good default.  Consider
     // something related to std::thread::hardware_concurrency().
     cl::init(2));
 
+static cl::opt<bool> DoNopInsertion("nop-insertion",
+                                    cl::desc("Randomly insert NOPs"),
+                                    cl::init(false));
+
+static cl::opt<int> MaxNopsPerInstruction(
+    "max-nops-per-instruction",
+    cl::desc("Max number of nops to insert per instruction"), cl::init(1));
+
+static cl::opt<int> NopProbabilityAsPercentage(
+    "nop-insertion-percentage",
+    cl::desc("Nop insertion probability as percentage"), cl::init(10));
+
+static cl::opt<bool>
+    RandomizeRegisterAllocation("randomize-regalloc",
+                                cl::desc("Randomize register allocation"),
+                                cl::init(false));
+
+// TODO(stichnot): See if we can easily use LLVM's -rng-seed option
+// and implementation.  I expect the implementation is different and
+// therefore the tests would need to be changed.
+cl::opt<unsigned long long>
+    RandomSeed("sz-seed", cl::desc("Seed the random number generator"),
+               cl::init(time(0)));
+
 static int GetReturnValue(int Val) {
   if (AlwaysExitSuccess)
     return 0;
   return Val;
 }
 
 static struct {
   const char *FlagName;
   int FlagValue;
 } ConditionalBuildAttributes[] = {{"dump", ALLOW_DUMP},
@@ skipping 73 matching lines @@
   Flags.setDataSections(DataSections);
   Flags.setDecorateAsm(DecorateAsm);
   Flags.setDefaultFunctionPrefix(DefaultFunctionPrefix);
   Flags.setDefaultGlobalPrefix(DefaultGlobalPrefix);
   Flags.setDisableInternal(DisableInternal);
   Flags.setDisableIRGeneration(DisableIRGeneration);
   Flags.setDisableTranslation(DisableTranslation);
   Flags.setDumpStats(DumpStats);
   Flags.setFunctionSections(FunctionSections);
   Flags.setNumTranslationThreads(NumThreads);
+  Flags.setOptLevel(OptLevel);
   Flags.setPhiEdgeSplit(EnablePhiEdgeSplit);
+  Flags.setRandomSeed(RandomSeed);
+  Flags.setShouldDoNopInsertion(DoNopInsertion);
+  Flags.setShouldRandomizeRegAlloc(RandomizeRegisterAllocation);
   Flags.setSubzeroTimingEnabled(SubzeroTimingEnabled);
+  Flags.setTargetArch(TargetArch);
+  Flags.setTargetInstructionSet(InstructionSet);
+  Flags.setTestPrefix(TestPrefix);
   Flags.setTimeEachFunction(TimeEachFunction);
   Flags.setTimingFocusOn(TimingFocusOn);
   Flags.setTranslateOnly(TranslateOnly);
   Flags.setUseSandboxing(UseSandboxing);
   Flags.setVerboseFocusOn(VerboseFocusOn);
   Flags.setOutFileType(OutFileType);
+  Flags.setMaxNopsPerInstruction(MaxNopsPerInstruction);
+  Flags.setNopProbabilityAsPercentage(NopProbabilityAsPercentage);
+  Flags.setVerbose(VMask);
 
   // Force -build-on-read=0 for .ll files.
   const std::string LLSuffix = ".ll";
   if (IRFilename.length() >= LLSuffix.length() &&
       IRFilename.compare(IRFilename.length() - LLSuffix.length(),
                          LLSuffix.length(), LLSuffix) == 0)
     BuildOnRead = false;
 
   // With the ELF writer, use a raw_fd_ostream to allow seeking.
   // Also don't buffer, otherwise it gets pretty slow.
@@ skipping 25 matching lines @@
     if (OutputFilename != "-") {
       Ofs.open(OutputFilename.c_str(), std::ofstream::out);
       Os.reset(new raw_os_ostream(Ofs));
     } else {
       Os.reset(new raw_os_ostream(std::cout));
     }
     Os->SetUnbuffered();
   } break;
   }
 
-  Ice::GlobalContext Ctx(Ls.get(), Os.get(), ELFStr.get(), VMask, TargetArch,
-                         OptLevel, TestPrefix, Flags);
+  Ice::GlobalContext Ctx(Ls.get(), Os.get(), ELFStr.get(), Flags);
 
   Ice::TimerMarker T(Ice::TimerStack::TT_szmain, &Ctx);
 
   if (OutFileType == Ice::FT_Elf) {
     Ice::TimerMarker T1(Ice::TimerStack::TT_emit, &Ctx);
     Ctx.getObjectWriter()->writeInitialELFHeader();
   }
 
   Ctx.startWorkerThreads();
 
@@ skipping 47 matching lines @@
   if (SubzeroTimingEnabled)
     Ctx.dumpTimers();
   if (TimeEachFunction) {
     const bool DumpCumulative = false;
     Ctx.dumpTimers(Ice::GlobalContext::TSK_Funcs, DumpCumulative);
   }
   const bool FinalStats = true;
   Ctx.dumpStats("_FINAL_", FinalStats);
   return GetReturnValue(Ctx.getErrorStatus()->value());
 }