Subzero: Allow per-method controls.

src/IceClFlags.def

 //===- subzero/src/IceClFlags.def - Cl Flags for translation ----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 131 matching lines @@
                                                                                \
   X(EnablePhiEdgeSplit, bool, dev_opt_flag, "phi-edge-split",                  \
     cl::desc("Enable edge splitting for Phi lowering"), cl::init(true))        \
                                                                                \
   X(ExcludedRegisters, std::string, dev_list_flag, "reg-exclude",              \
     cl::CommaSeparated, cl::desc("Don't use specified registers"))             \
                                                                                \
   X(ForceMemIntrinOpt, bool, dev_opt_flag, "fmem-intrin-opt",                  \
     cl::desc("Force optimization of memory intrinsics."))                      \
                                                                                \
+  X(ForceO2String, std::string, dev_opt_flag, "force-O2",                      \
+    cl::desc("Force -O2 for certain functions (assumes -Om1)"), cl::init(""))  \

[Eric Holk, 2016/04/18 18:51:49]

Just to make sure I understand how to use this option, the idea is to isolate
codegen bugs by translating with -Om1 for most things and translating a single
problematic function with -O2, right? The goal is to prevent translation bugs in
other functions from affecting the one we're currently looking at.

My first instinct would have been to use -Om1 for one problematic function and
leave the rest as -O2, but after thinking some more I think -Om1 by default is
better.

[Jim Stichnoth, 2016/04/18 19:49:48]

Right.  At least in my experience, bisection debugging is easiest when you can
express it as "it breaks when I enable a feature for e.g. methods 0:50000, so
try to reduce that range to a single method that breaks it".  Thus use the
reliable Om1 by default and then for O2 for a narrower and narrower range until
a single offending method is found.

+                                                                               \
   X(FunctionSections, bool, dev_opt_flag, "ffunction-sections",                \
     cl::desc("Emit functions into separate sections"))                         \
                                                                                \
   X(GenerateBuildAtts, bool, release_opt_flag, "build-atts",                   \
     cl::desc("Generate list of build attributes associated with "              \
              "this executable."),                                              \
     cl::init(false))                                                           \
                                                                                \
   X(InputFileFormat, llvm::NaClFileFormat, dev_opt_flag, "bitcode-format",     \
     cl::desc("Define format of input file:"),                                  \
@@ skipping 113 matching lines @@
                                                                                \
   X(TestPrefix, std::string, dev_opt_flag, "prefix",                           \
     cl::desc("Prepend a prefix to symbol names for testing"), cl::init(""),    \
     cl::value_desc("prefix"))                                                  \
                                                                                \
   X(TestStackExtra, uint32_t, dev_opt_flag, "test-stack-extra",                \
     cl::desc("Extra amount of stack to add to the "                            \
              "frame in bytes (for testing)."),                                 \
     cl::init(0))                                                               \
                                                                                \
+  X(TestStatusString, std::string, dev_opt_flag, "test-status",                \
+    cl::desc("Testing flag for -verbose=status"), cl::init(":"))               \
+                                                                               \
   X(TimeEachFunction, bool, dev_opt_flag, "timing-funcs",                      \
     cl::desc("Print total translation time for each function"))                \
                                                                                \
-  X(TimingFocusOn, std::string, dev_opt_flag, "timing-focus",                  \
-    cl::desc("Break down timing for a specific function (use '*' for all)"),   \
+  X(TimingFocusOnString, std::string, dev_opt_flag, "timing-focus",            \
+    cl::desc("Break down timing for specific functions (use ':' for all)"),    \
     cl::init(""))                                                              \
                                                                                \
-  X(TranslateOnly, std::string, dev_opt_flag, "translate-only",                \
-    cl::desc("Translate only the given function"), cl::init(""))               \
+  X(TranslateOnlyString, std::string, dev_opt_flag, "translate-only",          \
+    cl::desc("Translate only the given functions"), cl::init(":"))             \
                                                                                \
   X(UseNonsfi, bool, dev_opt_flag, "nonsfi", cl::desc("Enable Non-SFI mode"))  \
                                                                                \
   X(UseRestrictedRegisters, std::string, dev_list_flag, "reg-use",             \
     cl::CommaSeparated,                                                        \
     cl::desc("Only use specified registers for corresponding register "        \
              "classes"))                                                       \
                                                                                \
   X(UseSandboxing, bool, dev_opt_flag, "sandbox", cl::desc("Use sandboxing"))  \
                                                                                \
@@ skipping 24 matching lines @@
         clEnumValN(Ice::IceV_GlobalInit, "global_init",                        \
                    "Global initializers"),                                     \
         clEnumValN(Ice::IceV_ConstPoolStats, "cpool",                          \
                    "Constant pool counters"),                                  \
         clEnumValN(Ice::IceV_Wasm, "wasm", "WebAssembly builder"),             \
         clEnumValN(Ice::IceV_All, "all", "Use all verbose options"),           \
         clEnumValN(Ice::IceV_Most, "most",                                     \
                    "Use all verbose options except 'regalloc,global_init'"),   \
         clEnumValN(Ice::IceV_None, "none", "No verbosity"), clEnumValEnd))     \
                                                                                \
-  X(VerboseFocusOn, std::string, dev_opt_flag, "verbose-focus",                \
-    cl::desc("Override with -verbose=none except for the specified function"), \
-    cl::init(""))
+  X(VerboseFocusOnString, std::string, dev_opt_flag, "verbose-focus",          \
+    cl::desc("Override with -verbose=none except for specified functions"),    \
+    cl::init(":"))
 //#define X(Name, Type, ClType, ...)
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICECLFLAGS_DEF