roadrunner  2.6.0
Fast simulator for SBML models
CodeGenBase.h
1 /*
2  * CodeGenBase.h
3  *
4  * Created on: Jul 4, 2013
5  * Author: andy
6  */
7 
8 #ifndef LLVMCodeGenBaseH
9 #define LLVMCodeGenBaseH
10 
11 #include "ModelGeneratorContext.h"
12 #include "CodeGen.h"
13 #include "LLVMException.h"
14 #include "rrLogger.h"
15 #include <Poco/Logger.h>
16 
17 #ifdef _MSC_VER
18 #pragma warning(disable: 4146)
19 #pragma warning(disable: 4141)
20 #pragma warning(disable: 4267)
21 #pragma warning(disable: 4624)
22 #endif
23 
24 #include "llvm/IR/Mangler.h"
25 
26 #ifdef _MSC_VER
27 #pragma warning(default: 4146)
28 #pragma warning(default: 4141)
29 #pragma warning(default: 4267)
30 #pragma warning(default: 4624)
31 #endif
32 
33 
34 using rr::Logger;
35 using rr::getLogger;
36 
37 namespace rrllvm
38 {
39 
40  class Jit;
41 
42 typedef std::vector<std::string> StringVector;
43 typedef std::pair<std::string, int> StringIntPair;
44 typedef std::vector<StringIntPair> StringIntVector;
45 
52 template <typename FunctionPtrType>
54 {
55 public:
56  llvm::Function* createFunction()
57  {
58  llvm::Function *func = (llvm::Function*)codeGen();
59 
61  {
62  //functionPassManager->run(*func);
63  }
64 
65  return func;
66  }
67 
68  typedef FunctionPtrType FunctionPtr;
69 
70 protected:
72  modelGenContext(mgc),
73  model(mgc.getModel()),
74  dataSymbols(mgc.getModelDataSymbols()),
75  modelSymbols(mgc.getModelSymbols()),
76  context(mgc.getJitNonOwning()->getModuleNonOwning()->getContext()),
77  module(mgc.getJitNonOwning()->getModuleNonOwning()),
78  builder(*mgc.getJitNonOwning()->getBuilderNonOwning()),
79  options(mgc.getOptions()),
80  function(0)
81  {
82 
83  };
84 
85  const ModelGeneratorContext &modelGenContext;
86 
90  const libsbml::Model *model;
91 
92  const LLVMModelDataSymbols &dataSymbols;
93  const LLVMModelSymbols &modelSymbols;
94 
95  llvm::LLVMContext &context;
96  llvm::Module *module;
97  llvm::IRBuilder<> &builder;
98  llvm::Function *function;
99 
103  llvm::legacy::FunctionPassManager* functionPassManager;
104 
108  const unsigned options;
109 
110  virtual llvm::Value *codeGen() = 0;
111 
112  template <size_t N>
113  llvm::BasicBlock *codeGenHeader(const char* functionName,
114  llvm::Type *retType,
115  llvm::Type* (&argTypes)[N],
116  const char* (&argNames)[N],
117  llvm::Value* (&args)[N])
118  {
119  // make the set init value function
120 
121  llvm::FunctionType *funcType = llvm::FunctionType::get(retType, argTypes, false);
122  function = llvm::Function::Create(funcType,
123  llvm::Function::ExternalLinkage,
124  functionName, module);
125 
126  // Create a new basic block to start insertion into.
127  llvm::BasicBlock *basicBlock = llvm::BasicBlock::Create(context,"entry", function);
128  builder.SetInsertPoint(basicBlock);
129 
130  assert(function->arg_size() == N);
131 
132  int i = 0;
133  for (llvm::Function::arg_iterator ai = function->arg_begin();
134  ai != function->arg_end(); ++ai, ++i)
135  {
136  llvm::Value *arg = ai;
137  arg->setName(argNames[i]);
138  args[i] = arg;
139  }
140 
141  return basicBlock;
142  }
143 
148  llvm::BasicBlock *codeGenVoidModelDataHeader(const char* functionName,llvm::Value* &modelData)
149  {
150  llvm::Type *argTypes[] = {
151  llvm::PointerType::get(
153  };
154 
155  const char *argNames[] = { "modelData" };
156 
157  llvm::Value *args[] = { 0 };
158 
159  llvm::BasicBlock *basicBlock = codeGenHeader(functionName,
160  llvm::Type::getVoidTy(context),
161  argTypes, argNames, args);
162 
163  modelData = args[0];
164  return basicBlock;
165  }
166 
167  llvm::Function *verifyFunction()
168  {
169  rrLogInfo << std::string("function: ") + to_string(function);
170 
173  if (llvm::verifyFunction(*function))
174  {
175  std::string err = "Corrupt Generated Function, " + to_string(function);
176  rrLogErr << err;
177 
178  throw LLVMException(err);
179  }
180 
181  return function;
182  }
183 
184 
185  virtual ~CodeGenBase() {};
186 
187 
188 };
189 
190 } /* namespace rr */
191 #endif /* LLVMCodeGenBaseH */
The roadrunner logger.
Definition: rrLogger.h:63
a convenience class to pull the vars out of a context, and store them as ivars.
Definition: CodeGenBase.h:54
llvm::BasicBlock * codeGenVoidModelDataHeader(const char *functionName, llvm::Value *&modelData)
the most common type of generated function takes a ModelData*, and returns void.
Definition: CodeGenBase.h:148
const unsigned options
the options bit field that was passed into the top level load method.
Definition: CodeGenBase.h:108
llvm::legacy::FunctionPassManager * functionPassManager
function pass manager.
Definition: CodeGenBase.h:103
llvm::Function * verifyFunction()
Definition: CodeGenBase.h:167
const libsbml::Model * model
could potentially be null, everything else is guaranteed to be valid
Definition: CodeGenBase.h:90
virtual llvm::Module * getModuleNonOwning()
returns a non owning pointer to the llvm::Module instance
Definition: Jit.cpp:72
virtual llvm::IRBuilder * getBuilderNonOwning()
returns a non owning pointer to the llvm::LLVMContext instance
Definition: Jit.cpp:91
stores the names of all the symbols in the sbml model and thier indexes in the ModelData arrays.
Definition: LLVMModelDataSymbols.h:128
Hold all the un-evaluated symbolic inforamtion in the model.
Definition: LLVMModelSymbols.h:26
static llvm::StructType * getStructType(llvm::Module *module)
get the ModelData struct type.
Definition: ModelDataIRBuilder.cpp:731
All LLVM code generating objects basically need at a minimum three things to operate:
Definition: ModelGeneratorContext.h:95