1 //===-- Support/ToolRunner.h ------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file exposes an abstraction around a platform C compiler, used to
11 // compile C and assembly code. It also exposes an "AbstractIntepreter"
12 // interface, which is used to execute code using one of the LLVM execution
15 //===----------------------------------------------------------------------===//
20 #include "Support/SystemUtils.h"
30 /// ToolExecutionError - An instance of this class is thrown by the
31 /// AbstractInterpreter instances if there is an error running a tool (e.g., LLC
32 /// crashes) which prevents execution of the program.
34 class ToolExecutionError : std::exception {
37 explicit ToolExecutionError(const std::string &M) : Message(M) {}
38 virtual ~ToolExecutionError() throw();
39 virtual const char* what() const throw() { return Message.c_str(); }
43 //===---------------------------------------------------------------------===//
47 std::string GCCPath; // The path to the gcc executable
48 GCC(const std::string &gccPath) : GCCPath(gccPath) { }
50 enum FileType { AsmFile, CFile };
52 static GCC* create(const std::string &ProgramPath, std::string &Message);
54 /// ExecuteProgram - Execute the program specified by "ProgramFile" (which is
55 /// either a .s file, or a .c file, specified by FileType), with the specified
56 /// arguments. Standard input is specified with InputFile, and standard
57 /// Output is captured to the specified OutputFile location. The SharedLibs
58 /// option specifies optional native shared objects that can be loaded into
59 /// the program for execution.
61 int ExecuteProgram(const std::string &ProgramFile,
62 const std::vector<std::string> &Args,
64 const std::string &InputFile,
65 const std::string &OutputFile,
66 const std::vector<std::string> &SharedLibs =
67 std::vector<std::string>());
69 /// MakeSharedObject - This compiles the specified file (which is either a .c
70 /// file or a .s file) into a shared object.
72 int MakeSharedObject(const std::string &InputFile, FileType fileType,
73 std::string &OutputFile);
77 //===---------------------------------------------------------------------===//
78 /// AbstractInterpreter Class - Subclasses of this class are used to execute
79 /// LLVM bytecode in a variety of ways. This abstract interface hides this
80 /// complexity behind a simple interface.
82 struct AbstractInterpreter {
83 static CBE *createCBE(const std::string &ProgramPath, std::string &Message,
84 const std::vector<std::string> *Args = 0);
85 static LLC *createLLC(const std::string &ProgramPath, std::string &Message,
86 const std::vector<std::string> *Args = 0);
88 static AbstractInterpreter* createLLI(const std::string &ProgramPath,
90 const std::vector<std::string> *Args=0);
92 static AbstractInterpreter* createJIT(const std::string &ProgramPath,
94 const std::vector<std::string> *Args=0);
97 virtual ~AbstractInterpreter() {}
99 /// compileProgram - Compile the specified program from bytecode to executable
100 /// code. This does not produce any output, it is only used when debugging
101 /// the code generator. If the code generator fails, an exception should be
102 /// thrown, otherwise, this function will just return.
103 virtual void compileProgram(const std::string &Bytecode) {}
105 /// ExecuteProgram - Run the specified bytecode file, emitting output to the
106 /// specified filename. This returns the exit code of the program.
108 virtual int ExecuteProgram(const std::string &Bytecode,
109 const std::vector<std::string> &Args,
110 const std::string &InputFile,
111 const std::string &OutputFile,
112 const std::vector<std::string> &SharedLibs =
113 std::vector<std::string>()) = 0;
116 //===---------------------------------------------------------------------===//
117 // CBE Implementation of AbstractIntepreter interface
119 class CBE : public AbstractInterpreter {
120 std::string LLCPath; // The path to the `llc' executable
121 std::vector<std::string> ToolArgs; // Extra args to pass to LLC
124 CBE(const std::string &llcPath, GCC *Gcc,
125 const std::vector<std::string> *Args) : LLCPath(llcPath), gcc(Gcc) {
127 if (Args) { ToolArgs.assign (Args->begin (), Args->end ()); }
129 ~CBE() { delete gcc; }
131 /// compileProgram - Compile the specified program from bytecode to executable
132 /// code. This does not produce any output, it is only used when debugging
133 /// the code generator. If the code generator fails, an exception should be
134 /// thrown, otherwise, this function will just return.
135 virtual void compileProgram(const std::string &Bytecode);
137 virtual int ExecuteProgram(const std::string &Bytecode,
138 const std::vector<std::string> &Args,
139 const std::string &InputFile,
140 const std::string &OutputFile,
141 const std::vector<std::string> &SharedLibs =
142 std::vector<std::string>());
144 // Sometimes we just want to go half-way and only generate the .c file, not
145 // necessarily compile it with GCC and run the program. This throws an
146 // exception if LLC crashes.
148 virtual void OutputC(const std::string &Bytecode, std::string &OutputCFile);
152 //===---------------------------------------------------------------------===//
153 // LLC Implementation of AbstractIntepreter interface
155 class LLC : public AbstractInterpreter {
156 std::string LLCPath; // The path to the LLC executable
157 std::vector<std::string> ToolArgs; // Extra args to pass to LLC
160 LLC(const std::string &llcPath, GCC *Gcc,
161 const std::vector<std::string> *Args) : LLCPath(llcPath), gcc(Gcc) {
163 if (Args) { ToolArgs.assign (Args->begin (), Args->end ()); }
165 ~LLC() { delete gcc; }
167 /// compileProgram - Compile the specified program from bytecode to executable
168 /// code. This does not produce any output, it is only used when debugging
169 /// the code generator. If the code generator fails, an exception should be
170 /// thrown, otherwise, this function will just return.
171 virtual void compileProgram(const std::string &Bytecode);
173 virtual int ExecuteProgram(const std::string &Bytecode,
174 const std::vector<std::string> &Args,
175 const std::string &InputFile,
176 const std::string &OutputFile,
177 const std::vector<std::string> &SharedLibs =
178 std::vector<std::string>());
180 // Sometimes we just want to go half-way and only generate the .s file,
181 // not necessarily compile it all the way and run the program. This throws
182 // an exception if execution of LLC fails.
184 void OutputAsm(const std::string &Bytecode, std::string &OutputAsmFile);
187 } // End llvm namespace