Subzero: Allow per-method controls.

Makefile.standalone

@@ -308,6 +308,7 @@ SRCS = \
   IceMangling.cpp \
   IceMemory.cpp \
   IceOperand.cpp \
+  IceRangeSpec.cpp \
   IceRegAlloc.cpp \
   IceRNG.cpp \
   IceSwitchLowering.cpp \

src/IceCfg.cpp

@@ -197,20 +197,25 @@ void Cfg::addCallToProfileSummary() {
 void Cfg::translate() {
   if (hasError())
     return;
+  // Cache the possibly-overridden optimization level once translation begins.
+  // It would be nicer to do this in the constructor, but we need to wait until
+  // after setFunctionName() has a chance to be called.
+  OptimizationLevel =
+      getFlags().matchForceO2(getFunctionName(), getSequenceNumber())
+          ? Opt_2
+          : getFlags().getOptLevel();
   if (BuildDefs::timers()) {
-    const std::string TimingFocusOn = getFlags().getTimingFocusOn();
-    if (!TimingFocusOn.empty()) {
-      const std::string Name = getFunctionName().toString();
-      if (TimingFocusOn == "*" || TimingFocusOn == Name) {
-        setFocusedTiming();
-        getContext()->resetTimer(GlobalContext::TSK_Default);
-      }
+    if (getFlags().matchTimingFocus(getFunctionName(), getSequenceNumber())) {
+      setFocusedTiming();
+      getContext()->resetTimer(GlobalContext::TSK_Default);
     }
   }
   if (BuildDefs::dump()) {
-    if (isVerbose(IceV_Status)) {
+    if (isVerbose(IceV_Status) &&
+        getFlags().matchTestStatus(getFunctionName(), getSequenceNumber())) {
       getContext()->getStrDump() << ">>>Translating "
-                                 << getFunctionNameAndSize() << "\n";
+                                 << getFunctionNameAndSize()
+                                 << " seq=" << getSequenceNumber() << "\n";
     }
   }
   TimerMarker T_func(getContext(), getFunctionName().toStringOrEmpty());
@@ -222,7 +227,7 @@ void Cfg::translate() {
     profileBlocks();
     // TODO(jpp): this is fragile, at best. Figure out a better way of
     // detecting exit functions.
-    if (GlobalContext::matchSymbolName(getFunctionName(), "exit")) {
+    if (getFunctionName().toStringOrEmpty() == "exit") {
       addCallToProfileSummary();
     }
     dump("Profiled CFG");

src/IceCfg.h

@@ -40,6 +40,7 @@ public:
 
   GlobalContext *getContext() const { return Ctx; }
   uint32_t getSequenceNumber() const { return SequenceNumber; }
+  OptLevel getOptLevel() const { return OptimizationLevel; }
 
   static constexpr VerboseMask defaultVerboseMask() {
     return (IceV_NO_PER_PASS_DUMP_BEYOND << 1) - 1;
@@ -296,7 +297,8 @@ private:
   void findRematerializable();
 
   GlobalContext *Ctx;
-  uint32_t SequenceNumber;             /// output order for emission
+  uint32_t SequenceNumber; /// output order for emission
+  OptLevel OptimizationLevel = Opt_m1;
   uint32_t ConstantBlindingCookie = 0; /// cookie for constant blinding
   VerboseMask VMask;
   GlobalString FunctionName;

src/IceClFlags.cpp

@@ -193,6 +193,11 @@ void ClFlags::getParsedClFlags(ClFlags &OutFlags) {
                                         DisableInternalObj);
   OutFlags.setDisableHybridAssembly(DisableHybridAssemblyObj ||
                                     (OutFileTypeObj != Ice::FT_Iasm));
+  OutFlags.ForceO2.init(OutFlags.getForceO2String());
+  OutFlags.TestStatus.init(OutFlags.getTestStatusString());
+  OutFlags.TimingFocus.init(OutFlags.getTimingFocusOnString());
+  OutFlags.TranslateOnly.init(OutFlags.getTranslateOnlyString());
+  OutFlags.VerboseFocus.init(OutFlags.getVerboseFocusOnString());
 }
 
 } // end of namespace Ice

src/IceClFlags.def

@@ -149,6 +149,9 @@ struct dev_list_flag {};
   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(""))  \
+                                                                               \
   X(FunctionSections, bool, dev_opt_flag, "ffunction-sections",                \
     cl::desc("Emit functions into separate sections"))                         \
                                                                                \
@@ -282,15 +285,18 @@ struct dev_list_flag {};
              "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"))  \
                                                                                \
@@ -335,9 +341,9 @@ struct dev_list_flag {};
                    "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

src/IceClFlags.h

@@ -18,6 +18,7 @@
 #include "IceDefs.h"
 #include "IceBuildDefs.h"
 #include "IceClFlags.def"
+#include "IceRangeSpec.h"
 #include "IceTypes.h"
 
 #ifdef __clang__
@@ -150,12 +151,36 @@ public:
   void setGenerateUnitTestMessages(bool NewValue) {
     GenerateUnitTestMessages = NewValue;
   }
+  bool matchForceO2(GlobalString Name, uint32_t Number) const {
+    return ForceO2.match(Name, Number);
+  }
+  bool matchTestStatus(GlobalString Name, uint32_t Number) const {
+    return TestStatus.match(Name, Number);
+  }
+  bool matchTimingFocus(GlobalString Name, uint32_t Number) const {
+    return TimingFocus.match(Name, Number);
+  }
+  bool matchTranslateOnly(GlobalString Name, uint32_t Number) const {
+    return TranslateOnly.match(Name, Number);
+  }
+  bool matchVerboseFocusOn(GlobalString Name, uint32_t Number) const {
+    return VerboseFocus.match(Name, Number);
+  }
+  bool matchVerboseFocusOn(const std::string &Name, uint32_t Number) const {
+    return VerboseFocus.match(Name, Number);
+  }
 
 private:
   std::string AppName;
 
   /// Initialized to false; not set by the command line.
   bool GenerateUnitTestMessages;
+
+  RangeSpec ForceO2;
+  RangeSpec TestStatus;
+  RangeSpec TimingFocus;
+  RangeSpec TranslateOnly;
+  RangeSpec VerboseFocus;
 };
 
 inline const ClFlags &getFlags() { return ClFlags::Flags; }

src/IceELFObjectWriter.cpp

@@ -288,10 +288,9 @@ classifyGlobalSection(const VariableDeclaration *Var) {
 // Partition the Vars list by SectionType into VarsBySection. If TranslateOnly
 // is non-empty, then only the TranslateOnly variable is kept for emission.
 void partitionGlobalsBySection(const VariableDeclarationList &Vars,
-                               VariableDeclarationPartition VarsBySection[],
-                               const std::string &TranslateOnly) {
+                               VariableDeclarationPartition VarsBySection[]) {
   for (VariableDeclaration *Var : Vars) {
-    if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+    if (getFlags().matchTranslateOnly(Var->getName(), 0)) {
       size_t Section = classifyGlobalSection(Var);
       assert(Section < ELFObjectWriter::NumSectionTypes);
       VarsBySection[Section].push_back(Var);
@@ -310,7 +309,7 @@ void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
   VariableDeclarationPartition VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
-  partitionGlobalsBySection(Vars, VarsBySection, getFlags().getTranslateOnly());
+  partitionGlobalsBySection(Vars, VarsBySection);
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,

src/IceGlobalContext.cpp

@@ -367,18 +367,17 @@ void GlobalContext::translateFunctions() {
     CfgLocalAllocatorScope _(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
-    // Set verbose level to none if the current function does NOT
-    // match the -verbose-focus command-line option.
-    if (!matchSymbolName(Func->getFunctionName(),
-                         getFlags().getVerboseFocusOn()))
+    // Set verbose level to none if the current function does NOT match the
+    // -verbose-focus command-line option.
+    if (!getFlags().matchVerboseFocusOn(Func->getFunctionName(),
+                                        Func->getSequenceNumber()))
       Func->setVerbose(IceV_None);
-    // Disable translation if -notranslate is specified, or if the
-    // current function matches the -translate-only option.  If
-    // translation is disabled, just dump the high-level IR and
-    // continue.
+    // Disable translation if -notranslate is specified, or if the current
+    // function matches the -translate-only option.  If translation is disabled,
+    // just dump the high-level IR and continue.
     if (getFlags().getDisableTranslation() ||
-        !matchSymbolName(Func->getFunctionName(),
-                         getFlags().getTranslateOnly())) {
+        !getFlags().matchTranslateOnly(Func->getFunctionName(),
+                                       Func->getSequenceNumber())) {
       Func->dump();
       continue; // Func goes out of scope and gets deleted
     }
@@ -467,7 +466,7 @@ void GlobalContext::lowerGlobals(const std::string &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
   const bool DumpGlobalVariables =
       BuildDefs::dump() && (getFlags().getVerbose() & IceV_GlobalInit) &&
-      getFlags().getVerboseFocusOn().empty();
+      getFlags().matchVerboseFocusOn("", 0);
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
@@ -532,11 +531,6 @@ void GlobalContext::lowerProfileData() {
   lowerGlobals(ProfileDataSection);
 }
 
-bool GlobalContext::matchSymbolName(const GlobalString &SymbolName,
-                                    const std::string &Match) {
-  return Match.empty() || Match == SymbolName.toString();
-}
-
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
@@ -690,7 +684,7 @@ void GlobalContext::dumpConstantLookupCounts() {
   if (!BuildDefs::dump())
     return;
   const bool DumpCounts = (getFlags().getVerbose() & IceV_ConstPoolStats) &&
-                          getFlags().getVerboseFocusOn().empty();
+                          getFlags().matchVerboseFocusOn("", 0);
   if (!DumpCounts)
     return;
 
@@ -1024,7 +1018,7 @@ void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
     Active = getFlags().getSubzeroTimingEnabled() ||
-             !getFlags().getTimingFocusOn().empty();
+             !getFlags().getTimingFocusOnString().empty();
     break;
   case GlobalContext::TSK_Funcs:
     Active = getFlags().getTimeEachFunction();

src/IceGlobalContext.h

@@ -453,14 +453,6 @@ public:
 
   void dumpConstantLookupCounts();
 
-  /// Utility function to match a symbol name against a match string. This is
-  /// used in a few cases where we want to take some action on a particular
-  /// function or symbol based on a command-line argument, such as changing the
-  /// verbose level for a particular function. An empty Match argument means
-  /// match everything. Returns true if there is a match.
-  static bool matchSymbolName(const GlobalString &SymbolName,
-                              const std::string &Match);
-
   /// DisposeGlobalVariablesAfterLowering controls whether the memory used by
   /// GlobaleVariables can be reclaimed right after they have been lowered.
   /// @{

src/IceRangeSpec.cpp

+//===- subzero/src/IceRangeSpec.cpp - Include/exclude specification -------===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Implements a class for specifying sets of names and number ranges to
+/// match against.  This is specified as a comma-separated list of clauses.
+/// Each clause optionally starts with '-' to indicate exclusion instead of
+/// inclusion.  A clause can be a name, or a numeric range X:Y, or a single
+/// number X.  The X:Y form indicates a range of numbers greater than or equal
+/// to X and strictly less than Y.  A missing "X" is taken to be 0, and a
+/// missing "Y" is taken to be infinite.  E.g., "0:" and ":" specify the entire
+/// set.
+///
+/// This is essentially the same implementation as in szbuild.py, except that
+/// regular expressions are not used for the names.
+///
+//===----------------------------------------------------------------------===//
+
+#include "IceRangeSpec.h"
+#include "IceStringPool.h"
+
+#include <cctype>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace Ice {
+
+bool RangeSpec::HasNames = false;
+
+namespace {
+
+/// Helper function to tokenize a string into a vector of string tokens, given a
+/// single delimiter character.  An empty string produces an empty token vector.
+/// Zero-length tokens are allowed, e.g. ",a,,,b," may tokenize to
+/// {"","a","","","b",""}.
+std::vector<std::string> tokenize(const std::string &Spec, char Delimiter) {
+  std::vector<std::string> Tokens;
+  if (!Spec.empty()) {
+    std::string::size_type StartPos = 0;
+    std::string::size_type DelimPos = 0;
+    while (DelimPos != std::string::npos) {
+      DelimPos = Spec.find(Delimiter, StartPos);
+      Tokens.emplace_back(Spec.substr(StartPos, DelimPos - StartPos));
+      StartPos = DelimPos + 1;
+    }
+  }
+  return Tokens;
+}
+
+/// Helper function to parse "X" or "X:Y" into First and Last.
+/// - "X" is treated as "X:X+1".
+/// - ":Y" is treated as "0:Y".
+/// - "X:" is treated as "X:inf"
+///
+/// Behavior is undefined if "X" or "Y" is not a proper number (since std::stoul
+/// throws an exception).
+///
+/// If the string doesn't contain 1 or 2 ':' delimiters, or X>=Y,
+/// report_fatal_error is called.
+void getRange(const std::string &Token, uint32_t *First, uint32_t *Last) {
+  bool Error = false;
+  auto Tokens = tokenize(Token, RangeSpec::DELIM_RANGE);
+  if (Tokens.size() == 1) {
+    *First = std::stoul(Tokens[0]);
+    *Last = *First + 1;
+  } else if (Tokens.size() == 2) {
+    *First = Tokens[0].empty() ? 0 : std::stoul(Tokens[0]);
+    *Last = Tokens[1].empty() ? RangeSpec::RangeMax : std::stoul(Tokens[1]);
+  } else {
+    Error = true;
+  }
+  if (*First >= *Last) {
+    Error = true;
+  }
+  if (Error) {
+    llvm::report_fatal_error("Invalid range " + Token);
+  }
+}
+
+/// Helper function to add one token to the include or exclude set.  The token
+/// is examined and then treated as either a numeric range or a single name.
+void record(const std::string &Token, RangeSpec::Desc *D) {
+  if (Token.empty())
+    return;
+  // Mark that an include or exclude was explicitly given.  This affects the
+  // default decision when matching a value that wasn't explicitly provided in
+  // the include or exclude list.
+  D->IsExplicit = true;
+  // A range is identified by starting with a digit or a ':'.
+  if (Token[0] == RangeSpec::DELIM_RANGE || std::isdigit(Token[0])) {
+    uint32_t First, Last;
+    getRange(Token, &First, &Last);
+    if (Last == RangeSpec::RangeMax) {
+      D->AllFrom = std::min(D->AllFrom, First);
+    } else {
+      if (Last >= D->Numbers.size())
+        D->Numbers.resize(Last + 1);
+      D->Numbers.set(First, Last);
+    }
+  } else {
+    // Otherwise treat it as a single name.
+    D->Names.insert(Token);
+  }
+}
+
+} // end of anonymous namespace
+
+/// Initialize the RangeSpec with the given string.  Calling init multiple times
+/// (e.g. init("A");init("B");) is equivalent to init("A,B"); .
+void RangeSpec::init(const std::string &Spec) {
+  auto Tokens = tokenize(Spec, DELIM_LIST);
+  for (const auto &Token : Tokens) {
+    if (Token[0] == '-') {
+      exclude(Token.substr(1));
+    } else {
+      include(Token);
+    }
+  }
+  if (!Includes.Names.empty() || !Excludes.Names.empty())
+    HasNames = true;
+}
+
+/// Determine whether the given Name/Number combo match the specification given
+/// to the init() method.  Explicit excludes take precedence over explicit
+/// includes.  If the combo doesn't match any explicit include or exclude:
+/// - false if the init() string is empty (no explicit includes or excludes)
+/// - true if there is at least one explicit exclude and no explicit includes
+/// - false otherwise (at least one explicit include)
+bool RangeSpec::match(const std::string &Name, uint32_t Number) const {
+  // No match if it is explicitly excluded by name or number.
+  if (Excludes.Names.find(Name) != Excludes.Names.end())
+    return false;
+  if (Number >= Excludes.AllFrom)
+    return false;
+  if (Number < Excludes.Numbers.size() && Excludes.Numbers[Number])
+    return false;
+
+  // Positive match if it is explicitly included by name or number.
+  if (Includes.Names.find(Name) != Includes.Names.end())
+    return true;
+  if (Number >= Includes.AllFrom)
+    return true;
+  if (Number < Includes.Numbers.size() && Includes.Numbers[Number])
+    return true;
+
+  // Otherwise use the default decision.
+  return Excludes.IsExplicit && !Includes.IsExplicit;
+}
+
+void RangeSpec::include(const std::string &Token) { record(Token, &Includes); }
+
+void RangeSpec::exclude(const std::string &Token) { record(Token, &Excludes); }
+
+} // end of namespace Ice

src/IceRangeSpec.h

+//===- subzero/src/IceRangeSpec.h - Include/exclude specs -------*- C++ -*-===//
+//
+//                        The Subzero Code Generator
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Declares a class for specifying inclusion/exclusion of values, such
+/// as functions to match.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SUBZERO_SRC_ICERANGESPEC_H
+#define SUBZERO_SRC_ICERANGESPEC_H
+
+#include "IceStringPool.h"
+
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "llvm/ADT/BitVector.h"
+
+namespace Ice {
+
+class RangeSpec {
+  RangeSpec(const RangeSpec &) = delete;
+  RangeSpec &operator=(const RangeSpec &) = delete;
+
+public:
+  static constexpr char DELIM_LIST = ',';
+  static constexpr char DELIM_RANGE = ':';
+  static constexpr uint32_t RangeMax = std::numeric_limits<uint32_t>::max();
+  RangeSpec() = default;
+  struct Desc {
+    // Set of names explicitly provided.
+    std::unordered_set<std::string> Names;
+    // Set of numbers explicitly provided.
+    llvm::BitVector Numbers;
+    // The smallest X for which the open-ended interval "X:" was provided.  This
+    // is needed because the intervals are parsed before we know the largest
+    // number that might be matched against, and we can't make the Numbers
+    // bitvector infinitely long.
+    uint32_t AllFrom = RangeMax;
+    // Whether a clause was explicitly provided.
+    bool IsExplicit = false;
+  };
+  void init(const std::string &Spec);
+  bool match(const std::string &Name, uint32_t Number) const;
+  bool match(GlobalString Name, uint32_t Number) const {
+    return match(Name.toStringOrEmpty(), Number);
+  }
+  // Returns true if any RangeSpec object has had init() called with an explicit
+  // name rather than (or in addition to) a numeric range.  If so, we want to
+  // construct explicit names for functions even in a non-DUMP build so that
+  // matching on function name works correctly.  Note that this is not
+  // thread-safe, so we count on all this being handled by the startup thread.
+  static bool hasNames() { return HasNames; }
+
+private:
+  void include(const std::string &Token);
+  void exclude(const std::string &Token);
+  Desc Includes;
+  Desc Excludes;
+  static bool HasNames;
+};
+
+} // end of namespace Ice
+
+#endif // SUBZERO_SRC_ICERANGESPEC_H

src/IceStringPool.h

@@ -17,6 +17,8 @@
 #ifndef SUBZERO_SRC_ICESTRINGPOOL_H
 #define SUBZERO_SRC_ICESTRINGPOOL_H
 
+#include "IceDefs.h" // Ostream
+
 #include <cstdint> // uintptr_t
 #include <string>
 

src/IceTargetLowering.h

@@ -181,7 +181,7 @@ public:
   virtual std::unique_ptr<Assembler> createAssembler() const = 0;
 
   void translate() {
-    switch (getFlags().getOptLevel()) {
+    switch (Func->getOptLevel()) {
     case Opt_m1:
       translateOm1();
       break;

src/IceTargetLoweringARM32.cpp

@@ -6817,10 +6817,9 @@ void TargetDataARM32::lowerGlobals(const VariableDeclarationList &Vars,
   } break;
   case FT_Asm:
   case FT_Iasm: {
-    const std::string TranslateOnly = getFlags().getTranslateOnly();
     OstreamLocker _(Ctx);
     for (const VariableDeclaration *Var : Vars) {
-      if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+      if (getFlags().matchTranslateOnly(Var->getName(), 0)) {
         emitGlobal(*Var, SectionSuffix);
       }
     }

src/IceTargetLoweringMIPS32.cpp

@@ -1211,10 +1211,9 @@ void TargetDataMIPS32::lowerGlobals(const VariableDeclarationList &Vars,
   } break;
   case FT_Asm:
   case FT_Iasm: {
-    const std::string TranslateOnly = getFlags().getTranslateOnly();
     OstreamLocker L(Ctx);
     for (const VariableDeclaration *Var : Vars) {
-      if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+      if (getFlags().matchTranslateOnly(Var->getName(), 0)) {
         emitGlobal(*Var, SectionSuffix);
       }
     }

src/IceTargetLoweringX86BaseImpl.h

@@ -1399,7 +1399,7 @@ void TargetX86Base<TraitsType>::lowerAlloca(const InstAlloca *Instr) {
   const uint32_t Alignment =
       std::max(AlignmentParam, Traits::X86_STACK_ALIGNMENT_BYTES);
   const bool OverAligned = Alignment > Traits::X86_STACK_ALIGNMENT_BYTES;
-  const bool OptM1 = getFlags().getOptLevel() == Opt_m1;
+  const bool OptM1 = Func->getOptLevel() == Opt_m1;
   const bool AllocaWithKnownOffset = Instr->getKnownFrameOffset();
   const bool UseFramePointer =
       hasFramePointer() || OverAligned || !AllocaWithKnownOffset || OptM1;
@@ -1529,7 +1529,7 @@ bool TargetX86Base<TraitsType>::optimizeScalarMul(Variable *Dest, Operand *Src0,
                                                   int32_t Src1) {
   // Disable this optimization for Om1 and O0, just to keep things simple
   // there.
-  if (getFlags().getOptLevel() < Opt_1)
+  if (Func->getOptLevel() < Opt_1)
     return false;
   Type Ty = Dest->getType();
   if (Src1 == -1) {
@@ -2223,7 +2223,7 @@ void TargetX86Base<TraitsType>::lowerArithmetic(const InstArithmetic *Instr) {
   case InstArithmetic::Sdiv:
     // TODO(stichnot): Enable this after doing better performance and cross
     // testing.
-    if (false && getFlags().getOptLevel() >= Opt_1) {
+    if (false && Func->getOptLevel() >= Opt_1) {
       // Optimize division by constant power of 2, but not for Om1 or O0, just
       // to keep things simple there.
       if (auto *C = llvm::dyn_cast<ConstantInteger32>(Src1)) {
@@ -2313,7 +2313,7 @@ void TargetX86Base<TraitsType>::lowerArithmetic(const InstArithmetic *Instr) {
   case InstArithmetic::Srem: {
     // TODO(stichnot): Enable this after doing better performance and cross
     // testing.
-    if (false && getFlags().getOptLevel() >= Opt_1) {
+    if (false && Func->getOptLevel() >= Opt_1) {
       // Optimize mod by constant power of 2, but not for Om1 or O0, just to
       // keep things simple there.
       if (auto *C = llvm::dyn_cast<ConstantInteger32>(Src1)) {
@@ -4306,7 +4306,7 @@ bool TargetX86Base<TraitsType>::tryOptimizedCmpxchgCmpBr(Variable *Dest,
                                                          Operand *PtrToMem,
                                                          Operand *Expected,
                                                          Operand *Desired) {
-  if (getFlags().getOptLevel() == Opt_m1)
+  if (Func->getOptLevel() == Opt_m1)
     return false;
   // Peek ahead a few instructions and see how Dest is used.
   // It's very common to have:
@@ -7016,7 +7016,7 @@ Type TargetX86Base<TraitsType>::firstTypeThatFitsSize(uint32_t Size,
 }
 
 template <typename TraitsType> void TargetX86Base<TraitsType>::postLower() {
-  if (getFlags().getOptLevel() == Opt_m1)
+  if (Func->getOptLevel() == Opt_m1)
     return;
   markRedefinitions();
   Context.availabilityUpdate();
@@ -7417,10 +7417,9 @@ void TargetDataX86<TraitsType>::lowerGlobals(
   } break;
   case FT_Asm:
   case FT_Iasm: {
-    const std::string TranslateOnly = getFlags().getTranslateOnly();
     OstreamLocker L(Ctx);
     for (const VariableDeclaration *Var : Vars) {
-      if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
+      if (getFlags().matchTranslateOnly(Var->getName(), 0)) {
         emitGlobal(*Var, SectionSuffix);
       }
     }

src/PNaClTranslator.cpp

@@ -22,6 +22,7 @@
 #include "IceGlobalInits.h"
 #include "IceInst.h"
 #include "IceOperand.h"
+#include "IceRangeSpec.h"
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -481,10 +482,9 @@ private:
       // - DUMP is enabled
       // - The symbol is external
       // - The -timing-funcs flag is enabled
-      // - The -timing-focus flag is enabled
+      // - Some RangeSpec is initialized with actual names
       if (Ice::BuildDefs::dump() || !Decl->isInternal() ||
-          Ice::getFlags().getTimeEachFunction() ||
-          !Ice::getFlags().getTimingFocusOn().empty()) {
+          Ice::RangeSpec::hasNames() || Ice::getFlags().getTimeEachFunction()) {
         Decl->setName(Ctx, Translator.createUnnamedName(Prefix, NameIndex));
       } else {
         Decl->setName(Ctx);

tests_lit/llvm2ice_tests/rangespec.ll

+; Tests basic functionality of RangeSpec matching.  Makes use of the fact that
+; "-verbose=status" prints the sequence number, and "-test-status" can suppress
+; this output.  Note that seq=2 is the first sequence number for functions.
+
+; REQUIRES: allow_dump
+
+define internal void @Func2() { ret void }
+define internal void @Func3() { ret void }
+define internal void @Func4() { ret void }
+define internal void @Func5() { ret void }
+define internal void @Func6() { ret void }
+define internal void @Func7() { ret void }
+define internal void @Func8() { ret void }
+define internal void @Func9() { ret void }
+define internal void @Func10() { ret void }
+define internal void @Func11() { ret void }
+
+; A few tests that include everything.
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=: \
+; RUN:   | FileCheck %s --check-prefix=TEST1
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=2: \
+; RUN:   | FileCheck %s --check-prefix=TEST1
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=:20 \
+; RUN:   | FileCheck %s --check-prefix=TEST1
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=-xxx \
+; RUN:   | FileCheck %s --check-prefix=TEST1
+; TEST1: seq=2
+; TEST1: seq=3
+; TEST1: seq=4
+; TEST1: seq=5
+; TEST1: seq=6
+; TEST1: seq=7
+; TEST1: seq=8
+; TEST1: seq=9
+; TEST1: seq=10
+; TEST1: seq=11
+
+; Several ways of expressing 3+4+5+6
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=3:7 \
+; RUN:   | FileCheck %s --check-prefix=TEST2
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=3:6,6 \
+; RUN:   | FileCheck %s --check-prefix=TEST2
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=5,3:5,6 \
+; RUN:   | FileCheck %s --check-prefix=TEST2
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=3:9,-7: \
+; RUN:   | FileCheck %s --check-prefix=TEST2
+; RUN: %p2i -i %s -o /dev/null --args -verbose status -threads=0 \
+; RUN:   -test-status=3:9,-Func7,-Func8 \
+; RUN:   | FileCheck %s --check-prefix=TEST2
+; TEST2-NOT: seq=2
+; TEST2: seq=3
+; TEST2: seq=4
+; TEST2: seq=5
+; TEST2: seq=6
+; TEST2-NOT: seq=7
+; TEST2-NOT: seq=8
+; TEST2-NOT: seq=9
+; TEST2-NOT: seq=10
+; TEST2-NOT: seq=11
+; TEST2-NOT: seq=12