#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Verifier.h"
-#include "llvm/PassManager.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Transforms/Scalar.h"
#include <cctype>
-#include <cstdio>
+#include <iomanip>
+#include <iostream>
#include <map>
+#include <sstream>
#include <string>
#include <vector>
using namespace llvm;
/// ExprAST - Base class for all expression nodes.
struct ExprAST {
virtual ~ExprAST() {}
- virtual Value* IRGen(IRGenContext &C) = 0;
+ virtual Value *IRGen(IRGenContext &C) const = 0;
};
/// NumberExprAST - Expression class for numeric literals like "1.0".
struct NumberExprAST : public ExprAST {
NumberExprAST(double Val) : Val(Val) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
double Val;
};
/// VariableExprAST - Expression class for referencing a variable, like "a".
struct VariableExprAST : public ExprAST {
VariableExprAST(std::string Name) : Name(std::move(Name)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
std::string Name;
};
UnaryExprAST(char Opcode, std::unique_ptr<ExprAST> Operand)
: Opcode(std::move(Opcode)), Operand(std::move(Operand)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
char Opcode;
std::unique_ptr<ExprAST> Operand;
std::unique_ptr<ExprAST> RHS)
: Op(Op), LHS(std::move(LHS)), RHS(std::move(RHS)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
char Op;
std::unique_ptr<ExprAST> LHS, RHS;
std::vector<std::unique_ptr<ExprAST>> Args)
: CalleeName(std::move(CalleeName)), Args(std::move(Args)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
std::string CalleeName;
std::vector<std::unique_ptr<ExprAST>> Args;
IfExprAST(std::unique_ptr<ExprAST> Cond, std::unique_ptr<ExprAST> Then,
std::unique_ptr<ExprAST> Else)
: Cond(std::move(Cond)), Then(std::move(Then)), Else(std::move(Else)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
std::unique_ptr<ExprAST> Cond, Then, Else;
};
: VarName(std::move(VarName)), Start(std::move(Start)), End(std::move(End)),
Step(std::move(Step)), Body(std::move(Body)) {}
- Value* IRGen(IRGenContext &C) override;
+ Value *IRGen(IRGenContext &C) const override;
std::string VarName;
std::unique_ptr<ExprAST> Start, End, Step, Body;
VarExprAST(BindingList VarBindings, std::unique_ptr<ExprAST> Body)
: VarBindings(std::move(VarBindings)), Body(std::move(Body)) {}
-
- Value* IRGen(IRGenContext &C) override;
+
+ Value *IRGen(IRGenContext &C) const override;
BindingList VarBindings;
std::unique_ptr<ExprAST> Body;
: Name(std::move(Name)), Args(std::move(Args)), IsOperator(IsOperator),
Precedence(Precedence) {}
- Function* IRGen(IRGenContext &C);
+ Function *IRGen(IRGenContext &C) const;
void CreateArgumentAllocas(Function *F, IRGenContext &C);
bool isUnaryOp() const { return IsOperator && Args.size() == 1; }
std::unique_ptr<ExprAST> Body)
: Proto(std::move(Proto)), Body(std::move(Body)) {}
- Function* IRGen(IRGenContext &C);
+ Function *IRGen(IRGenContext &C) const;
std::unique_ptr<PrototypeAST> Proto;
std::unique_ptr<ExprAST> Body;
}
template <typename T>
-std::unique_ptr<T> ErrorU(const char *Str) {
- fprintf(stderr, "Error: %s\n", Str);
+std::unique_ptr<T> ErrorU(const std::string &Str) {
+ std::cerr << "Error: " << Str << "\n";
return nullptr;
}
template <typename T>
-T* ErrorP(const char *Str) {
- fprintf(stderr, "Error: %s\n", Str);
+T* ErrorP(const std::string &Str) {
+ std::cerr << "Error: " << Str << "\n";
return nullptr;
}
//===----------------------------------------------------------------------===//
// FIXME: Obviously we can do better than this
-std::string GenerateUniqueName(const char *root)
-{
+std::string GenerateUniqueName(const std::string &Root) {
static int i = 0;
- char s[16];
- sprintf(s, "%s%d", root, i++);
- std::string S = s;
- return S;
+ std::ostringstream NameStream;
+ NameStream << Root << ++i;
+ return NameStream.str();
}
std::string MakeLegalFunctionName(std::string Name)
std::string legal_elements = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
size_t pos;
while ((pos = NewName.find_first_not_of(legal_elements)) != std::string::npos) {
- char old_c = NewName.at(pos);
- char new_str[16];
- sprintf(new_str, "%d", (int)old_c);
- NewName = NewName.replace(pos, 1, new_str);
+ std::ostringstream NumStream;
+ NumStream << (int)NewName.at(pos);
+ NewName = NewName.replace(pos, 1, NumStream.str());
}
return NewName;
if (I != Prototypes.end())
return I->second.get();
return nullptr;
-}
+}
class IRGenContext {
public:
VarName.c_str());
}
-Value *NumberExprAST::IRGen(IRGenContext &C) {
+Value *NumberExprAST::IRGen(IRGenContext &C) const {
return ConstantFP::get(C.getLLVMContext(), APFloat(Val));
}
-Value *VariableExprAST::IRGen(IRGenContext &C) {
+Value *VariableExprAST::IRGen(IRGenContext &C) const {
// Look this variable up in the function.
Value *V = C.NamedValues[Name];
- if (V == 0) {
- char ErrStr[256];
- sprintf(ErrStr, "Unknown variable name %s", Name.c_str());
- return ErrorP<Value>(ErrStr);
- }
+ if (V == 0)
+ return ErrorP<Value>("Unknown variable name '" + Name + "'");
// Load the value.
return C.getBuilder().CreateLoad(V, Name.c_str());
}
-Value *UnaryExprAST::IRGen(IRGenContext &C) {
+Value *UnaryExprAST::IRGen(IRGenContext &C) const {
if (Value *OperandV = Operand->IRGen(C)) {
std::string FnName = MakeLegalFunctionName(std::string("unary")+Opcode);
if (Function *F = C.getPrototype(FnName))
return nullptr;
}
-Value *BinaryExprAST::IRGen(IRGenContext &C) {
+Value *BinaryExprAST::IRGen(IRGenContext &C) const {
// Special case '=' because we don't want to emit the LHS as an expression.
if (Op == '=') {
// Assignment requires the LHS to be an identifier.
return ErrorP<Value>("Unknown binary operator");
}
-Value *CallExprAST::IRGen(IRGenContext &C) {
+Value *CallExprAST::IRGen(IRGenContext &C) const {
// Look up the name in the global module table.
if (auto CalleeF = C.getPrototype(CalleeName)) {
// If argument mismatch error.
return ErrorP<Value>("Unknown function referenced");
}
-Value *IfExprAST::IRGen(IRGenContext &C) {
+Value *IfExprAST::IRGen(IRGenContext &C) const {
Value *CondV = Cond->IRGen(C);
if (!CondV) return nullptr;
return PN;
}
-Value *ForExprAST::IRGen(IRGenContext &C) {
+Value *ForExprAST::IRGen(IRGenContext &C) const {
// Output this as:
// var = alloca double
// ...
return Constant::getNullValue(Type::getDoubleTy(getGlobalContext()));
}
-Value *VarExprAST::IRGen(IRGenContext &C) {
+Value *VarExprAST::IRGen(IRGenContext &C) const {
std::vector<AllocaInst *> OldBindings;
Function *TheFunction = C.getBuilder().GetInsertBlock()->getParent();
return BodyVal;
}
-Function *PrototypeAST::IRGen(IRGenContext &C) {
+Function *PrototypeAST::IRGen(IRGenContext &C) const {
std::string FnName = MakeLegalFunctionName(Name);
// Make the function type: double(double,double) etc.
}
}
-Function *FunctionAST::IRGen(IRGenContext &C) {
+Function *FunctionAST::IRGen(IRGenContext &C) const {
C.NamedValues.clear();
Function *TheFunction = Proto->IRGen(C);
// new module. Create one that resolves symbols by looking back into the JIT.
auto MM = createLookasideRTDyldMM<SectionMemoryManager>(
[&](const std::string &S) {
- return getMangledSymbolAddress(S);
- },
+ return findMangledSymbol(S).getAddress();
+ },
[](const std::string &S) { return 0; } );
return CompileLayer.addModuleSet(std::move(S), std::move(MM));
void removeModule(ModuleHandleT H) { CompileLayer.removeModuleSet(H); }
- uint64_t getMangledSymbolAddress(const std::string &Name) {
- return CompileLayer.getSymbolAddress(Name, false);
+ JITSymbol findMangledSymbol(const std::string &Name) {
+ return CompileLayer.findSymbol(Name, false);
}
- uint64_t getSymbolAddress(const std::string Name) {
+ JITSymbol findSymbol(const std::string Name) {
std::string MangledName;
{
raw_string_ostream MangledNameStream(MangledName);
Mang.getNameWithPrefix(MangledNameStream, Name);
}
- return getMangledSymbolAddress(MangledName);
+ return findMangledSymbol(MangledName);
}
private:
CompileLayerT CompileLayer;
};
-static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) {
- if (auto F = ParseDefinition()) {
- IRGenContext C(S);
- if (auto LF = F->IRGen(C)) {
+static std::unique_ptr<llvm::Module> IRGen(SessionContext &S,
+ const FunctionAST &F) {
+ IRGenContext C(S);
+ auto LF = F.IRGen(C);
+ if (!LF)
+ return nullptr;
#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "Read function definition:");
- LF->dump();
+ fprintf(stderr, "Read function definition:");
+ LF->dump();
#endif
- J.addModule(C.takeM());
+ return C.takeM();
+}
+
+static void HandleDefinition(SessionContext &S, KaleidoscopeJIT &J) {
+ if (auto F = ParseDefinition()) {
+ if (auto M = IRGen(S, *F)) {
S.addPrototypeAST(llvm::make_unique<PrototypeAST>(*F->Proto));
+ J.addModule(std::move(M));
}
} else {
// Skip token for error recovery.
IRGenContext C(S);
if (auto ExprFunc = F->IRGen(C)) {
#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "Expression function:\n");
+ std::cerr << "Expression function:\n";
ExprFunc->dump();
#endif
// Add the CodeGen'd module to the JIT. Keep a handle to it: We can remove
auto H = J.addModule(C.takeM());
// Get the address of the JIT'd function in memory.
- uint64_t ExprFuncAddr = J.getSymbolAddress("__anon_expr");
+ auto ExprSymbol = J.findSymbol("__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)ExprFuncAddr;
+ double (*FP)() = (double (*)())(intptr_t)ExprSymbol.getAddress();
#ifdef MINIMAL_STDERR_OUTPUT
FP();
#else
- fprintf(stderr, "Evaluated to %f\n", FP());
+ std::cerr << "Evaluated to " << FP() << "\n";
#endif
// Remove the function.
while (1) {
#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "ready> ");
+ std::cerr << "ready> ";
#endif
switch (CurTok) {
case tok_eof: return;
// Prime the first token.
#ifndef MINIMAL_STDERR_OUTPUT
- fprintf(stderr, "ready> ");
+ std::cerr << "ready> ";
#endif
getNextToken();
+ std::cerr << std::fixed;
+
// Run the main "interpreter loop" now.
MainLoop();
projects / oota-llvm.git / blobdiff