Reflow comments to use the full width.

src/IceClFlags.cpp

 //===- 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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// 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.
+/// 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 "IceClFlags.h"
 
 #include "IceClFlagsExtra.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunused-parameter"
 #include "llvm/Support/CommandLine.h"
@@ skipping 68 matching lines @@
     ForceMemIntrinOpt("fmem-intrin-opt",
                       cl::desc("Force optimization of memory intrinsics."));
 
 cl::opt<bool>
     FunctionSections("ffunction-sections",
                      cl::desc("Emit functions into separate sections"));
 
 cl::opt<bool> MockBoundsCheck("mock-bounds-check",
                               cl::desc("Mock bounds checking on loads/stores"));
 
-// 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.)
+// 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().
+    // 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.
+// 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(1));
 
 cl::opt<bool> ShouldDoNopInsertion("nop-insertion",
                                    cl::desc("Randomly insert NOPs"),
                                    cl::init(false));
 
 cl::opt<bool>
     RandomizeRegisterAllocation("randomize-regalloc",
@@ skipping 107 matching lines @@
         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.
+// 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),
@@ skipping 134 matching lines @@
   // size_t and 64-bit fields.
   OutFlags.NumTranslationThreads = 0;
   OutFlags.RandomSeed = 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.
+  // Don't generate verbose messages if routines to dump messages are not
+  // available.
   if (BuildDefs::dump()) {
     for (unsigned i = 0; i != VerboseList.size(); ++i)
       VMask |= VerboseList[i];
   }
 
   OutFlags.setAllowErrorRecovery(::AllowErrorRecovery);
   OutFlags.setAllowIacaMarks(::AllowIacaMarks);
   OutFlags.setAllowUninitializedGlobals(::AllowUninitializedGlobals);
   OutFlags.setDataSections(::DataSections);
   OutFlags.setDecorateAsm(::DecorateAsm);
@@ skipping 46 matching lines @@
   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