Llvm - generate addition

In this case KaleidoscopeJIT stay ./llvm-8.0.1.src/examples/Kaleidoscope/include/KaleidoscopeJIT. in

1、LLVM Generating function
2、LVVM Generating addition
3、LLVM jit function

#include <sys/time.h>
#include "./llvm-8.0.1.src/examples/Kaleidoscope/include/KaleidoscopeJIT.h"
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/LegacyPassManager.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Verifier.h"
#include "llvm/Support/TargetSelect.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Transforms/InstCombine/InstCombine.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Transforms/Scalar/GVN.h"
#include <string>
#include <vector>
#include <iostream>
using namespace std;
using namespace llvm;
using namespace llvm::orc;

//LLVM items
static LLVMContext TheContext;
static IRBuilder<> Builder(TheContext);
static std::unique_ptr<Module> TheModule;
//JIT
static std::unique_ptr<KaleidoscopeJIT> TheJIT;



/* *double fuckadd(double a, double b) *{ * return a + b; *} * */
int main()
{
    
    InitializeNativeTarget();
    InitializeNativeTargetAsmPrinter();

    //init module
    TheModule = llvm::make_unique<Module>("myjit", TheContext);

    //used to be runned by jit later
    TheJIT = llvm::make_unique<KaleidoscopeJIT>();
    TheModule->setDataLayout(TheJIT->getTargetMachine().createDataLayout());

    //define the args
    vector<std::string> ArgNames;

    //fuckadd has 2 args
    ArgNames.push_back(string("a"));
    ArgNames.push_back(string("b"));

    //make the 2 args attach to LLVM Type::double
    std::vector<Type *> Doubles(ArgNames.size(), Type::getDoubleTy(TheContext));

    //generate llvm function type
    FunctionType *FT = FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);

    //Create function whose FunctionType is FT
    Function *F = Function::Create(FT, Function::ExternalLinkage, "fuckadd", TheModule.get());

    //give the name of Function args and save the args as innerargs
    unsigned Idx = 0;

    std::vector<Value *>innerargs;

    for (auto &Arg : F->args()) {
    
        Arg.setName(ArgNames[Idx++]);
        innerargs.push_back(&Arg);
    }

    //generate the function body
    BasicBlock *BB = BasicBlock::Create(TheContext, "entry", F);
    Builder.SetInsertPoint(BB);

    //generate llvm function body:a+b
    Value *ret = Builder.CreateFAdd(innerargs[0], innerargs[1], "addtmp");
    Builder.CreateRet(ret);

    //print LLVM IR
    F->print(errs());

    //using jit to run this code
    auto H = TheJIT->addModule(std::move(TheModule));
    auto ExprSymbol = TheJIT->findSymbol("fuckadd");
    double (*fuckadd)(double, double) = (double (*)(double, double))(intptr_t)cantFail(ExprSymbol.getAddress());
    std::cout<< fuckadd(1, 3) <<std::endl;
}