llvm.org GIT mirror llvm / 4561ab5
Use Doxygen-style comments. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50833 91177308-0d34-0410-b5e6-96231b3b80d8 Mikhail Glushenkov 11 years ago
8 changed file(s) with 146 addition(s) and 111 deletion(s). Raw diff Collapse all Expand all
2020
2121 typedef std::vector StringVector;
2222
23 /// Action - A class that encapsulates a single shell command.
2324 class Action {
25 /// Command_ - The actual command (for example, 'ls').
2426 std::string Command_;
27 /// Args_ - Command arguments. Stdout redirection is allowed.
2528 std::vector Args_;
2629 public:
2730 Action (const std::string& C,
2932 : Command_(C), Args_(A)
3033 {}
3134
35 /// Execute - Executes the represented action.
3236 int Execute() const;
3337 };
3438
2222 typedef llvm::StringMap LanguageMap;
2323 class CompilationGraph;
2424
25 /// PopulateLanguageMap - The auto-generated function that fills in
26 /// the language map (map from file extensions to language names).
2527 void PopulateLanguageMap(LanguageMap& language_map);
28 /// PopulateCompilationGraph - The auto-generated function that
29 /// populates the compilation graph with nodes and edges.
2630 void PopulateCompilationGraph(CompilationGraph& tools);
2731 }
2832
3232
3333 namespace {
3434
35 // Return the edge with the maximum weight.
35 /// ChooseEdge - Return the edge with the maximum weight.
3636 template
3737 const Edge* ChooseEdge(const C& EdgesContainer,
3838 const InputLanguagesSet& InLangs,
303303 std::back_inserter(Out), NotJoinNode);
304304 }
305305
306 // Build the targets. Command-line options are accessed through global
307 // variables.
308306 int CompilationGraph::Build (const sys::Path& TempDir) {
309307
310308 InputLanguagesSet InLangs;
2828
2929 namespace llvmc {
3030
31 // A wrapper for StringMap that provides set-like functionality.
32 // Only insert() and count() methods are used by my code.
31 /// StringSet - A wrapper for StringMap that provides set-like
32 /// functionality. Only insert() and count() methods are used by my
33 /// code.
3334 template
3435 class StringSet : public llvm::StringMap {
3536 typedef llvm::StringMap base;
4445 };
4546 typedef StringSet<> InputLanguagesSet;
4647
47 // An edge of the compilation graph.
48 /// Edge - Represents an edge of the compilation graph.
4849 class Edge : public llvm::RefCountedBaseVPTR {
4950 public:
5051 Edge(const std::string& T) : ToolName_(T) {}
5657 std::string ToolName_;
5758 };
5859
59 // Edges that have no properties are instances of this class.
60 /// SimpleEdge - An edge that has no properties.
6061 class SimpleEdge : public Edge {
6162 public:
6263 SimpleEdge(const std::string& T) : Edge(T) {}
6364 unsigned Weight(const InputLanguagesSet&) const { return 1; }
6465 };
6566
66 // A node of the compilation graph.
67 /// Node - A node (vertex) of the compilation graph.
6768 struct Node {
6869 // A Node holds a list of the outward edges.
6970 typedef llvm::SmallVector, 3> container_type;
8586 iterator EdgesEnd() { return OutEdges.end(); }
8687 const_iterator EdgesEnd() const { return OutEdges.end(); }
8788
88 // Add an outward edge. Takes ownership of the Edge object.
89 /// AddEdge - Add an outward edge. Takes ownership of the provided
90 /// Edge object.
8991 void AddEdge(Edge* E)
9092 { OutEdges.push_back(llvm::IntrusiveRefCntPtr(E)); }
9193
110112
111113 class NodesIterator;
112114
113 // The compilation graph itself.
115 /// CompilationGraph - The compilation graph itself.
114116 class CompilationGraph {
115 // Main data structure.
117 /// nodes_map_type - The main data structure.
116118 typedef llvm::StringMap nodes_map_type;
117 // These are used to map from language names to tools. (We can
118 // have several tools associated with each language name, hence
119 // the need for a vector of Edges.)
119 /// tools_vector_type, tools_map_type - Data structures used to
120 /// map from language names to tools. (We can have several tools
121 /// associated with each language name, hence the need for a
122 /// vector.)
120123 typedef
121124 llvm::SmallVector, 3> tools_vector_type;
122125 typedef llvm::StringMap tools_map_type;
123126
124 // Map from file extensions to language names.
127 /// ExtsToLangs - Map from file extensions to language names.
125128 LanguageMap ExtsToLangs;
126 // Map from language names to lists of tool names.
129 /// ToolsMap - Map from language names to lists of tool names.
127130 tools_map_type ToolsMap;
128 // Map from tool names to Tool objects.
131 /// NodesMap - Map from tool names to Tool objects.
129132 nodes_map_type NodesMap;
130133
131134 public:
132135
133136 CompilationGraph();
134137
135 // insertVertex - insert a new node into the graph. Takes
136 // ownership of the object.
138 /// insertNode - Insert a new node into the graph. Takes
139 /// ownership of the object.
137140 void insertNode(Tool* T);
138141
139 // insertEdge - Insert a new edge into the graph. Takes ownership
140 // of the Edge object.
142 /// insertEdge - Insert a new edge into the graph. Takes ownership
143 /// of the Edge object.
141144 void insertEdge(const std::string& A, Edge* E);
142145
143 // Build - Build target(s) from the input file set. Command-line
144 // options are passed implicitly as global variables.
146 /// Build - Build target(s) from the input file set. Command-line
147 /// options are passed implicitly as global variables.
145148 int Build(llvm::sys::Path const& tempDir);
146149
147 // Return a reference to the node correponding to the given tool
148 // name. Throws std::runtime_error.
150 /// getNode -Return a reference to the node correponding to the
151 /// given tool name. Throws std::runtime_error.
149152 Node& getNode(const std::string& ToolName);
150153 const Node& getNode(const std::string& ToolName) const;
151154
152 // viewGraph - This function is meant for use from the debugger.
153 // You can just say 'call G->viewGraph()' and a ghostview window
154 // should pop up from the program, displaying the compilation
155 // graph. This depends on there being a 'dot' and 'gv' program
156 // in your path.
155 /// viewGraph - This function is meant for use from the debugger.
156 /// You can just say 'call G->viewGraph()' and a ghostview window
157 /// should pop up from the program, displaying the compilation
158 /// graph. This depends on there being a 'dot' and 'gv' program
159 /// in your path.
157160 void viewGraph();
158161
159 // Write a CompilationGraph.dot file.
162 /// writeGraph - Write a compilation-graph.dot file.
160163 void writeGraph();
161164
162 // GraphTraits support
165 // GraphTraits support.
163166 friend NodesIterator GraphBegin(CompilationGraph*);
164167 friend NodesIterator GraphEnd(CompilationGraph*);
165168 friend void PopulateCompilationGraph(CompilationGraph&);
167170 private:
168171 // Helper functions.
169172
170 // Find out which language corresponds to the suffix of this file.
173 /// getLanguage - Find out which language corresponds to the
174 /// suffix of this file.
171175 const std::string& getLanguage(const llvm::sys::Path& File) const;
172176
173 // Return a reference to the list of tool names corresponding to
174 // the given language name. Throws std::runtime_error.
177 /// getToolsVector - Return a reference to the list of tool names
178 /// corresponding to the given language name. Throws
179 /// std::runtime_error.
175180 const tools_vector_type& getToolsVector(const std::string& LangName) const;
176181
177 // Pass the input file through the toolchain starting at StartNode.
182 /// PassThroughGraph - Pass the input file through the toolchain
183 /// starting at StartNode.
178184 void PassThroughGraph (const llvm::sys::Path& In, const Node* StartNode,
179185 const InputLanguagesSet& InLangs,
180186 const llvm::sys::Path& TempDir) const;
181187
182 // Find head of the toolchain corresponding to the given file.
188 /// FindToolChain - Find head of the toolchain corresponding to the given file.
183189 const Node* FindToolChain(const llvm::sys::Path& In,
184190 const std::string* forceLanguage,
185191 InputLanguagesSet& InLangs) const;
186192
187 // Traverse the initial parts of the toolchains.
193 /// BuildInitial - Traverse the initial parts of the toolchains.
188194 void BuildInitial(InputLanguagesSet& InLangs,
189195 const llvm::sys::Path& TempDir);
190196
191 // Sort the nodes in topological order.
197 /// TopologicalSort - Sort the nodes in topological order.
192198 void TopologicalSort(std::vector& Out);
193 // Call TopologicalSort and filter the resulting list to include
194 // only Join nodes.
199 /// TopologicalSortFilterJoinNodes - Call TopologicalSort and
200 /// filter the resulting list to include only Join nodes.
195201 void TopologicalSortFilterJoinNodes(std::vector& Out);
196202 };
197203
198 /// GraphTraits support code.
199
200 // Auxiliary class needed to implement GraphTraits support. Can be
201 // generalised to something like value_iterator for map-like
202 // containers.
204 // GraphTraits support code.
205
206 /// NodesIterator - Auxiliary class needed to implement GraphTraits
207 /// support. Can be generalised to something like value_iterator
208 /// for map-like containers.
203209 class NodesIterator : public llvm::StringMap::iterator {
204210 typedef llvm::StringMap::iterator super;
205211 typedef NodesIterator ThisType;
226232 }
227233
228234
229 // Another auxiliary class needed by GraphTraits.
235 /// NodeChildIterator - Another auxiliary class needed by GraphTraits.
230236 class NodeChildIterator : public bidirectional_iterator {
231237 typedef NodeChildIterator ThisType;
232238 typedef Node::container_type::iterator iterator;
2525
2626 typedef std::vector PathVector;
2727
28 /// Tool - A class
2829 class Tool : public llvm::RefCountedBaseVPTR {
2930 public:
3031
4546 virtual bool IsJoin() const = 0;
4647 };
4748
48 // Join tools have an input file list associated with them.
49 /// JoinTool - A Tool that has an associated input file list.
4950 class JoinTool : public Tool {
5051 public:
5152 void AddToJoinList(const llvm::sys::Path& P) { JoinList_.push_back(P); }
4747 cl::Hidden);
4848
4949 namespace {
50 /// BuildTargets - A small wrapper for CompilationGraph::Build.
5051 int BuildTargets(CompilationGraph& graph) {
5152 int ret;
5253 sys::Path tempDir(sys::Path::GetTemporaryDirectory());
3737 //===----------------------------------------------------------------------===//
3838 /// Constants
3939
40 // Indentation strings
40 // Indentation strings.
4141 const char * Indent1 = " ";
4242 const char * Indent2 = " ";
4343 const char * Indent3 = " ";
4444 const char * Indent4 = " ";
4545
46 // Default help string
46 // Default help string.
4747 const char * DefaultHelpString = "NO HELP MESSAGE PROVIDED";
4848
49 // Name for the "sink" option
49 // Name for the "sink" option.
5050 const char * SinkOptionName = "AutoGeneratedSinkOption";
5151
5252 //===----------------------------------------------------------------------===//
6868 }
6969
7070
71 // Ensure that the number of args in d is <= min_arguments,
72 // throw exception otherwise
71 // checkNumberOfArguments - Ensure that the number of args in d is
72 // less than or equal to min_arguments, otherwise throw an exception .
7373 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
7474 if (d->getNumArgs() < min_arguments)
7575 throw "Property " + d->getOperator()->getAsString()
110110 // the option registration code, while ToolOptionDescriptions are used
111111 // to generate tool-specific code.
112112
113 // Base class for option descriptions
114
113 /// OptionDescription - Base class for option descriptions.
115114 struct OptionDescription {
116115 OptionType::OptionType Type;
117116 std::string Name;
153152
154153 };
155154
156 // Global option description
155 // Global option description.
157156
158157 namespace GlobalOptionDescriptionFlags {
159158 enum GlobalOptionDescriptionFlags { Required = 0x1 };
179178 Flags |= GlobalOptionDescriptionFlags::Required;
180179 }
181180
182 // Merge two option descriptions
181 /// Merge - Merge two option descriptions.
183182 void Merge (const GlobalOptionDescription& other)
184183 {
185184 if (other.Type != Type)
196195 }
197196 };
198197
199 // A GlobalOptionDescription array
200 // + some flags affecting generation of option declarations
198 /// GlobalOptionDescriptions - A GlobalOptionDescription array
199 /// together with some flags affecting generation of option
200 /// declarations.
201201 struct GlobalOptionDescriptions {
202202 typedef StringMap container_type;
203203 typedef container_type::const_iterator const_iterator;
204204
205 // A list of GlobalOptionDescriptions
205 /// Descriptions - A list of GlobalOptionDescriptions.
206206 container_type Descriptions;
207 // Should the emitter generate a "cl::sink" option?
207 /// HasSink - Should the emitter generate a "cl::sink" option?
208208 bool HasSink;
209209
210210 const GlobalOptionDescription& FindOption(const std::string& OptName) const {
306306 };
307307
308308
309 // A list of Tool information records
310 // IntrusiveRefCntPtrs are used because StringMap has no copy constructor
311 // (and we want to avoid copying ToolProperties anyway)
309 /// ToolPropertiesList - A list of Tool information records
310 /// IntrusiveRefCntPtrs are used here because StringMap has no copy
311 /// constructor (and we want to avoid copying ToolProperties anyway).
312312 typedef std::vector > ToolPropertiesList;
313313
314314
315 // Function object for iterating over a list of tool property records
315 /// CollectProperties - Function object for iterating over a list of
316 /// tool property records
316317 class CollectProperties {
317318 private:
318319
319320 /// Implementation details
320321
321 // "Property handler" - a function that extracts information
322 // about a given tool property from its DAG representation
322 /// PropertyHandler - a function that extracts information
323 /// about a given tool property from its DAG representation
323324 typedef void (CollectProperties::*PropertyHandler)(const DagInit*);
324325
325 // Map from property names -> property handlers
326 /// PropertyHandlerMap - A map from property names to property
327 /// handlers.
326328 typedef StringMap PropertyHandlerMap;
327329
328 // "Option property handler" - a function that extracts information
329 // about a given option property from its DAG representation
330 /// OptionPropertyHandler - a function that extracts information
331 /// about a given option property from its DAG representation.
330332 typedef void (CollectProperties::* OptionPropertyHandler)
331333 (const DagInit*, GlobalOptionDescription &);
332334
333 // Map from option property names -> option property handlers
335 /// OptionPropertyHandlerMap - A map from option property names to
336 /// option property handlers
334337 typedef StringMap OptionPropertyHandlerMap;
335338
336339 // Static maps from strings to CollectProperties methods("handlers")
341344
342345 /// This is where the information is stored
343346
344 // Current Tool properties
347 /// toolProps_ - Properties of the current Tool.
345348 ToolProperties& toolProps_;
346 // OptionDescriptions table(used to register options globally)
349 /// optDescs_ - OptionDescriptions table (used to register options
350 /// globally).
347351 GlobalOptionDescriptions& optDescs_;
348352
349353 public:
382386 }
383387 }
384388
385 // Gets called for every tool property;
386 // Just forwards to the corresponding property handler.
389 /// operator() - Gets called for every tool property; Just forwards
390 /// to the corresponding property handler.
387391 void operator() (Init* i) {
388392 const DagInit& d = InitPtrToDagInitRef(i);
389393 const std::string& property_name = d.getOperator()->getAsString();
524528 }
525529 }
526530
527 // Go through the list of option properties and call a corresponding
528 // handler for each.
529 //
530 // Parameters:
531 // name - option name
532 // d - option property list
531 /// processOptionProperties - Go through the list of option
532 /// properties and call a corresponding handler for each.
533 ///
534 /// Parameters:
535 /// name - option name
536 /// d - option property list
533537 void processOptionProperties (const DagInit* d, GlobalOptionDescription& o) {
534538 // First argument is option name
535539 checkNumberOfArguments(d, 2);
563567 bool CollectProperties::staticMembersInitialized_ = false;
564568
565569
566 // Gather information from the parsed TableGen data
567 // (Basically a wrapper for CollectProperties)
570 /// CollectToolProperties - Gather information from the parsed
571 /// TableGen data (basically a wrapper for CollectProperties).
568572 void CollectToolProperties (RecordVector::const_iterator B,
569573 RecordVector::const_iterator E,
570574 ToolPropertiesList& TPList,
584588 }
585589 }
586590
587 // Used by EmitGenerateActionMethod
591 /// EmitOptionPropertyHandlingCode - Used by EmitGenerateActionMethod.
588592 void EmitOptionPropertyHandlingCode (const ToolProperties& P,
589593 const ToolOptionDescription& D,
590594 std::ostream& O)
672676 O << Indent2 << "}\n";
673677 }
674678
675 // Emite one of two versions of GenerateAction method
679 // EmitGenerateActionMethod - Emit one of two versions of
680 // GenerateAction method.
676681 void EmitGenerateActionMethod (const ToolProperties& P, int V, std::ostream& O)
677682 {
678683 assert(V==1 || V==2);
730735 << Indent1 << "}\n\n";
731736 }
732737
733 // Emit GenerateAction methods for Tool classes
738 /// EmitGenerateActionMethods - Emit two GenerateAction methods for a given
739 /// Tool class.
734740 void EmitGenerateActionMethods (const ToolProperties& P, std::ostream& O) {
735741
736742 if (!P.isJoin())
746752 EmitGenerateActionMethod(P, 2, O);
747753 }
748754
749 // Emit IsLast() method for Tool classes
755 /// EmitIsLastMethod - Emit IsLast() method for a given Tool class
750756 void EmitIsLastMethod (const ToolProperties& P, std::ostream& O) {
751757 O << Indent1 << "bool IsLast() const {\n"
752758 << Indent2 << "bool last = false;\n";
765771 << Indent1 << "}\n\n";
766772 }
767773
768 // Emit static [Input,Output]Language() methods for Tool classes
774 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
775 /// methods for a given Tool class.
769776 void EmitInOutLanguageMethods (const ToolProperties& P, std::ostream& O) {
770777 O << Indent1 << "const char* InputLanguage() const {\n"
771778 << Indent2 << "return \"" << P.InLanguage << "\";\n"
776783 << Indent1 << "}\n\n";
777784 }
778785
779 // Emit static [Input,Output]Language() methods for Tool classes
786 /// EmitOutputSuffixMethod - Emit the OutputSuffix() method for a
787 /// given Tool class.
780788 void EmitOutputSuffixMethod (const ToolProperties& P, std::ostream& O) {
781789 O << Indent1 << "const char* OutputSuffix() const {\n"
782790 << Indent2 << "return \"" << P.OutputSuffix << "\";\n"
783791 << Indent1 << "}\n\n";
784792 }
785793
786 // Emit static Name() method for Tool classes
794 /// EmitNameMethod - Emit the Name() method for a given Tool class.
787795 void EmitNameMethod (const ToolProperties& P, std::ostream& O) {
788796 O << Indent1 << "const char* Name() const {\n"
789797 << Indent2 << "return \"" << P.Name << "\";\n"
790798 << Indent1 << "}\n\n";
791799 }
792800
793 // Emit static Name() method for Tool classes
801 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
802 /// class.
794803 void EmitIsJoinMethod (const ToolProperties& P, std::ostream& O) {
795804 O << Indent1 << "bool IsJoin() const {\n";
796805 if (P.isJoin())
800809 O << Indent1 << "}\n\n";
801810 }
802811
803 // Emit a Tool class definition
812 /// EmitToolClassDefinition - Emit a Tool class definition.
804813 void EmitToolClassDefinition (const ToolProperties& P, std::ostream& O) {
805814
806815 if(P.Name == "root")
825834 O << "};\n\n";
826835 }
827836
828 // Iterate over a list of option descriptions and emit registration code
837 /// EmitOptionDescriptions - Iterate over a list of option
838 /// descriptions and emit registration code.
829839 void EmitOptionDescriptions (const GlobalOptionDescriptions& descs,
830840 std::ostream& O)
831841 {
861871 O << '\n';
862872 }
863873
874 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMap() function.
864875 void EmitPopulateLanguageMap (const RecordKeeper& Records, std::ostream& O)
865876 {
866877 // Get the relevant field out of RecordKeeper
890901 O << "}\n\n";
891902 }
892903
893 // Fills in two tables that map tool names to (input, output) languages.
894 // Used by the typechecker.
904 /// FillInToolToLang - Fills in two tables that map tool names to
905 /// (input, output) languages. Used by the typechecker.
895906 void FillInToolToLang (const ToolPropertiesList& TPList,
896907 StringMap& ToolToInLang,
897908 StringMap& ToolToOutLang) {
903914 }
904915 }
905916
906 // Check that all output and input language names match.
917 /// TypecheckGraph - Check that names for output and input languages
918 /// on all edges do match.
907919 // TOFIX: check for cycles.
908920 // TOFIX: check for multiple default edges.
909921 void TypecheckGraph (Record* CompilationGraph,
934946 }
935947 }
936948
937 // Helper function used by EmitEdgePropertyTest.
949 /// EmitEdgePropertyTest1Arg - Helper function used by
950 /// EmitEdgePropertyTest.
938951 bool EmitEdgePropertyTest1Arg(const std::string& PropName,
939952 const DagInit& Prop,
940953 const GlobalOptionDescriptions& OptDescs,
955968 return false;
956969 }
957970
958 // Helper function used by EmitEdgePropertyTest.
971 /// EmitEdgePropertyTest2Args - Helper function used by
972 /// EmitEdgePropertyTest.
959973 bool EmitEdgePropertyTest2Args(const std::string& PropName,
960974 const DagInit& Prop,
961975 const GlobalOptionDescriptions& OptDescs,
9911005 const GlobalOptionDescriptions& OptDescs,
9921006 std::ostream& O);
9931007
994 // Helper function used by EmitEdgeClass.
1008 /// EmitLogicalOperationTest - Helper function used by
1009 /// EmitEdgePropertyTest.
9951010 void EmitLogicalOperationTest(const DagInit& Prop, const char* LogicOp,
9961011 const GlobalOptionDescriptions& OptDescs,
9971012 std::ostream& O) {
10061021 }
10071022 }
10081023
1009 // Helper function used by EmitEdgeClass.
1024 /// EmitEdgePropertyTest - Helper function used by EmitEdgeClass.
10101025 void EmitEdgePropertyTest(const DagInit& Prop,
10111026 const GlobalOptionDescriptions& OptDescs,
10121027 std::ostream& O) {
10241039 throw PropName + ": unknown edge property!";
10251040 }
10261041
1027 // Emit a single Edge* class.
1042 /// EmitEdgeClass - Emit a single Edge# class.
10281043 void EmitEdgeClass(unsigned N, const std::string& Target,
10291044 ListInit* Props, const GlobalOptionDescriptions& OptDescs,
10301045 std::ostream& O) {
10821097 }
10831098 }
10841099
1100 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraph()
1101 /// function.
10851102 void EmitPopulateCompilationGraph (Record* CompilationGraph,
10861103 std::ostream& O)
10871104 {
11301147 // End of anonymous namespace
11311148 }
11321149
1133 // Back-end entry point
1150 /// run - The back-end entry point.
11341151 void LLVMCConfigurationEmitter::run (std::ostream &O) {
1135 // Emit file header
1152
1153 // Emit file header.
11361154 EmitSourceFileHeader("LLVMC Configuration Library", O);
11371155
1138 // Get a list of all defined Tools
1156 // Get a list of all defined Tools.
11391157 RecordVector Tools = Records.getAllDerivedDefinitions("Tool");
11401158 if (Tools.empty())
11411159 throw std::string("No tool definitions found!");
11421160
1143 // Gather information from the Tool descriptions
1161 // Gather information from the Tool description dags.
11441162 ToolPropertiesList tool_props;
11451163 GlobalOptionDescriptions opt_descs;
11461164 CollectToolProperties(Tools.begin(), Tools.end(), tool_props, opt_descs);
11471165
1148 // Emit global option registration code
1166 // Emit global option registration code.
11491167 EmitOptionDescriptions(opt_descs, O);
11501168
1151 // Emit PopulateLanguageMap function
1152 // (a language map maps from file extensions to language names)
1169 // Emit PopulateLanguageMap() function
1170 // (a language map maps from file extensions to language names).
11531171 EmitPopulateLanguageMap(Records, O);
11541172
1155 // Emit Tool classes
1173 // Emit Tool classes.
11561174 for (ToolPropertiesList::const_iterator B = tool_props.begin(),
11571175 E = tool_props.end(); B!=E; ++B)
11581176 EmitToolClassDefinition(*(*B), O);
11641182 // Typecheck the compilation graph.
11651183 TypecheckGraph(CompilationGraphRecord, tool_props);
11661184
1167 // Emit Edge* classes.
1185 // Emit Edge# classes.
11681186 EmitEdgeClasses(CompilationGraphRecord, opt_descs, O);
11691187
1170 // Emit PopulateCompilationGraph function
1188 // Emit PopulateCompilationGraph() function.
11711189 EmitPopulateCompilationGraph(CompilationGraphRecord, O);
11721190
11731191 // EOF
1616 #include "TableGenBackend.h"
1717
1818 namespace llvm {
19
20 /// LLVMCConfigurationEmitter - TableGen backend that generates
21 /// configuration code for LLVMC.
1922 class LLVMCConfigurationEmitter : public TableGenBackend {
2023 RecordKeeper &Records;
2124 public: