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"
26 //===---------------------------------------------------------------------===//
30 std::string GCCPath; // The path to the gcc executable
31 GCC(const std::string &gccPath) : GCCPath(gccPath) { }
33 enum FileType { AsmFile, CFile };
35 static GCC* create(const std::string &ProgramPath, std::string &Message);
37 /// ExecuteProgram - Execute the program specified by "ProgramFile" (which is
38 /// either a .s file, or a .c file, specified by FileType), with the specified
39 /// arguments. Standard input is specified with InputFile, and standard
40 /// Output is captured to the specified OutputFile location. The SharedLibs
41 /// option specifies optional native shared objects that can be loaded into
42 /// the program for execution.
44 int ExecuteProgram(const std::string &ProgramFile,
45 const std::vector<std::string> &Args,
47 const std::string &InputFile,
48 const std::string &OutputFile,
49 const std::vector<std::string> &SharedLibs =
50 std::vector<std::string>());
52 /// MakeSharedObject - This compiles the specified file (which is either a .c
53 /// file or a .s file) into a shared object.
55 int MakeSharedObject(const std::string &InputFile, FileType fileType,
56 std::string &OutputFile);
59 void ProcessFailure(const char **Args);
63 //===---------------------------------------------------------------------===//
64 /// AbstractInterpreter Class - Subclasses of this class are used to execute
65 /// LLVM bytecode in a variety of ways. This abstract interface hides this
66 /// complexity behind a simple interface.
68 struct AbstractInterpreter {
69 static CBE* createCBE(const std::string &ProgramPath, std::string &Message);
70 static LLC *createLLC(const std::string &ProgramPath, std::string &Message);
72 static AbstractInterpreter* createLLI(const std::string &ProgramPath,
73 std::string &Message);
75 static AbstractInterpreter* createJIT(const std::string &ProgramPath,
76 std::string &Message);
79 virtual ~AbstractInterpreter() {}
81 /// ExecuteProgram - Run the specified bytecode file, emitting output to the
82 /// specified filename. This returns the exit code of the program.
84 virtual int ExecuteProgram(const std::string &Bytecode,
85 const std::vector<std::string> &Args,
86 const std::string &InputFile,
87 const std::string &OutputFile,
88 const std::vector<std::string> &SharedLibs =
89 std::vector<std::string>()) = 0;
92 //===---------------------------------------------------------------------===//
93 // CBE Implementation of AbstractIntepreter interface
95 class CBE : public AbstractInterpreter {
96 std::string DISPath; // The path to the `llvm-dis' executable
99 CBE(const std::string &disPath, GCC *Gcc) : DISPath(disPath), gcc(Gcc) { }
100 ~CBE() { delete gcc; }
102 virtual int ExecuteProgram(const std::string &Bytecode,
103 const std::vector<std::string> &Args,
104 const std::string &InputFile,
105 const std::string &OutputFile,
106 const std::vector<std::string> &SharedLibs =
107 std::vector<std::string>());
109 // Sometimes we just want to go half-way and only generate the .c file,
110 // not necessarily compile it with GCC and run the program.
112 virtual int OutputC(const std::string &Bytecode, std::string &OutputCFile);
116 //===---------------------------------------------------------------------===//
117 // LLC Implementation of AbstractIntepreter interface
119 class LLC : public AbstractInterpreter {
120 std::string LLCPath; // The path to the LLC executable
123 LLC(const std::string &llcPath, GCC *Gcc)
124 : LLCPath(llcPath), gcc(Gcc) { }
125 ~LLC() { delete gcc; }
127 virtual int ExecuteProgram(const std::string &Bytecode,
128 const std::vector<std::string> &Args,
129 const std::string &InputFile,
130 const std::string &OutputFile,
131 const std::vector<std::string> &SharedLibs =
132 std::vector<std::string>());
134 // Sometimes we just want to go half-way and only generate the .s file,
135 // not necessarily compile it all the way and run the program.
137 int OutputAsm(const std::string &Bytecode, std::string &OutputAsmFile);