// control
tok_if = -6, tok_then = -7, tok_else = -8,
tok_for = -9, tok_in = -10,
// control
tok_if = -6, tok_then = -7, tok_else = -8,
tok_for = -9, tok_in = -10,
: Opcode(std::move(Opcode)), Operand(std::move(Operand)) {}
Value *IRGen(IRGenContext &C) const override;
: Opcode(std::move(Opcode)), Operand(std::move(Operand)) {}
Value *IRGen(IRGenContext &C) const override;
/// BinaryExprAST - Expression class for a binary operator.
struct BinaryExprAST : public ExprAST {
BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
/// BinaryExprAST - Expression class for a binary operator.
struct BinaryExprAST : public ExprAST {
BinaryExprAST(char Op, std::unique_ptr<ExprAST> LHS,
: Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
Value *IRGen(IRGenContext &C) const override;
: Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
Value *IRGen(IRGenContext &C) const override;
bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
bool isBinaryOp() const { return IsOperator && Args.size() == 2; }
char getOperatorName() const {
assert(isUnaryOp() || isBinaryOp());
return Name[Name.size()-1];
char getOperatorName() const {
assert(isUnaryOp() || isBinaryOp());
return Name[Name.size()-1];
// Make sure it's a declared binop.
int TokPrec = BinopPrecedence[CurTok];
if (TokPrec <= 0) return -1;
// Make sure it's a declared binop.
int TokPrec = BinopPrecedence[CurTok];
if (TokPrec <= 0) return -1;
/// ::= identifier '(' expression* ')'
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
std::string IdName = IdentifierStr;
/// ::= identifier '(' expression* ')'
static std::unique_ptr<ExprAST> ParseIdentifierExpr() {
std::string IdName = IdentifierStr;
/// ifexpr ::= 'if' expression 'then' expression 'else' expression
static std::unique_ptr<ExprAST> ParseIfExpr() {
getNextToken(); // eat the if.
/// ifexpr ::= 'if' expression 'then' expression 'else' expression
static std::unique_ptr<ExprAST> ParseIfExpr() {
getNextToken(); // eat the if.
auto Start = ParseExpression();
if (!Start)
return nullptr;
if (CurTok != ',')
return ErrorU<ForExprAST>("expected ',' after for start value");
getNextToken();
auto Start = ParseExpression();
if (!Start)
return nullptr;
if (CurTok != ',')
return ErrorU<ForExprAST>("expected ',' after for start value");
getNextToken();
// (',' identifier ('=' expression)?)* 'in' expression
static std::unique_ptr<VarExprAST> ParseVarExpr() {
getNextToken(); // eat the var.
// (',' identifier ('=' expression)?)* 'in' expression
static std::unique_ptr<VarExprAST> ParseVarExpr() {
getNextToken(); // eat the var.
// At least one variable name is required.
if (CurTok != tok_identifier)
return ErrorU<VarExprAST>("expected identifier after var");
// At least one variable name is required.
if (CurTok != tok_identifier)
return ErrorU<VarExprAST>("expected identifier after var");
// End of var list, exit loop.
if (CurTok != ',') break;
getNextToken(); // eat the ','.
// End of var list, exit loop.
if (CurTok != ',') break;
getNextToken(); // eat the ','.
// At this point, we have to have 'in'.
if (CurTok != tok_in)
return ErrorU<VarExprAST>("expected 'in' keyword after 'var'");
getNextToken(); // eat 'in'.
// At this point, we have to have 'in'.
if (CurTok != tok_in)
return ErrorU<VarExprAST>("expected 'in' keyword after 'var'");
getNextToken(); // eat 'in'.
// If the current token is not an operator, it must be a primary expr.
if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
return ParsePrimary();
// If the current token is not an operator, it must be a primary expr.
if (!isascii(CurTok) || CurTok == '(' || CurTok == ',')
return ParsePrimary();
// If this is a binop, find its precedence.
while (1) {
int TokPrec = GetTokPrecedence();
// If this is a binop, find its precedence.
while (1) {
int TokPrec = GetTokPrecedence();
// If this is a binop that binds at least as tightly as the current binop,
// consume it, otherwise we are done.
if (TokPrec < ExprPrec)
return LHS;
// If this is a binop that binds at least as tightly as the current binop,
// consume it, otherwise we are done.
if (TokPrec < ExprPrec)
return LHS;
// Okay, we know this is a binop.
int BinOp = CurTok;
getNextToken(); // eat binop
// Okay, we know this is a binop.
int BinOp = CurTok;
getNextToken(); // eat binop
// If BinOp binds less tightly with RHS than the operator after RHS, let
// the pending operator take RHS as its LHS.
int NextPrec = GetTokPrecedence();
// If BinOp binds less tightly with RHS than the operator after RHS, let
// the pending operator take RHS as its LHS.
int NextPrec = GetTokPrecedence();
unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
unsigned BinaryPrecedence = 30;
unsigned Kind = 0; // 0 = identifier, 1 = unary, 2 = binary.
unsigned BinaryPrecedence = 30;
// Read the precedence if present.
if (CurTok == tok_number) {
if (NumVal < 1 || NumVal > 100)
// Read the precedence if present.
if (CurTok == tok_number) {
if (NumVal < 1 || NumVal > 100)
std::vector<std::string> ArgNames;
while (getNextToken() == tok_identifier)
ArgNames.push_back(IdentifierStr);
if (CurTok != ')')
return ErrorU<PrototypeAST>("Expected ')' in prototype");
std::vector<std::string> ArgNames;
while (getNextToken() == tok_identifier)
ArgNames.push_back(IdentifierStr);
if (CurTok != ')')
return ErrorU<PrototypeAST>("Expected ')' in prototype");
// Verify right number of names for operator.
if (Kind && ArgNames.size() != Kind)
return ErrorU<PrototypeAST>("Invalid number of operands for operator");
// Verify right number of names for operator.
if (Kind && ArgNames.size() != Kind)
return ErrorU<PrototypeAST>("Invalid number of operands for operator");
return llvm::make_unique<PrototypeAST>(FnName, std::move(ArgNames), Kind != 0,
BinaryPrecedence);
}
return llvm::make_unique<PrototypeAST>(FnName, std::move(ArgNames), Kind != 0,
BinaryPrecedence);
}
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
PrototypeAST* getPrototypeAST(const std::string &Name);
private:
typedef std::map<std::string, std::unique_ptr<PrototypeAST>> PrototypeMap;
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
Builder(Session.getLLVMContext()) {
M(new Module(GenerateUniqueName("jit_module_"),
Session.getLLVMContext())),
Builder(Session.getLLVMContext()) {
const std::string &VarName) {
IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
TheFunction->getEntryBlock().begin());
const std::string &VarName) {
IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
TheFunction->getEntryBlock().begin());
// Special case '=' because we don't want to emit the LHS as an expression.
if (Op == '=') {
// Assignment requires the LHS to be an identifier.
// Special case '=' because we don't want to emit the LHS as an expression.
if (Op == '=') {
// Assignment requires the LHS to be an identifier.
Value *L = LHS->IRGen(C);
Value *R = RHS->IRGen(C);
if (!L || !R) return nullptr;
Value *L = LHS->IRGen(C);
Value *R = RHS->IRGen(C);
if (!L || !R) return nullptr;
switch (Op) {
case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
switch (Op) {
case '+': return C.getBuilder().CreateFAdd(L, R, "addtmp");
case '-': return C.getBuilder().CreateFSub(L, R, "subtmp");
// If it wasn't a builtin binary operator, it must be a user defined one. Emit
// a call to it.
std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
// If it wasn't a builtin binary operator, it must be a user defined one. Emit
// a call to it.
std::string FnName = MakeLegalFunctionName(std::string("binary")+Op);
Value *IfExprAST::IRGen(IRGenContext &C) const {
Value *CondV = Cond->IRGen(C);
if (!CondV) return nullptr;
Value *IfExprAST::IRGen(IRGenContext &C) const {
Value *CondV = Cond->IRGen(C);
if (!CondV) return nullptr;
ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
CondV = C.getBuilder().CreateFCmpONE(CondV, FPZero, "ifcond");
ConstantFP::get(C.getLLVMContext(), APFloat(0.0));
CondV = C.getBuilder().CreateFCmpONE(CondV, FPZero, "ifcond");
// Create blocks for the then and else cases. Insert the 'then' block at the
// end of the function.
BasicBlock *ThenBB = BasicBlock::Create(C.getLLVMContext(), "then", TheFunction);
BasicBlock *ElseBB = BasicBlock::Create(C.getLLVMContext(), "else");
BasicBlock *MergeBB = BasicBlock::Create(C.getLLVMContext(), "ifcont");
// Create blocks for the then and else cases. Insert the 'then' block at the
// end of the function.
BasicBlock *ThenBB = BasicBlock::Create(C.getLLVMContext(), "then", TheFunction);
BasicBlock *ElseBB = BasicBlock::Create(C.getLLVMContext(), "else");
BasicBlock *MergeBB = BasicBlock::Create(C.getLLVMContext(), "ifcont");
C.getBuilder().CreateBr(MergeBB);
// Codegen of 'Then' can change the current block, update ThenBB for the PHI.
ThenBB = C.getBuilder().GetInsertBlock();
C.getBuilder().CreateBr(MergeBB);
// Codegen of 'Then' can change the current block, update ThenBB for the PHI.
ThenBB = C.getBuilder().GetInsertBlock();
C.getBuilder().CreateBr(MergeBB);
// Codegen of 'Else' can change the current block, update ElseBB for the PHI.
ElseBB = C.getBuilder().GetInsertBlock();
C.getBuilder().CreateBr(MergeBB);
// Codegen of 'Else' can change the current block, update ElseBB for the PHI.
ElseBB = C.getBuilder().GetInsertBlock();
// Emit merge block.
TheFunction->getBasicBlockList().push_back(MergeBB);
C.getBuilder().SetInsertPoint(MergeBB);
PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
"iftmp");
// Emit merge block.
TheFunction->getBasicBlockList().push_back(MergeBB);
C.getBuilder().SetInsertPoint(MergeBB);
PHINode *PN = C.getBuilder().CreatePHI(Type::getDoubleTy(getGlobalContext()), 2,
"iftmp");
PN->addIncoming(ThenV, ThenBB);
PN->addIncoming(ElseV, ElseBB);
return PN;
PN->addIncoming(ThenV, ThenBB);
PN->addIncoming(ElseV, ElseBB);
return PN;
Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
// Create an alloca for the variable in the entry block.
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
// Create an alloca for the variable in the entry block.
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
// Emit the start code first, without 'variable' in scope.
Value *StartVal = Start->IRGen(C);
if (!StartVal) return nullptr;
// Emit the start code first, without 'variable' in scope.
Value *StartVal = Start->IRGen(C);
if (!StartVal) return nullptr;
// Store the value into the alloca.
C.getBuilder().CreateStore(StartVal, Alloca);
// Store the value into the alloca.
C.getBuilder().CreateStore(StartVal, Alloca);
// Make the new basic block for the loop header, inserting after current
// block.
BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
// Make the new basic block for the loop header, inserting after current
// block.
BasicBlock *LoopBB = BasicBlock::Create(getGlobalContext(), "loop", TheFunction);
// Insert an explicit fall through from the current block to the LoopBB.
C.getBuilder().CreateBr(LoopBB);
// Start insertion in LoopBB.
C.getBuilder().SetInsertPoint(LoopBB);
// Insert an explicit fall through from the current block to the LoopBB.
C.getBuilder().CreateBr(LoopBB);
// Start insertion in LoopBB.
C.getBuilder().SetInsertPoint(LoopBB);
// Within the loop, the variable is defined equal to the PHI node. If it
// shadows an existing variable, we have to restore it, so save it now.
AllocaInst *OldVal = C.NamedValues[VarName];
C.NamedValues[VarName] = Alloca;
// Within the loop, the variable is defined equal to the PHI node. If it
// shadows an existing variable, we have to restore it, so save it now.
AllocaInst *OldVal = C.NamedValues[VarName];
C.NamedValues[VarName] = Alloca;
// Emit the body of the loop. This, like any other expr, can change the
// current BB. Note that we ignore the value computed by the body, but don't
// allow an error.
if (!Body->IRGen(C))
return nullptr;
// Emit the body of the loop. This, like any other expr, can change the
// current BB. Note that we ignore the value computed by the body, but don't
// allow an error.
if (!Body->IRGen(C))
return nullptr;
// If not specified, use 1.0.
StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
}
// If not specified, use 1.0.
StepVal = ConstantFP::get(getGlobalContext(), APFloat(1.0));
}
// Reload, increment, and restore the alloca. This handles the case where
// the body of the loop mutates the variable.
Value *CurVar = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
C.getBuilder().CreateStore(NextVar, Alloca);
// Reload, increment, and restore the alloca. This handles the case where
// the body of the loop mutates the variable.
Value *CurVar = C.getBuilder().CreateLoad(Alloca, VarName.c_str());
Value *NextVar = C.getBuilder().CreateFAdd(CurVar, StepVal, "nextvar");
C.getBuilder().CreateStore(NextVar, Alloca);
// Create the "after loop" block and insert it.
BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
// Create the "after loop" block and insert it.
BasicBlock *AfterBB = BasicBlock::Create(getGlobalContext(), "afterloop", TheFunction);
// Insert the conditional branch into the end of LoopEndBB.
C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
// Insert the conditional branch into the end of LoopEndBB.
C.getBuilder().CreateCondBr(EndCond, LoopBB, AfterBB);
// Restore the unshadowed variable.
if (OldVal)
C.NamedValues[VarName] = OldVal;
else
C.NamedValues.erase(VarName);
// Restore the unshadowed variable.
if (OldVal)
C.NamedValues[VarName] = OldVal;
else
C.NamedValues.erase(VarName);
// for expr always returns 0.0.
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
Value *VarExprAST::IRGen(IRGenContext &C) const {
std::vector<AllocaInst *> OldBindings;
// for expr always returns 0.0.
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
Value *VarExprAST::IRGen(IRGenContext &C) const {
std::vector<AllocaInst *> OldBindings;
Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
// Register all variables and emit their initializer.
for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
auto &VarName = VarBindings[i].first;
auto &Init = VarBindings[i].second;
Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
// Register all variables and emit their initializer.
for (unsigned i = 0, e = VarBindings.size(); i != e; ++i) {
auto &VarName = VarBindings[i].first;
auto &Init = VarBindings[i].second;
// Emit the initializer before adding the variable to scope, this prevents
// the initializer from referencing the variable itself, and permits stuff
// like this:
// Emit the initializer before adding the variable to scope, this prevents
// the initializer from referencing the variable itself, and permits stuff
// like this:
if (!InitVal) return nullptr;
} else // If not specified, use 0.0.
InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
if (!InitVal) return nullptr;
} else // If not specified, use 0.0.
InitVal = ConstantFP::get(getGlobalContext(), APFloat(0.0));
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
C.getBuilder().CreateStore(InitVal, Alloca);
// Remember the old variable binding so that we can restore the binding when
// we unrecurse.
OldBindings.push_back(C.NamedValues[VarName]);
AllocaInst *Alloca = CreateEntryBlockAlloca(TheFunction, VarName);
C.getBuilder().CreateStore(InitVal, Alloca);
// Remember the old variable binding so that we can restore the binding when
// we unrecurse.
OldBindings.push_back(C.NamedValues[VarName]);
// Codegen the body, now that all vars are in scope.
Value *BodyVal = Body->IRGen(C);
if (!BodyVal) return nullptr;
// Codegen the body, now that all vars are in scope.
Value *BodyVal = Body->IRGen(C);
if (!BodyVal) return nullptr;
// Pop all our variables from scope.
for (unsigned i = 0, e = VarBindings.size(); i != e; ++i)
C.NamedValues[VarBindings[i].first] = OldBindings[i];
// Pop all our variables from scope.
for (unsigned i = 0, e = VarBindings.size(); i != e; ++i)
C.NamedValues[VarBindings[i].first] = OldBindings[i];
std::string FnName = MakeLegalFunctionName(Name);
// Make the function type: double(double,double) etc.
std::string FnName = MakeLegalFunctionName(Name);
// Make the function type: double(double,double) etc.
Type::getDoubleTy(getGlobalContext()));
FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
Doubles, false);
Type::getDoubleTy(getGlobalContext()));
FunctionType *FT = FunctionType::get(Type::getDoubleTy(getGlobalContext()),
Doubles, false);
// If F already has a body, reject this.
if (!F->empty()) {
ErrorP<Function>("redefinition of function");
return nullptr;
}
// If F already has a body, reject this.
if (!F->empty()) {
ErrorP<Function>("redefinition of function");
return nullptr;
}
// If F took a different number of args, reject.
if (F->arg_size() != Args.size()) {
ErrorP<Function>("redefinition of function with different # args");
return nullptr;
}
}
// If F took a different number of args, reject.
if (F->arg_size() != Args.size()) {
ErrorP<Function>("redefinition of function with different # args");
return nullptr;
}
}
// If this is an operator, install it.
if (Proto->isBinaryOp())
BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
// If this is an operator, install it.
if (Proto->isBinaryOp())
BinopPrecedence[Proto->getOperatorName()] = Proto->Precedence;
// Create a new basic block to start insertion into.
BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
C.getBuilder().SetInsertPoint(BB);
// Create a new basic block to start insertion into.
BasicBlock *BB = BasicBlock::Create(getGlobalContext(), "entry", TheFunction);
C.getBuilder().SetInsertPoint(BB);
// Add all arguments to the symbol table and create their allocas.
Proto->CreateArgumentAllocas(TheFunction, C);
// Add all arguments to the symbol table and create their allocas.
Proto->CreateArgumentAllocas(TheFunction, C);
// Error reading body, remove function.
TheFunction->eraseFromParent();
// Error reading body, remove function.
TheFunction->eraseFromParent();
: Session(Session),
CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())),
LazyEmitLayer(CompileLayer),
: Session(Session),
CompileLayer(ObjectLayer, SimpleCompiler(Session.getTarget())),
LazyEmitLayer(CompileLayer),
- CompileCallbacks(LazyEmitLayer, CCMgrMemMgr, Session.getLLVMContext(),
- reinterpret_cast<uintptr_t>(EarthShatteringKaboom),
- 64) {}
+ CompileCallbacks(reinterpret_cast<uintptr_t>(EarthShatteringKaboom)) {}
std::string mangle(const std::string &Name) {
std::string MangledName;
{
raw_string_ostream MangledNameStream(MangledName);
Mangler::getNameWithPrefix(MangledNameStream, Name,
std::string mangle(const std::string &Name) {
std::string MangledName;
{
raw_string_ostream MangledNameStream(MangledName);
Mangler::getNameWithPrefix(MangledNameStream, Name,
RuntimeDyld::SymbolInfo searchFunctionASTs(const std::string &Name) {
auto DefI = FunctionDefs.find(Name);
if (DefI == FunctionDefs.end())
RuntimeDyld::SymbolInfo searchFunctionASTs(const std::string &Name) {
auto DefI = FunctionDefs.find(Name);
if (DefI == FunctionDefs.end())
// the function. The resulting CallbackInfo type will let us set the
// compile and update actions for the callback, and get a pointer to
// the jit trampoline that we need to call to trigger those actions.
// the function. The resulting CallbackInfo type will let us set the
// compile and update actions for the callback, and get a pointer to
// the jit trampoline that we need to call to trigger those actions.
// Step 3) Create a stub that will indirectly call the body of this
// function once it is compiled. Initially, set the function
// Step 3) Create a stub that will indirectly call the body of this
// function once it is compiled. Initially, set the function
// Get the address of the JIT'd function in memory.
auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Get the address of the JIT'd function in memory.
auto ExprSymbol = J.findUnmangledSymbol("__anon_expr");
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
// Cast it to the right type (takes no arguments, returns a double) so we
// can call it as a native function.
double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
//===----------------------------------------------------------------------===//
/// putchard - putchar that takes a double and returns 0.
//===----------------------------------------------------------------------===//
/// putchard - putchar that takes a double and returns 0.
double putchard(double X) {
putchar((char)X);
return 0;
}
/// printd - printf that takes a double prints it as "%f\n", returning 0.
double putchard(double X) {
putchar((char)X);
return 0;
}
/// printd - printf that takes a double prints it as "%f\n", returning 0.