Subzero: Use a "known" version of clang-format.

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        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 that uses LLVM capabilities to parse a
@@ skipping 55 matching lines @@
         clEnumValN(Ice::Target_ARM32, "arm32", "arm32 (same as arm)"),
         clEnumValN(Ice::Target_ARM64, "arm64", "arm64"), 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"),
-         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));
+    OptLevel(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));
 static cl::opt<std::string> IRFilename(cl::Positional, cl::desc("<IR file>"),
                                        cl::init("-"));
 static cl::opt<std::string> OutputFilename("o",
                                            cl::desc("Override output filename"),
                                            cl::init("-"),
                                            cl::value_desc("filename"));
 static cl::opt<std::string> LogFilename("log", cl::desc("Set log filename"),
                                         cl::init("-"),
                                         cl::value_desc("filename"));
 static cl::opt<std::string>
-TestPrefix("prefix", cl::desc("Prepend a prefix to symbol names for testing"),
-           cl::init(""), cl::value_desc("prefix"));
+    TestPrefix("prefix",
+               cl::desc("Prepend a prefix to symbol names for testing"),
+               cl::init(""), cl::value_desc("prefix"));
+static cl::opt<bool> DisableInternal("externalize",
+                                     cl::desc("Externalize all symbols"));
 static cl::opt<bool>
-DisableInternal("externalize",
-                cl::desc("Externalize all symbols"));
-static cl::opt<bool>
-DisableTranslation("notranslate", cl::desc("Disable Subzero translation"));
+    DisableTranslation("notranslate", cl::desc("Disable Subzero translation"));
 // Note: Modifiable only if ALLOW_DISABLE_IR_GEN.
 static cl::opt<bool>
     DisableIRGeneration("no-ir-gen",
                         cl::desc("Disable generating Subzero IR."));
 static cl::opt<std::string>
-TranslateOnly("translate-only", cl::desc("Translate only the given function"),
-              cl::init(""));
+    TranslateOnly("translate-only",
+                  cl::desc("Translate only the given function"), cl::init(""));
 
 static cl::opt<bool> SubzeroTimingEnabled(
     "timing", cl::desc("Enable breakdown timing of Subzero translation"));
 
-static cl::opt<bool>
-TimeEachFunction("timing-funcs",
-                 cl::desc("Print total translation time for each function"));
+static cl::opt<bool> TimeEachFunction(
+    "timing-funcs", cl::desc("Print total translation time for each function"));
 
 static cl::opt<std::string> TimingFocusOn(
     "timing-focus",
     cl::desc("Break down timing for a specific function (use '*' for all)"),
     cl::init(""));
 
 static cl::opt<std::string> VerboseFocusOn(
     "verbose-focus",
     cl::desc("Temporarily enable full verbosity for a specific function"),
     cl::init(""));
 
 static cl::opt<bool>
-EnablePhiEdgeSplit("phi-edge-split",
-                   cl::desc("Enable edge splitting for Phi lowering"),
-                   cl::init(true));
+    EnablePhiEdgeSplit("phi-edge-split",
+                       cl::desc("Enable edge splitting for Phi lowering"),
+                       cl::init(true));
 
 static cl::opt<bool> DecorateAsm(
     "asm-verbose",
     cl::desc("Decorate textual asm output with register liveness info"));
 
 static cl::opt<bool>
-DumpStats("szstats",
-          cl::desc("Print statistics after translating each function"));
+    DumpStats("szstats",
+              cl::desc("Print statistics after translating each function"));
 
 // This is currently needed by crosstest.py.
 static cl::opt<bool> AllowUninitializedGlobals(
     "allow-uninitialized-globals",
     cl::desc("Allow global variables to be uninitialized"));
 
 static cl::opt<NaClFileFormat> InputFileFormat(
     "bitcode-format", cl::desc("Define format of input file:"),
     cl::values(clEnumValN(LLVMFormat, "llvm", "LLVM file (default)"),
                clEnumValN(PNaClFormat, "pnacl", "PNaCl bitcode file"),
@@ skipping 19 matching lines @@
 static cl::opt<bool>
     BuildOnRead("build-on-read",
                 cl::desc("Build ICE instructions when reading bitcode"),
                 cl::init(true));
 
 static cl::opt<bool> AllowErrorRecovery(
     "allow-pnacl-reader-error-recovery",
     cl::desc("Allow error recovery when reading PNaCl bitcode."),
     cl::init(false));
 
-static cl::opt<bool>
-LLVMVerboseErrors(
+static 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));
 
 static cl::opt<bool>
     UseIntegratedAssembler("integrated-as",
                            cl::desc("Use integrated assembler (default yes)"),
                            cl::init(true));
 
 static cl::alias UseIas("ias", cl::desc("Alias for -integrated-as"),
                         cl::NotHidden, cl::aliasopt(UseIntegratedAssembler));
 
 static cl::opt<bool>
     UseELFWriter("elf-writer",
                  cl::desc("Use ELF writer with the integrated assembler"),
                  cl::init(false));
 
 static cl::opt<bool> AlwaysExitSuccess(
     "exit-success", cl::desc("Exit with success status, even if errors found"),
     cl::init(false));
 
-static cl::opt<bool>
-GenerateBuildAtts("build-atts",
-                  cl::desc("Generate list of build attributes associated with "
+static cl::opt<bool> GenerateBuildAtts(
+    "build-atts", cl::desc("Generate list of build attributes associated with "
                            "this executable."),
-                  cl::init(false));
+    cl::init(false));
 
 // 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.)
-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(0));
+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(0));
 
 static int GetReturnValue(int Val) {
   if (AlwaysExitSuccess)
     return 0;
   return Val;
 }
 
 static struct {
   const char *FlagName;
   int FlagValue;
@@ skipping 143 matching lines @@
   if (BuildOnRead) {
     std::unique_ptr<Ice::PNaClTranslator> PTranslator(
         new Ice::PNaClTranslator(&Ctx, Flags));
     PTranslator->translate(IRFilename);
     Translator.reset(PTranslator.release());
   } else if (ALLOW_LLVM_IR) {
     // Parse the input LLVM IR file into a module.
     SMDiagnostic Err;
     Ice::TimerMarker T1(Ice::TimerStack::TT_parse, &Ctx);
     raw_ostream *Verbose = LLVMVerboseErrors ? &errs() : nullptr;
-    Module *Mod =
-        NaClParseIRFile(IRFilename, InputFileFormat, Err, Verbose,
-                        getGlobalContext());
+    Module *Mod = NaClParseIRFile(IRFilename, InputFileFormat, Err, Verbose,
+                                  getGlobalContext());
 
     if (!Mod) {
       Err.print(argv[0], errs());
       return GetReturnValue(Ice::EC_Bitcode);
     }
 
     std::unique_ptr<Ice::Converter> Converter(
         new Ice::Converter(Mod, &Ctx, Flags));
     Converter->convertToIce();
     Translator.reset(Converter.release());
@@ skipping 14 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());
 }