1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
//===-- Support/ToolRunner.h ------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file was developed by the LLVM research group and is distributed under
// the University of Illinois Open Source License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file exposes an abstraction around a platform C compiler, used to
// compile C and assembly code. It also exposes an "AbstractIntepreter"
// interface, which is used to execute code using one of the LLVM execution
// engines.
//
//===----------------------------------------------------------------------===//
#ifndef TOOLRUNNER_H
#define TOOLRUNNER_H
#include "Support/SystemUtils.h"
#include <vector>
namespace llvm {
class CBE;
class LLC;
//===---------------------------------------------------------------------===//
// GCC abstraction
//
class GCC {
std::string GCCPath; // The path to the gcc executable
GCC(const std::string &gccPath) : GCCPath(gccPath) { }
public:
enum FileType { AsmFile, CFile };
static GCC* create(const std::string &ProgramPath, std::string &Message);
/// ExecuteProgram - Execute the program specified by "ProgramFile" (which is
/// either a .s file, or a .c file, specified by FileType), with the specified
/// arguments. Standard input is specified with InputFile, and standard
/// Output is captured to the specified OutputFile location. The SharedLibs
/// option specifies optional native shared objects that can be loaded into
/// the program for execution.
///
int ExecuteProgram(const std::string &ProgramFile,
const std::vector<std::string> &Args,
FileType fileType,
const std::string &InputFile,
const std::string &OutputFile,
const std::vector<std::string> &SharedLibs =
std::vector<std::string>());
/// MakeSharedObject - This compiles the specified file (which is either a .c
/// file or a .s file) into a shared object.
///
int MakeSharedObject(const std::string &InputFile, FileType fileType,
std::string &OutputFile);
private:
void ProcessFailure(const char **Args);
};
//===---------------------------------------------------------------------===//
/// AbstractInterpreter Class - Subclasses of this class are used to execute
/// LLVM bytecode in a variety of ways. This abstract interface hides this
/// complexity behind a simple interface.
///
struct AbstractInterpreter {
static CBE* createCBE(const std::string &ProgramPath, std::string &Message);
static LLC *createLLC(const std::string &ProgramPath, std::string &Message);
static AbstractInterpreter* createLLI(const std::string &ProgramPath,
std::string &Message);
static AbstractInterpreter* createJIT(const std::string &ProgramPath,
std::string &Message);
virtual ~AbstractInterpreter() {}
/// ExecuteProgram - Run the specified bytecode file, emitting output to the
/// specified filename. This returns the exit code of the program.
///
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
const std::vector<std::string> &SharedLibs =
std::vector<std::string>()) = 0;
};
//===---------------------------------------------------------------------===//
// CBE Implementation of AbstractIntepreter interface
//
class CBE : public AbstractInterpreter {
std::string LLCPath; // The path to the `llc' executable
GCC *gcc;
public:
CBE(const std::string &llcPath, GCC *Gcc) : LLCPath(llcPath), gcc(Gcc) { }
~CBE() { delete gcc; }
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
const std::vector<std::string> &SharedLibs =
std::vector<std::string>());
// Sometimes we just want to go half-way and only generate the .c file,
// not necessarily compile it with GCC and run the program.
//
virtual int OutputC(const std::string &Bytecode, std::string &OutputCFile);
};
//===---------------------------------------------------------------------===//
// LLC Implementation of AbstractIntepreter interface
//
class LLC : public AbstractInterpreter {
std::string LLCPath; // The path to the LLC executable
GCC *gcc;
public:
LLC(const std::string &llcPath, GCC *Gcc)
: LLCPath(llcPath), gcc(Gcc) { }
~LLC() { delete gcc; }
virtual int ExecuteProgram(const std::string &Bytecode,
const std::vector<std::string> &Args,
const std::string &InputFile,
const std::string &OutputFile,
const std::vector<std::string> &SharedLibs =
std::vector<std::string>());
// Sometimes we just want to go half-way and only generate the .s file,
// not necessarily compile it all the way and run the program.
//
int OutputAsm(const std::string &Bytecode, std::string &OutputAsmFile);
};
} // End llvm namespace
#endif
|
