Ongoing work: add an edge typechecker, rudimentary support for edge properties.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50725 91177308-0d34-0410-b5e6-96231b3b80d8

4 files changed, 133 insertions, 77 deletions

diff --git a/tools/llvmc2/Common.td b/tools/llvmc2/Common.td
index ea211e1..4435857 100644
--- a/tools/llvmc2/Common.td
+++ b/tools/llvmc2/Common.td
@@ -15,7 +15,7 @@ class Tool<list<dag> l> {
       list<dag> properties = l;
 }
 
-// Special Tool instance - root of all toolchains
+// Special Tool instance - graph root.
 
 def root : Tool<[]>;
 
@@ -45,6 +45,17 @@ def unpack_values;
 def help;
 def required;
 
+// Possible edge properties
+
+def switch_on;
+def parameter_equals;
+def element_in_list;
+
+// Property combinators
+// TOFIX: implement
+def and;
+def or;
+
 // Map from suffixes to language names
 
 class LangToSuffixes<string str, list<string> lst> {
@@ -58,11 +69,20 @@ class LanguageMap<list<LangToSuffixes> lst> {
 
 // Compilation graph
 
-class Edge<Tool t1, Tool t2> {
+class EdgeBase<Tool t1, Tool t2, list<dag> lst> {
       Tool a = t1;
       Tool b = t2;
+      list<dag> props = lst;
 }
 
-class CompilationGraph<list<Edge> lst> {
-      list<Edge> edges = lst;
+class Edge<Tool t1, Tool t2> : EdgeBase<t1, t2, []>;
+
+// Edge and DefaultEdge are synonyms.
+class DefaultEdge<Tool t1, Tool t2> : EdgeBase<t1, t2, []>;
+
+// Optionally enabled edge.
+class OptionalEdge<Tool t1, Tool t2, list<dag> lst> : EdgeBase<t1, t2, lst>;
+
+class CompilationGraph<list<EdgeBase> lst> {
+      list<EdgeBase> edges = lst;
 }
diff --git a/tools/llvmc2/CompilationGraph.cpp b/tools/llvmc2/CompilationGraph.cpp
index bff1aa5..07b09e7 100644
--- a/tools/llvmc2/CompilationGraph.cpp
+++ b/tools/llvmc2/CompilationGraph.cpp
@@ -60,7 +60,7 @@ CompilationGraph::getToolsVector(const std::string& LangName) const
   return I->second;
 }
 
-void CompilationGraph::insertVertex(const IntrusiveRefCntPtr<Tool> V) {
+void CompilationGraph::insertNode(Tool* V) {
   if (!NodesMap.count(V->Name())) {
     Node N;
     N.OwningGraph = this;
@@ -82,13 +82,13 @@ void CompilationGraph::insertEdge(const std::string& A,
     ToolsMap[InputLanguage].push_back(B);
 
     // Needed to support iteration via GraphTraits.
-    NodesMap["root"].Children.push_back(B);
+    NodesMap["root"].AddEdge(new DefaultEdge(B));
   }
   else {
-    Node& NA = getNode(A);
+    Node& N = getNode(A);
     // Check that there is a node at B.
     getNode(B);
-    NA.Children.push_back(B);
+    N.AddEdge(new DefaultEdge(B));
   }
 }
 
@@ -123,7 +123,7 @@ int CompilationGraph::Build (const sys::Path& tempDir) const {
       }
 
       // Is this the last tool?
-      if (N->Children.empty() || CurTool->IsLast()) {
+      if (!N->HasChildren() || CurTool->IsLast()) {
         Out.appendComponent(In.getBasename());
         Out.appendSuffix(CurTool->OutputSuffix());
         Last = true;
@@ -139,7 +139,7 @@ int CompilationGraph::Build (const sys::Path& tempDir) const {
       if (CurTool->GenerateAction(In, Out).Execute() != 0)
         throw std::runtime_error("Tool returned error code!");
 
-      N = &getNode(*N->Children.begin());
+      N = &getNode((*N->EdgesBegin())->ToolName());
       In = Out; Out.clear();
     }
   }
diff --git a/tools/llvmc2/CompilationGraph.h b/tools/llvmc2/CompilationGraph.h
index f46b287..85210dc 100644
--- a/tools/llvmc2/CompilationGraph.h
+++ b/tools/llvmc2/CompilationGraph.h
@@ -18,6 +18,7 @@
 #include "Tool.h"
 
 #include "llvm/ADT/GraphTraits.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/iterator"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -27,45 +28,59 @@
 
 namespace llvmcc {
 
-  class CompilationGraph;
+  class Edge : public llvm::RefCountedBaseVPTR<Edge> {
+  public:
+    Edge(const std::string& T) : ToolName_(T) {}
+    virtual ~Edge() {};
+
+    const std::string& ToolName() const { return ToolName_; }
+    virtual bool isEnabled() const = 0;
+    virtual bool isDefault() const = 0;
+  private:
+    std::string ToolName_;
+  };
+
+  class DefaultEdge : public Edge {
+  public:
+    DefaultEdge(const std::string& T) : Edge(T) {}
+    bool isEnabled() const { return true;}
+    bool isDefault() const { return true;}
+  };
 
   struct Node {
-    typedef llvm::SmallVector<std::string, 3> sequence_type;
+    typedef llvm::SmallVector<llvm::IntrusiveRefCntPtr<Edge>, 3> container_type;
+    typedef container_type::iterator iterator;
+    typedef container_type::const_iterator const_iterator;
 
     Node() {}
     Node(CompilationGraph* G) : OwningGraph(G) {}
     Node(CompilationGraph* G, Tool* T) : OwningGraph(G), ToolPtr(T) {}
 
+    bool HasChildren() const { return OutEdges.empty(); }
+
+    iterator EdgesBegin() { return OutEdges.begin(); }
+    const_iterator EdgesBegin() const { return OutEdges.begin(); }
+    iterator EdgesEnd() { return OutEdges.end(); }
+    const_iterator EdgesEnd() const { return OutEdges.end(); }
+
+    // E is a new-allocated pointer.
+    void AddEdge(Edge* E)
+    { OutEdges.push_back(llvm::IntrusiveRefCntPtr<Edge>(E)); }
+
     // Needed to implement NodeChildIterator/GraphTraits
     CompilationGraph* OwningGraph;
     // The corresponding Tool.
     llvm::IntrusiveRefCntPtr<Tool> ToolPtr;
     // Links to children.
-    sequence_type Children;
+    container_type OutEdges;
   };
 
-  // This can be generalised to something like value_iterator for maps
-  class NodesIterator : public llvm::StringMap<Node>::iterator {
-    typedef llvm::StringMap<Node>::iterator super;
-    typedef NodesIterator ThisType;
-    typedef Node* pointer;
-    typedef Node& reference;
-
-  public:
-    NodesIterator(super I) : super(I) {}
-
-    inline reference operator*() const {
-      return super::operator->()->second;
-    }
-    inline pointer operator->() const {
-      return &super::operator->()->second;
-    }
-  };
+  class NodesIterator;
 
   class CompilationGraph {
-    typedef llvm::StringMap<Node> nodes_map_type;
     typedef llvm::SmallVector<std::string, 3> tools_vector_type;
     typedef llvm::StringMap<tools_vector_type> tools_map_type;
+    typedef llvm::StringMap<Node> nodes_map_type;
 
     // Map from file extensions to language names.
     LanguageMap ExtsToLangs;
@@ -79,7 +94,7 @@ namespace llvmcc {
     CompilationGraph();
 
     // insertVertex - insert a new node into the graph.
-    void insertVertex(const llvm::IntrusiveRefCntPtr<Tool> T);
+    void insertNode(Tool* T);
 
     // insertEdge - Insert a new edge into the graph. This function
     // assumes that both A and B have been already inserted.
@@ -90,87 +105,108 @@ namespace llvmcc {
     // variables.
     int Build(llvm::sys::Path const& tempDir) const;
 
-    /// viewGraph - This function is meant for use from the debugger.
-    /// You can just say 'call G->viewGraph()' and a ghostview window
-    /// should pop up from the program, displaying the compilation
-    /// graph. This depends on there being a 'dot' and 'gv' program
-    /// in your path.
+    // Return a reference to the node correponding to the given tool
+    // name. Throws std::runtime_error.
+    Node& getNode(const std::string& ToolName);
+    const Node& getNode(const std::string& ToolName) const;
+
+    // viewGraph - This function is meant for use from the debugger.
+    // You can just say 'call G->viewGraph()' and a ghostview window
+    // should pop up from the program, displaying the compilation
+    // graph. This depends on there being a 'dot' and 'gv' program
+    // in your path.
     void viewGraph();
 
-    /// Write a CompilationGraph.dot file.
+    // Write a CompilationGraph.dot file.
     void writeGraph();
 
     // GraphTraits support
+    friend NodesIterator GraphBegin(CompilationGraph*);
+    friend NodesIterator GraphEnd(CompilationGraph*);
+    friend void PopulateCompilationGraph(CompilationGraph&);
 
-    typedef NodesIterator nodes_iterator;
+  private:
+    // Helper functions.
 
-    nodes_iterator nodes_begin() {
-      return NodesIterator(NodesMap.begin());
-    }
+    // Find out which language corresponds to the suffix of this file.
+    const std::string& getLanguage(const llvm::sys::Path& File) const;
 
-    nodes_iterator nodes_end() {
-      return NodesIterator(NodesMap.end());
-    }
+    // Return a reference to the list of tool names corresponding to
+    // the given language name. Throws std::runtime_error.
+    const tools_vector_type& getToolsVector(const std::string& LangName) const;
+  };
 
-    // Return a reference to the node correponding to the given tool
-    // name. Throws std::runtime_error in case of error.
-    Node& getNode(const std::string& ToolName);
-    const Node& getNode(const std::string& ToolName) const;
+  /// GraphTraits support code.
 
-    // Auto-generated function.
-    friend void PopulateCompilationGraph(CompilationGraph&);
+  // Auxiliary class needed to implement GraphTraits support.  Can be
+  // generalised to something like value_iterator for map-like
+  // containers.
+  class NodesIterator : public llvm::StringMap<Node>::iterator {
+    typedef llvm::StringMap<Node>::iterator super;
+    typedef NodesIterator ThisType;
+    typedef Node* pointer;
+    typedef Node& reference;
 
-  private:
-    // Helper function - find out which language corresponds to the
-    // suffix of this file
-    const std::string& getLanguage(const llvm::sys::Path& File) const;
+  public:
+    NodesIterator(super I) : super(I) {}
 
-    // Return a reference to the tool names list correponding to the
-    // given language name. Throws std::runtime_error in case of
-    // error.
-    const tools_vector_type& getToolsVector(const std::string& LangName) const;
+    inline reference operator*() const {
+      return super::operator->()->second;
+    }
+    inline pointer operator->() const {
+      return &super::operator->()->second;
+    }
   };
 
-  // Auxiliary class needed to implement GraphTraits support.
+  inline NodesIterator GraphBegin(CompilationGraph* G) {
+    return NodesIterator(G->NodesMap.begin());
+  }
+
+  inline NodesIterator GraphEnd(CompilationGraph* G) {
+    return NodesIterator(G->NodesMap.end());
+  }
+
+
+  // Another auxiliary class needed by GraphTraits.
   class NodeChildIterator : public bidirectional_iterator<Node, ptrdiff_t> {
     typedef NodeChildIterator ThisType;
-    typedef Node::sequence_type::iterator iterator;
+    typedef Node::container_type::iterator iterator;
 
     CompilationGraph* OwningGraph;
-    iterator KeyIter;
+    iterator EdgeIter;
   public:
     typedef Node* pointer;
     typedef Node& reference;
 
     NodeChildIterator(Node* N, iterator I) :
-      OwningGraph(N->OwningGraph), KeyIter(I) {}
+      OwningGraph(N->OwningGraph), EdgeIter(I) {}
 
     const ThisType& operator=(const ThisType& I) {
       assert(OwningGraph == I.OwningGraph);
-      KeyIter = I.KeyIter;
+      EdgeIter = I.EdgeIter;
       return *this;
     }
 
     inline bool operator==(const ThisType& I) const
-    { return KeyIter == I.KeyIter; }
+    { return EdgeIter == I.EdgeIter; }
     inline bool operator!=(const ThisType& I) const
-    { return KeyIter != I.KeyIter; }
+    { return EdgeIter != I.EdgeIter; }
 
     inline pointer operator*() const {
-      return &OwningGraph->getNode(*KeyIter);
+      return &OwningGraph->getNode((*EdgeIter)->ToolName());
     }
     inline pointer operator->() const {
-      return &OwningGraph->getNode(*KeyIter);
+      return &OwningGraph->getNode((*EdgeIter)->ToolName());
     }
 
-    ThisType& operator++() { ++KeyIter; return *this; } // Preincrement
+    ThisType& operator++() { ++EdgeIter; return *this; } // Preincrement
     ThisType operator++(int) { // Postincrement
       ThisType tmp = *this;
       ++*this;
       return tmp;
     }
 
-    inline ThisType& operator--() { --KeyIter; return *this; }  // Predecrement
+    inline ThisType& operator--() { --EdgeIter; return *this; }  // Predecrement
     inline ThisType operator--(int) { // Postdecrement
       ThisType tmp = *this;
       --*this;
@@ -192,18 +228,18 @@ namespace llvm {
     }
 
     static ChildIteratorType child_begin(NodeType* N) {
-      return ChildIteratorType(N, N->Children.begin());
+      return ChildIteratorType(N, N->OutEdges.begin());
     }
     static ChildIteratorType child_end(NodeType* N) {
-      return ChildIteratorType(N, N->Children.end());
+      return ChildIteratorType(N, N->OutEdges.end());
     }
 
-    typedef GraphType::nodes_iterator nodes_iterator;
+    typedef llvmcc::NodesIterator nodes_iterator;
     static nodes_iterator nodes_begin(GraphType *G) {
-      return G->nodes_begin();
+      return GraphBegin(G);
     }
     static nodes_iterator nodes_end(GraphType *G) {
-      return G->nodes_end();
+      return GraphEnd(G);
     }
   };
 
diff --git a/tools/llvmc2/Tools.td b/tools/llvmc2/Tools.td
index f69c290..4b84aef 100644
--- a/tools/llvmc2/Tools.td
+++ b/tools/llvmc2/Tools.td
@@ -21,7 +21,7 @@
 
 def llvm_gcc_c : Tool<
 [(in_language "c"),
- (out_language "llvm-assembler"),
+ (out_language "llvm-bitcode"),
  (output_suffix "bc"),
  (cmd_line "llvm-gcc -c $INFILE -o $OUTFILE -emit-llvm"),
  (sink)
@@ -29,7 +29,7 @@ def llvm_gcc_c : Tool<
 
 def llvm_gcc_cpp : Tool<
 [(in_language "c++"),
- (out_language "llvm-assembler"),
+ (out_language "llvm-bitcode"),
  (output_suffix "bc"),
  (cmd_line "llvm-g++ -c $INFILE -o $OUTFILE -emit-llvm"),
  (sink)