[llvm-commits] [llvm] r50765 - in /llvm/trunk: tools/llvmc2/Common.td tools/llvmc2/doc/LLVMC-Tutorial.rst utils/TableGen/LLVMCConfigurationEmitter.cpp

Mikhail Glushenkov foldr at codedgers.com
Tue May 6 11:18:20 PDT 2008


Author: foldr
Date: Tue May  6 13:18:20 2008
New Revision: 50765

URL: http://llvm.org/viewvc/llvm-project?rev=50765&view=rev
Log:
Add new edge property combinator: weight.

Modified:
    llvm/trunk/tools/llvmc2/Common.td
    llvm/trunk/tools/llvmc2/doc/LLVMC-Tutorial.rst
    llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp

Modified: llvm/trunk/tools/llvmc2/Common.td
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvmc2/Common.td?rev=50765&r1=50764&r2=50765&view=diff

==============================================================================
--- llvm/trunk/tools/llvmc2/Common.td (original)
+++ llvm/trunk/tools/llvmc2/Common.td Tue May  6 13:18:20 2008
@@ -53,6 +53,7 @@
 def if_input_languages_contain;
 
 // Edge property combinators.
+def weight;
 def and;
 def or;
 
@@ -77,8 +78,8 @@
 
 class Edge<Tool t1, Tool t2> : EdgeBase<t1, t2, []>;
 
-// Edge and DefaultEdge are synonyms.
-class DefaultEdge<Tool t1, Tool t2> : EdgeBase<t1, t2, []>;
+// Edge and SimpleEdge are synonyms.
+class SimpleEdge<Tool t1, Tool t2> : EdgeBase<t1, t2, []>;
 
 // Optionally enabled edge.
 class OptionalEdge<Tool t1, Tool t2, list<dag> lst> : EdgeBase<t1, t2, lst>;

Modified: llvm/trunk/tools/llvmc2/doc/LLVMC-Tutorial.rst
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvmc2/doc/LLVMC-Tutorial.rst?rev=50765&r1=50764&r2=50765&view=diff

==============================================================================
--- llvm/trunk/tools/llvmc2/doc/LLVMC-Tutorial.rst (original)
+++ llvm/trunk/tools/llvmc2/doc/LLVMC-Tutorial.rst Tue May  6 13:18:20 2008
@@ -120,11 +120,20 @@
     language belongs to the current input language set.
 
   - ``and`` - Edge property combinator. Returns true if all of its
-    arguments return true. Used like this: (and
-    (prop1), (prop2), ... (propN)). Nesting not allowed.
+    arguments return true. Used like this: ``(and (prop1), (prop2),
+    ... (propN))``. Nesting is allowed, but not encouraged.
 
   - ``or`` - Edge property combinator that returns true if any one of its
-    arguments returns true. Example: (or (prop1), (prop2), ... (propN))
+    arguments returns true. Example: ``(or (prop1), (prop2), ... (propN))``.
+
+  - ``weight`` - Makes it possible to explicitly specify the quantity
+    added to the edge weight if this edge property matches. Used like
+    this: ``(weight N, (prop))``. The inner property can include
+    ``and`` and ``or`` combinators. When N is equal to 2, equivalent
+    to ``(prop)``.
+
+    Example: ``(weight 8, (and (switch_on "a"), (switch_on "b")))``.
+
 
 To get a visual representation of the compilation graph (useful for
 debugging), run ``llvmc2 --view-graph``. You will need ``dot`` and

Modified: llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp?rev=50765&r1=50764&r2=50765&view=diff

==============================================================================
--- llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp (original)
+++ llvm/trunk/utils/TableGen/LLVMCConfigurationEmitter.cpp Tue May  6 13:18:20 2008
@@ -58,6 +58,17 @@
   return val.getValue();
 }
 
+int InitPtrToInt(Init* ptr) {
+  IntInit& val = dynamic_cast<IntInit&>(*ptr);
+  return val.getValue();
+}
+
+const DagInit& InitPtrToDagInitRef(Init* ptr) {
+  DagInit& val = dynamic_cast<DagInit&>(*ptr);
+  return val;
+}
+
+
 // Ensure that the number of args in d is <= min_arguments,
 // throw exception otherwise
 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
@@ -310,15 +321,15 @@
 
   // "Property handler" - a function that extracts information
   // about a given tool property from its DAG representation
-  typedef void (CollectProperties::*PropertyHandler)(DagInit*);
+  typedef void (CollectProperties::*PropertyHandler)(const DagInit*);
 
   // Map from property names -> property handlers
   typedef StringMap<PropertyHandler> PropertyHandlerMap;
 
   // "Option property handler" - a function that extracts information
   // about a given option property from its DAG representation
-  typedef void (CollectProperties::*
-                OptionPropertyHandler)(DagInit*, GlobalOptionDescription &);
+  typedef void (CollectProperties::* OptionPropertyHandler)
+  (const DagInit*, GlobalOptionDescription &);
 
   // Map from option property names -> option property handlers
   typedef StringMap<OptionPropertyHandler> OptionPropertyHandlerMap;
