+#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Analysis/Passes.h"
#include "llvm/ExecutionEngine/ExecutionEngine.h"
#include "llvm/ExecutionEngine/MCJIT.h"
#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/IR/DIBuilder.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DerivedTypes.h"
-#include "llvm/IR/DIBuilder.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/Host.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Transforms/Scalar.h"
#include <cctype>
#include <cstdio>
+#include <iostream>
#include <map>
#include <string>
#include <vector>
-#include <iostream>
using namespace llvm;
//===----------------------------------------------------------------------===//
public:
NumberExprAST(double val) : Val(val) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
return ExprAST::dump(out << Val, ind);
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// VariableExprAST - Expression class for referencing a variable, like "a".
VariableExprAST(SourceLocation Loc, const std::string &name)
: ExprAST(Loc), Name(name) {}
const std::string &getName() const { return Name; }
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
return ExprAST::dump(out << Name, ind);
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// UnaryExprAST - Expression class for a unary operator.
public:
UnaryExprAST(char opcode, ExprAST *operand)
: Opcode(opcode), Operand(operand) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "unary" << Opcode, ind);
Operand->dump(out, ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// BinaryExprAST - Expression class for a binary operator.
public:
BinaryExprAST(SourceLocation Loc, char op, ExprAST *lhs, ExprAST *rhs)
: ExprAST(Loc), Op(op), LHS(lhs), RHS(rhs) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "binary" << Op, ind);
LHS->dump(indent(out, ind) << "LHS:", ind + 1);
RHS->dump(indent(out, ind) << "RHS:", ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// CallExprAST - Expression class for function calls.
CallExprAST(SourceLocation Loc, const std::string &callee,
std::vector<ExprAST *> &args)
: ExprAST(Loc), Callee(callee), Args(args) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "call " << Callee, ind);
for (ExprAST *Arg : Args)
Arg->dump(indent(out, ind + 1), ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// IfExprAST - Expression class for if/then/else.
public:
IfExprAST(SourceLocation Loc, ExprAST *cond, ExprAST *then, ExprAST *_else)
: ExprAST(Loc), Cond(cond), Then(then), Else(_else) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "if", ind);
Cond->dump(indent(out, ind) << "Cond:", ind + 1);
Then->dump(indent(out, ind) << "Then:", ind + 1);
Else->dump(indent(out, ind) << "Else:", ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// ForExprAST - Expression class for for/in.
ForExprAST(const std::string &varname, ExprAST *start, ExprAST *end,
ExprAST *step, ExprAST *body)
: VarName(varname), Start(start), End(end), Step(step), Body(body) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "for", ind);
Start->dump(indent(out, ind) << "Cond:", ind + 1);
End->dump(indent(out, ind) << "End:", ind + 1);
Body->dump(indent(out, ind) << "Body:", ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// VarExprAST - Expression class for var/in
ExprAST *body)
: VarNames(varnames), Body(body) {}
- virtual std::ostream &dump(std::ostream &out, int ind) {
+ std::ostream &dump(std::ostream &out, int ind) override {
ExprAST::dump(out << "var", ind);
for (const auto &NamedVar : VarNames)
NamedVar.second->dump(indent(out, ind) << NamedVar.first << ':', ind + 1);
Body->dump(indent(out, ind) << "Body:", ind + 1);
return out;
}
- virtual Value *Codegen();
+ Value *Codegen() override;
};
/// PrototypeAST - This class represents the "prototype" for a function,
}
static DICompositeType CreateFunctionType(unsigned NumArgs, DIFile Unit) {
- SmallVector<Value *, 8> EltTys;
+ SmallVector<Metadata *, 8> EltTys;
DIType DblTy = KSDbgInfo.getDoubleTy();
// Add the result type.
static Module *TheModule;
static std::map<std::string, AllocaInst *> NamedValues;
-static FunctionPassManager *TheFPM;
+static legacy::FunctionPassManager *TheFPM;
Value *ErrorV(const char *Str) {
Error(Str);
CreateFunctionType(Args.size(), Unit), false /* internal linkage */,
true /* definition */, ScopeLine, DIDescriptor::FlagPrototyped, false, F);
- KSDbgInfo.FnScopeMap[this] = SP;
+ KSDbgInfo.FnScopeMap[this] = (DIScope)SP;
return F;
}
// Create the JIT. This takes ownership of the module.
std::string ErrStr;
- TheExecutionEngine = EngineBuilder(std::move(Owner))
- .setErrorStr(&ErrStr)
- .setMCJITMemoryManager(new SectionMemoryManager())
- .create();
+ TheExecutionEngine =
+ EngineBuilder(std::move(Owner))
+ .setErrorStr(&ErrStr)
+ .setMCJITMemoryManager(llvm::make_unique<SectionMemoryManager>())
+ .create();
if (!TheExecutionEngine) {
fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
exit(1);
}
- FunctionPassManager OurFPM(TheModule);
+ legacy::FunctionPassManager OurFPM(TheModule);
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
- TheModule->setDataLayout(TheExecutionEngine->getDataLayout());
- OurFPM.add(new DataLayoutPass());
+ TheModule->setDataLayout(*TheExecutionEngine->getDataLayout());
#if 0
// Provide basic AliasAnalysis support for GVN.
OurFPM.add(createBasicAliasAnalysisPass());