Refactor Subzero initialization and add a browser callback handler.

src/IceClFlags.cpp

Index: src/IceClFlags.cpp
diff --git a/src/IceClFlags.cpp b/src/IceClFlags.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..9e24665744ff286f2cc59c43938becb6f14604c8
--- /dev/null
+++ b/src/IceClFlags.cpp
@@ -0,0 +1,304 @@
+//===- subzero/src/IceClFlags.cpp - Command line flags and parsing --------===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines commandline flags parsing.
+// This currently relies on llvm::cl to parse.  In the future, the minimal
+// build can have a simpler parser.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/CommandLine.h"
+
+#include "IceClFlags.h"
+#include "IceClFlagsExtra.h"
+
+namespace cl = llvm::cl;
+
+// Options which are captured in Ice::ClFlags and propagated.
+
+namespace {
+
+cl::opt<bool> AllowErrorRecovery(
+    "allow-pnacl-reader-error-recovery",
+    cl::desc("Allow error recovery when reading PNaCl bitcode."),
+    cl::init(false));
+
+// This is currently needed by crosstest.py.
+cl::opt<bool> AllowUninitializedGlobals(
+    "allow-uninitialized-globals",
+    cl::desc("Allow global variables to be uninitialized"));
+
+cl::opt<bool>
+    DataSections("fdata-sections",
+                 cl::desc("Emit (global) data into separate sections"));
+
+cl::opt<bool> DecorateAsm(
+    "asm-verbose",
+    cl::desc("Decorate textual asm output with register liveness info"));
+
+cl::opt<std::string>
+    DefaultFunctionPrefix("default-function-prefix",
+                          cl::desc("Define default function prefix for naming "
+                                   "unnamed functions"),
+                          cl::init("Function"));
+
+cl::opt<std::string>
+    DefaultGlobalPrefix("default-global-prefix",
+                        cl::desc("Define default global prefix for naming "
+                                 "unnamed globals"),
+                        cl::init("Global"));
+cl::opt<bool> DisableInternal("externalize",
+                              cl::desc("Externalize all symbols"));
+// Note: Modifiable only if ALLOW_DISABLE_IR_GEN.
+cl::opt<bool> DisableIRGeneration("no-ir-gen",
+                                  cl::desc("Disable generating Subzero IR."));
+cl::opt<bool> DisableTranslation("notranslate",
+                                 cl::desc("Disable Subzero translation"));
+
+cl::opt<bool>
+    DumpStats("szstats",
+              cl::desc("Print statistics after translating each function"));
+
+cl::opt<bool>
+    FunctionSections("ffunction-sections",
+                     cl::desc("Emit functions into separate sections"));
+
+// Number of translation threads (in addition to the parser thread and
+// the emitter thread).  The special case of 0 means purely
+// 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.)
+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));
+
+cl::opt<Ice::OptLevel> OLevel(cl::desc("Optimization level"),
+                              cl::init(Ice::Opt_m1), cl::value_desc("level"),
+                              cl::values(clEnumValN(Ice::Opt_m1, "Om1", "-1"),
+                                         clEnumValN(Ice::Opt_m1, "O-1", "-1"),
+                                         clEnumValN(Ice::Opt_0, "O0", "0"),
+                                         clEnumValN(Ice::Opt_1, "O1", "1"),
+                                         clEnumValN(Ice::Opt_2, "O2", "2"),
+                                         clEnumValEnd));
+
+cl::opt<bool>
+    EnablePhiEdgeSplit("phi-edge-split",
+                       cl::desc("Enable edge splitting for Phi lowering"),
+                       cl::init(true));
+
+// 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)));
+
+cl::opt<bool> ShouldDoNopInsertion("nop-insertion",
+                                   cl::desc("Randomly insert NOPs"),
+                                   cl::init(false));
+
+cl::opt<bool>
+    RandomizeRegisterAllocation("randomize-regalloc",
+                                cl::desc("Randomize register allocation"),
+                                cl::init(false));
+
+cl::opt<bool> SubzeroTimingEnabled(
+    "timing", cl::desc("Enable breakdown timing of Subzero translation"));
+
+cl::opt<Ice::TargetArch> TargetArch(
+    "target", cl::desc("Target architecture:"), cl::init(Ice::Target_X8632),
+    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> TargetInstructionSet(
+    "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));
+cl::opt<std::string>
+    TestPrefix("prefix",
+               cl::desc("Prepend a prefix to symbol names for testing"),
+               cl::init(""), cl::value_desc("prefix"));
+
+cl::opt<bool> TimeEachFunction(
+    "timing-funcs", cl::desc("Print total translation time for each function"));
+
+cl::opt<std::string> TimingFocusOn(
+    "timing-focus",
+    cl::desc("Break down timing for a specific function (use '*' for all)"),
+    cl::init(""));
+
+cl::opt<std::string>
+    TranslateOnly("translate-only",
+                  cl::desc("Translate only the given function"), cl::init(""));
+
+cl::opt<bool> UseSandboxing("sandbox", cl::desc("Use sandboxing"));
+
+cl::opt<std::string> VerboseFocusOn(
+    "verbose-focus",
+    cl::desc("Temporarily enable full verbosity for a specific function"),
+    cl::init(""));
+
+cl::opt<Ice::FileType> OutFileType(
+    "filetype", cl::desc("Output file type"), cl::init(Ice::FT_Iasm),
+    cl::values(clEnumValN(Ice::FT_Elf, "obj", "Native ELF object ('.o') file"),
+               clEnumValN(Ice::FT_Asm, "asm", "Assembly ('.s') file"),
+               clEnumValN(Ice::FT_Iasm, "iasm",
+                          "Low-level integrated assembly ('.s') file"),
+               clEnumValEnd));
+
+cl::opt<int> MaxNopsPerInstruction(
+    "max-nops-per-instruction",
+    cl::desc("Max number of nops to insert per instruction"), cl::init(1));
+
+cl::opt<int> NopProbabilityAsPercentage(
+    "nop-insertion-percentage",
+    cl::desc("Nop insertion probability as percentage"), cl::init(10));
+
+cl::list<Ice::VerboseItem> VerboseList(
+    "verbose", cl::CommaSeparated,
+    cl::desc("Verbose options (can be comma-separated):"),
+    cl::values(
+        clEnumValN(Ice::IceV_Instructions, "inst", "Print basic instructions"),
+        clEnumValN(Ice::IceV_Deleted, "del", "Include deleted instructions"),
+        clEnumValN(Ice::IceV_InstNumbers, "instnum",
+                   "Print instruction numbers"),
+        clEnumValN(Ice::IceV_Preds, "pred", "Show predecessors"),
+        clEnumValN(Ice::IceV_Succs, "succ", "Show successors"),
+        clEnumValN(Ice::IceV_Liveness, "live", "Liveness information"),
+        clEnumValN(Ice::IceV_RegOrigins, "orig", "Physical register origins"),
+        clEnumValN(Ice::IceV_LinearScan, "regalloc", "Linear scan details"),
+        clEnumValN(Ice::IceV_Frame, "frame", "Stack frame layout details"),
+        clEnumValN(Ice::IceV_AddrOpt, "addropt", "Address mode optimization"),
+        clEnumValN(Ice::IceV_Random, "random", "Randomization details"),
+        clEnumValN(Ice::IceV_All, "all", "Use all verbose options"),
+        clEnumValN(Ice::IceV_Most, "most",
+                   "Use all verbose options except 'regalloc'"),
+        clEnumValN(Ice::IceV_None, "none", "No verbosity"), clEnumValEnd));
+
+// Options not captured in Ice::ClFlags and propagated.
+
+cl::opt<bool> AlwaysExitSuccess(
+    "exit-success", cl::desc("Exit with success status, even if errors found"),
+    cl::init(false));
+
+// Note: While this flag isn't used in the minimal build, we keep this
+// flag so that tests can set this command-line flag without concern
+// to the type of build. We double check that this flag at runtime
+// to make sure the consistency is maintained.
+cl::opt<bool>
+    BuildOnRead("build-on-read",
+                cl::desc("Build ICE instructions when reading bitcode"),
+                cl::init(true));
+
+cl::opt<llvm::NaClFileFormat> InputFileFormat(
+    "bitcode-format", cl::desc("Define format of input file:"),
+    cl::values(clEnumValN(llvm::LLVMFormat, "llvm", "LLVM file (default)"),
+               clEnumValN(llvm::PNaClFormat, "pnacl", "PNaCl bitcode file"),
+               clEnumValEnd),
+    cl::init(llvm::LLVMFormat));
+
+cl::opt<bool> GenerateBuildAtts(
+    "build-atts", cl::desc("Generate list of build attributes associated with "
+                           "this executable."),
+    cl::init(false));
+
+cl::opt<std::string> IRFilename(cl::Positional, cl::desc("<IR file>"),
+                                cl::init("-"));
+cl::opt<std::string> LogFilename("log", cl::desc("Set log filename"),
+                                 cl::init("-"), cl::value_desc("filename"));
+cl::opt<bool> LLVMVerboseErrors(
+    "verbose-llvm-parse-errors",
+    cl::desc("Print out more descriptive PNaCl bitcode parse errors when "
+             "building LLVM IR first"),
+    cl::init(false));
+cl::opt<std::string> OutputFilename("o", cl::desc("Override output filename"),
+                                    cl::init("-"), cl::value_desc("filename"));
+
+Ice::IceString AppName;
+
+} // end of anonymous namespace
+
+namespace Ice {
+
+void ClFlags::parseFlags(int argc, char **argv) {
+  cl::ParseCommandLineOptions(argc, argv);
+  AppName = IceString(argv[0]);
+}
+
+void ClFlags::getParsedClFlags(ClFlags &OutFlags) {
+  if (::DisableIRGeneration)
+    ::DisableTranslation = true;
+
+  Ice::VerboseMask VMask = Ice::IceV_None;
+  // Don't generate verbose messages if routines
+  // to dump messages are not available.
+  if (ALLOW_DUMP) {
+    for (unsigned i = 0; i != VerboseList.size(); ++i)
+      VMask |= VerboseList[i];
+  }
+
+  OutFlags.setAllowErrorRecovery(::AllowErrorRecovery);
+  OutFlags.setAllowUninitializedGlobals(::AllowUninitializedGlobals);
+  OutFlags.setDataSections(::DataSections);
+  OutFlags.setDecorateAsm(::DecorateAsm);
+  OutFlags.setDefaultFunctionPrefix(::DefaultFunctionPrefix);
+  OutFlags.setDefaultGlobalPrefix(::DefaultGlobalPrefix);
+  OutFlags.setDisableInternal(::DisableInternal);
+  OutFlags.setDisableIRGeneration(::DisableIRGeneration);
+  OutFlags.setDisableTranslation(::DisableTranslation);
+  OutFlags.setDumpStats(::DumpStats);
+  OutFlags.setFunctionSections(::FunctionSections);
+  OutFlags.setNumTranslationThreads(::NumThreads);
+  OutFlags.setOptLevel(::OLevel);
+  OutFlags.setPhiEdgeSplit(::EnablePhiEdgeSplit);
+  OutFlags.setRandomSeed(::RandomSeed);
+  OutFlags.setShouldDoNopInsertion(::ShouldDoNopInsertion);
+  OutFlags.setShouldRandomizeRegAlloc(::RandomizeRegisterAllocation);
+  OutFlags.setSubzeroTimingEnabled(::SubzeroTimingEnabled);
+  OutFlags.setTargetArch(::TargetArch);
+  OutFlags.setTargetInstructionSet(::TargetInstructionSet);
+  OutFlags.setTestPrefix(::TestPrefix);
+  OutFlags.setTimeEachFunction(::TimeEachFunction);
+  OutFlags.setTimingFocusOn(::TimingFocusOn);
+  OutFlags.setTranslateOnly(::TranslateOnly);
+  OutFlags.setUseSandboxing(::UseSandboxing);
+  OutFlags.setVerboseFocusOn(::VerboseFocusOn);
+  OutFlags.setOutFileType(::OutFileType);
+  OutFlags.setMaxNopsPerInstruction(::MaxNopsPerInstruction);
+  OutFlags.setNopProbabilityAsPercentage(::NopProbabilityAsPercentage);
+  OutFlags.setVerbose(VMask);
+}
+
+void ClFlags::getParsedClFlagsExtra(ClFlagsExtra &OutFlagsExtra) {
+  OutFlagsExtra.setAlwaysExitSuccess(AlwaysExitSuccess);
+  OutFlagsExtra.setBuildOnRead(BuildOnRead);
+  OutFlagsExtra.setGenerateBuildAtts(GenerateBuildAtts);
+  OutFlagsExtra.setLLVMVerboseErrors(LLVMVerboseErrors);
+  OutFlagsExtra.setAppName(AppName);
+  OutFlagsExtra.setInputFileFormat(InputFileFormat);
+  OutFlagsExtra.setIRFilename(IRFilename);
+  OutFlagsExtra.setLogFilename(LogFilename);
+  OutFlagsExtra.setOutputFilename(OutputFilename);
+}
+
+} // end of namespace Ice