tools/llvmc2/CompilationGraph.cpp

   1 //===--- CompilationGraph.cpp - The LLVM Compiler Driver --------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open
   6 // Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  Compilation graph - implementation.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CompilationGraph.h"
  15
  16 #include "llvm/Support/CommandLine.h"
  17 #include "llvm/Support/DOTGraphTraits.h"
  18 #include "llvm/Support/GraphWriter.h"
  19
  20 #include <stdexcept>
  21
  22 using namespace llvm;
  23 using namespace llvmcc;
  24
  25 extern cl::list<std::string> InputFilenames;
  26 extern cl::opt<std::string> OutputFilename;
  27
  28 // Choose one of the edges based on command-line options.
  29 const Edge* Node::ChooseEdge() const {
  30   const Edge* DefaultEdge = 0;
  31   for (const_iterator B = EdgesBegin(), E = EdgesEnd();
  32        B != E; ++B) {
  33     const Edge* E = (*B).getPtr();
  34     if (E->isDefault())
  35       if (!DefaultEdge)
  36         DefaultEdge = E;
  37       else
  38         throw std::runtime_error("Node " + Name() +
  39                                  ": multiple default edges found!"
  40                                  "Most probably a specification error.");
  41     if (E->isEnabled())
  42       return E;
  43   }
  44
  45   if (DefaultEdge)
  46     return DefaultEdge;
  47   else
  48     throw std::runtime_error("Node " + Name() +
  49                              ": no suitable edge found! "
  50                              "Most probably a specification error.");
  51 }
  52
  53 CompilationGraph::CompilationGraph() {
  54   NodesMap["root"] = Node(this);
  55 }
  56
  57 Node& CompilationGraph::getNode(const std::string& ToolName) {
  58   nodes_map_type::iterator I = NodesMap.find(ToolName);
  59   if (I == NodesMap.end())
  60     throw std::runtime_error("Node " + ToolName + " is not in the graph");
  61   return I->second;
  62 }
  63
  64 const Node& CompilationGraph::getNode(const std::string& ToolName) const {
  65   nodes_map_type::const_iterator I = NodesMap.find(ToolName);
  66   if (I == NodesMap.end())
  67     throw std::runtime_error("Node " + ToolName + " is not in the graph!");
  68   return I->second;
  69 }
  70
  71 const std::string& CompilationGraph::getLanguage(const sys::Path& File) const {
  72   LanguageMap::const_iterator Lang = ExtsToLangs.find(File.getSuffix());
  73   if (Lang == ExtsToLangs.end())
  74     throw std::runtime_error("Unknown suffix: " + File.getSuffix() + '!');
  75   return Lang->second;
  76 }
  77
  78 const CompilationGraph::tools_vector_type&
  79 CompilationGraph::getToolsVector(const std::string& LangName) const
  80 {
  81   tools_map_type::const_iterator I = ToolsMap.find(LangName);
  82   if (I == ToolsMap.end())
  83     throw std::runtime_error("No tools corresponding to " + LangName
  84                              + " found!");
  85   return I->second;
  86 }
  87
  88 void CompilationGraph::insertNode(Tool* V) {
  89   if (!NodesMap.count(V->Name())) {
  90     Node N;
  91     N.OwningGraph = this;
  92     N.ToolPtr = V;
  93     NodesMap[V->Name()] = N;
  94   }
  95 }
  96
  97 void CompilationGraph::insertEdge(const std::string& A, Edge* E) {
  98   if (A == "root") {
  99     const Node& N = getNode(E->ToolName());
 100     const std::string& InputLanguage = N.ToolPtr->InputLanguage();
 101     ToolsMap[InputLanguage].push_back(E->ToolName());
 102
 103     // Needed to support iteration via GraphTraits.
 104     NodesMap["root"].AddEdge(E);
 105   }
 106   else {
 107     Node& N = getNode(A);
 108     N.AddEdge(E);
 109   }
 110 }
 111
 112 // Pass input file through the chain until we bump into a Join node or
 113 // a node that says that it is the last.
 114 const Tool* CompilationGraph::PassThroughGraph (sys::Path& In,
 115                                                 sys::Path Out,
 116                                                 const sys::Path& TempDir,
 117                                                 PathVector& JoinList) const {
 118   bool Last = false;
 119   const Tool* ret = 0;
 120
 121   // Get to the head of the toolchain.
 122   const tools_vector_type& TV = getToolsVector(getLanguage(In));
 123   if (TV.empty())
 124     throw std::runtime_error("Tool names vector is empty!");
 125   const Node* N = &getNode(*TV.begin());
 126
 127   while(!Last) {
 128     const Tool* CurTool = N->ToolPtr.getPtr();
 129
 130     if (CurTool->IsJoin()) {
 131       JoinList.push_back(In);
 132       ret = CurTool;
 133       break;
 134     }
 135
 136     // Is this the last tool?
 137     if (!N->HasChildren() || CurTool->IsLast()) {
 138       // Check if the first tool is also the last
 139       if (Out.empty())
 140         Out.set(In.getBasename());
 141       else
 142         Out.appendComponent(In.getBasename());
 143       Out.appendSuffix(CurTool->OutputSuffix());
 144       Last = true;
 145     }
 146     else {
 147       Out = TempDir;
 148       Out.appendComponent(In.getBasename());
 149       Out.appendSuffix(CurTool->OutputSuffix());
 150       Out.makeUnique(true, NULL);
 151       Out.eraseFromDisk();
 152     }
 153
 154     if (CurTool->GenerateAction(In, Out).Execute() != 0)
 155       throw std::runtime_error("Tool returned error code!");
 156
 157     N = &getNode(N->ChooseEdge()->ToolName());
 158     In = Out; Out.clear();
 159   }
 160
 161   return ret;
 162 }
 163
 164 // TOFIX: support more interesting graph topologies. We will need to
 165 // do topological sorting to process multiple Join nodes correctly.
 166 int CompilationGraph::Build (const sys::Path& TempDir) const {
 167   PathVector JoinList;
 168   const Tool* JoinTool = 0;
 169   sys::Path In, Out;
 170
 171   // For each input file
 172   for (cl::list<std::string>::const_iterator B = InputFilenames.begin(),
 173         E = InputFilenames.end(); B != E; ++B) {
 174     In = sys::Path(*B);
 175
 176     const Tool* NewJoin = PassThroughGraph(In, Out, TempDir, JoinList);
 177     if (JoinTool && NewJoin && JoinTool != NewJoin)
 178       throw std::runtime_error("Graphs with multiple Join nodes"
 179                                "are not yet supported!");
 180     else if (NewJoin)
 181       JoinTool = NewJoin;
 182   }
 183
 184   if (JoinTool) {
 185     // If the final output name is empty, set it to "a.out"
 186     if (!OutputFilename.empty()) {
 187       Out = sys::Path(OutputFilename);
 188     }
 189     else {
 190       Out = sys::Path("a");
 191       Out.appendSuffix(JoinTool->OutputSuffix());
 192     }
 193
 194     if (JoinTool->GenerateAction(JoinList, Out).Execute() != 0)
 195       throw std::runtime_error("Tool returned error code!");
 196   }
 197
 198   return 0;
 199 }
 200
 201 namespace llvm {
 202   template <>
 203   struct DOTGraphTraits<llvmcc::CompilationGraph*>
 204     : public DefaultDOTGraphTraits
 205   {
 206
 207   template<typename GraphType>
 208   static std::string getNodeLabel(const Node* N, const GraphType&) {
 209     if (N->ToolPtr)
 210       return N->Name();
 211     else
 212       return "root";
 213   }
 214
 215   };
 216 }
 217
 218 void CompilationGraph::writeGraph() {
 219   std::ofstream O("CompilationGraph.dot");
 220
 221   if (O.good()) {
 222     llvm::WriteGraph(this, "CompilationGraph");
 223     O.close();
 224   }
 225   else {
 226     throw std::runtime_error("");
 227   }
 228 }
 229
 230 void CompilationGraph::viewGraph() {
 231   llvm::ViewGraph(this, "compilation-graph");
 232 }