@@ -375,7 +386,7 @@
   // Gets called for every tool property;
   // Just forwards to the corresponding property handler.
   void operator() (Init* i) {
-    DagInit& d = dynamic_cast<DagInit&>(*i);
+    const DagInit& d = InitPtrToDagInitRef(i);
     const std::string& property_name = d.getOperator()->getAsString();
     PropertyHandlerMap::iterator method
       = propertyHandlers_.find(property_name);
@@ -395,81 +406,95 @@
   /// Functions that extract information about tool properties from
   /// DAG representation.
 
-  void onCmdLine (DagInit* d) {
+  void onCmdLine (const DagInit* d) {
     checkNumberOfArguments(d, 1);
     SplitString(InitPtrToString(d->getArg(0)), toolProps_.CmdLine);
     if (toolProps_.CmdLine.empty())
       throw "Tool " + toolProps_.Name + " has empty command line!";
   }
 
-  void onInLanguage (DagInit* d) {
+  void onInLanguage (const DagInit* d) {
     checkNumberOfArguments(d, 1);
     toolProps_.InLanguage = InitPtrToString(d->getArg(0));
   }
 
-  void onJoin (DagInit* d) {
+  void onJoin (const DagInit* d) {
     checkNumberOfArguments(d, 0);
     toolProps_.setJoin();
   }
 
-  void onOutLanguage (DagInit* d) {
+  void onOutLanguage (const DagInit* d) {
     checkNumberOfArguments(d, 1);
     toolProps_.OutLanguage = InitPtrToString(d->getArg(0));
   }
 
-  void onOutputSuffix (DagInit* d) {
+  void onOutputSuffix (const DagInit* d) {
     checkNumberOfArguments(d, 1);
     toolProps_.OutputSuffix = InitPtrToString(d->getArg(0));
   }
 
-  void onSink (DagInit* d) {
+  void onSink (const DagInit* d) {
     checkNumberOfArguments(d, 0);
     optDescs_.HasSink = true;
     toolProps_.setSink();
   }
 
-  void onSwitch (DagInit* d)        { addOption(d, OptionType::Switch); }
-  void onParameter (DagInit* d)     { addOption(d, OptionType::Parameter); }
-  void onParameterList (DagInit* d) { addOption(d, OptionType::ParameterList); }
-  void onPrefix (DagInit* d)        { addOption(d, OptionType::Prefix); }
-  void onPrefixList (DagInit* d)    { addOption(d, OptionType::PrefixList); }
+  void onSwitch (const DagInit* d) {
+    addOption(d, OptionType::Switch);
+  }
+
+  void onParameter (const DagInit* d) {
+    addOption(d, OptionType::Parameter);
+  }
+
+  void onParameterList (const DagInit* d) {
+    addOption(d, OptionType::ParameterList);
+  }
+
+  void onPrefix (const DagInit* d) {
+    addOption(d, OptionType::Prefix);
+  }
+
+  void onPrefixList (const DagInit* d) {
+    addOption(d, OptionType::PrefixList);
+  }
 
   /// Option property handlers --
   /// Methods that handle properties that are common for all types of
   /// options (like append_cmd, stop_compilation)
 
-  void onAppendCmd (DagInit* d, GlobalOptionDescription& o) {
+  void onAppendCmd (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 1);
     std::string const& cmd = InitPtrToString(d->getArg(0));
 
     toolProps_.OptDescs[o.Name].AddProperty(OptionPropertyType::AppendCmd, cmd);
   }
 
-  void onForward (DagInit* d, GlobalOptionDescription& o) {
+  void onForward (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 0);
     toolProps_.OptDescs[o.Name].setForward();
   }
 
-  void onHelp (DagInit* d, GlobalOptionDescription& o) {
+  void onHelp (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 1);
     const std::string& help_message = InitPtrToString(d->getArg(0));
 
     o.Help = help_message;
   }
 
-  void onRequired (DagInit* d, GlobalOptionDescription& o) {
+  void onRequired (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 0);
     o.setRequired();
   }
 
-  void onStopCompilation (DagInit* d, GlobalOptionDescription& o) {
+  void onStopCompilation (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 0);
     if (o.Type != OptionType::Switch)
       throw std::string("Only options of type Switch can stop compilation!");
     toolProps_.OptDescs[o.Name].setStopCompilation();
   }
 
-  void onUnpackValues (DagInit* d, GlobalOptionDescription& o) {
+  void onUnpackValues (const DagInit* d, GlobalOptionDescription& o) {
     checkNumberOfArguments(d, 0);
     toolProps_.OptDescs[o.Name].setUnpackValues();
   }
@@ -477,7 +502,7 @@
   /// Helper functions
 
   // Add an option of type t
-  void addOption (DagInit* d, OptionType::OptionType t) {
+  void addOption (const DagInit* d, OptionType::OptionType t) {
     checkNumberOfArguments(d, 2);
     const std::string& name = InitPtrToString(d->getArg(0));
 
@@ -506,13 +531,13 @@
   // Parameters:
   // name - option name
   // d - option property list
-  void processOptionProperties (DagInit* d, GlobalOptionDescription& o) {
+  void processOptionProperties (const DagInit* d, GlobalOptionDescription& o) {
     // First argument is option name
     checkNumberOfArguments(d, 2);
 
     for (unsigned B = 1, E = d->getNumArgs(); B!=E; ++B) {
-      DagInit& option_property
-        = dynamic_cast<DagInit&>(*d->getArg(B));
+      const DagInit& option_property
+        = InitPtrToDagInitRef(d->getArg(B));
       const std::string& option_property_name
         = option_property.getOperator()->getAsString();
       OptionPropertyHandlerMap::iterator method
@@ -963,18 +988,10 @@
   return false;
 }
 
-// Helper function used by EmitEdgeClass.
-void EmitEdgePropertyTest(const std::string& PropName,
-                          const DagInit& Prop,
+// Forward declaration.
+void EmitEdgePropertyTest(const DagInit& Prop,
                           const GlobalOptionDescriptions& OptDescs,
-                          std::ostream& O) {
-  if (EmitEdgePropertyTest1Arg(PropName, Prop, OptDescs, O))
-    return;
-  else if (EmitEdgePropertyTest2Args(PropName, Prop, OptDescs, O))
-    return;
-  else
-    throw PropName + ": unknown edge property!";
-}
+                          std::ostream& O);
 
 // Helper function used by EmitEdgeClass.
 void EmitLogicalOperationTest(const DagInit& Prop, const char* LogicOp,
@@ -982,10 +999,8 @@
                               std::ostream& O) {
   O << '(';
   for (unsigned j = 0, NumArgs = Prop.getNumArgs(); j < NumArgs; ++j) {
-    const DagInit& InnerProp = dynamic_cast<DagInit&>(*Prop.getArg(j));
-    const std::string& InnerPropName =
-      InnerProp.getOperator()->getAsString();
-    EmitEdgePropertyTest(InnerPropName, InnerProp, OptDescs, O);
+    const DagInit& InnerProp = InitPtrToDagInitRef(Prop.getArg(j));
+    EmitEdgePropertyTest(InnerProp, OptDescs, O);
     if (j != NumArgs - 1)
       O << ")\n" << Indent3 << ' ' << LogicOp << " (";
     else
@@ -993,11 +1008,28 @@
   }
 }
 
+// Helper function used by EmitEdgeClass.
+void EmitEdgePropertyTest(const DagInit& Prop,
+                          const GlobalOptionDescriptions& OptDescs,
+                          std::ostream& O) {
+  const std::string& PropName = Prop.getOperator()->getAsString();
+
+  if (PropName == "and")
+    EmitLogicalOperationTest(Prop, "&&", OptDescs, O);
+  else if (PropName == "or")
+    EmitLogicalOperationTest(Prop, "||", OptDescs, O);
+  else if (EmitEdgePropertyTest1Arg(PropName, Prop, OptDescs, O))
+    return;
+  else if (EmitEdgePropertyTest2Args(PropName, Prop, OptDescs, O))
+    return;
+  else
+    throw PropName + ": unknown edge property!";
+}
+
 // Emit a single Edge* class.
 void EmitEdgeClass(unsigned N, const std::string& Target,
                    ListInit* Props, const GlobalOptionDescriptions& OptDescs,
                    std::ostream& O) {
-  bool IsDefault = false;
 
   // Class constructor.
   O << "class Edge" << N << ": public Edge {\n"
@@ -1009,28 +1041,26 @@
     << Indent1 << "unsigned Weight(const InputLanguagesSet& InLangs) const {\n"
     << Indent2 << "unsigned ret = 0;\n";
 
+  // Emit tests for every edge property.
   for (size_t i = 0, PropsSize = Props->size(); i < PropsSize; ++i) {
-    const DagInit& Prop = dynamic_cast<DagInit&>(*Props->getElement(i));
+    const DagInit& Prop = InitPtrToDagInitRef(Props->getElement(i));
     const std::string& PropName = Prop.getOperator()->getAsString();
-
-    if (PropName == "default")
-      IsDefault = true;
+    unsigned N = 2;
 
     O << Indent2 << "if (";
-    if (PropName == "and") {
-      EmitLogicalOperationTest(Prop, "&&", OptDescs, O);
-    }
-    else if (PropName == "or") {
-      EmitLogicalOperationTest(Prop, "||", OptDescs, O);
+
+    if (PropName == "weight") {
+      checkNumberOfArguments(&Prop, 2);
+      N = InitPtrToInt(Prop.getArg(0));
+      const DagInit& InnerProp = InitPtrToDagInitRef(Prop.getArg(1));
+      EmitEdgePropertyTest(InnerProp, OptDescs, O);
     }
     else {
-      EmitEdgePropertyTest(PropName, Prop, OptDescs, O);
+      EmitEdgePropertyTest(Prop, OptDescs, O);
     }
-    O << ")\n" << Indent3 << "ret += 2;\n";
-  }
 
-  if (IsDefault)
-    O << Indent2 << "ret += 1;\n";
+    O << ")\n" << Indent3 << "ret += " << N << ";\n";
+  }
 
   O << Indent2 << "return ret;\n"
     << Indent1 << "};\n\n};\n\n";





More information about the llvm-commits mailing list