cpps_jit_codegen.cpp

#include "cpps_jit_codegen.h"



cpps_jit_codegen::cpps_jit_codegen() {
    __context = NULL;
}

cpps_jit_codegen::~cpps_jit_codegen()
{
    if (__context) {
        delete __context;
        __context = NULL;
    }
}

void cpps::cpps_jit_codegen::init() {

    passBuilder.registerModuleAnalyses(moduleAnalysisManager);
    passBuilder.registerCGSCCAnalyses(cGSCCAnalysisManager);
    passBuilder.registerFunctionAnalyses(functionAnalysisManager);
    passBuilder.registerLoopAnalyses(loopAnalysisManager);

    // This is the important line:
    passBuilder.crossRegisterProxies(
        loopAnalysisManager, functionAnalysisManager, cGSCCAnalysisManager, moduleAnalysisManager);

}

ThreadSafeModule cpps::cpps_jit_codegen::build(cpps_jit_data* __moduledata, std::string& __funcname, cpps::C* c, cpps::cpps_domain* domain, cpps::node* _params, cpps::node* _context) {
    auto context = std::make_unique<LLVMContext>();
    IRBuilder<> builder(*context);
    // Create a module
    auto module = std::make_unique<Module>(__funcname, *context);

    __moduledata->object_structType = StructType::create(*context, "object");
    std::vector<Type*> elements;
    elements.push_back(Type::getInt8Ty(*context));
    elements.push_back(Type::getInt64Ty(*context));
    __moduledata->object_structType->setBody(elements);

    std::vector<Constant*> ele_vec;
    ele_vec.push_back(ConstantInt::get(Type::getInt64Ty(*context), 0));
    ele_vec.push_back(ConstantInt::get(Type::getInt64Ty(*context), 0));
    __moduledata->object_nil = ConstantStruct::get(__moduledata->object_structType, ele_vec);


    // Create a function that looks like:
    //   int Add(int a, int b)
    std::vector<Type*> parameters(3, builder.getInt8PtrTy());
    FunctionType* functionType = FunctionType::get(builder.getInt64Ty(), parameters, false);
    Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, __funcname.c_str(), module.get());
    // Set arguments for the function
    function->getArg(0)->setName("c");
    function->getArg(1)->setName("domain");
    function->getArg(2)->setName("stack");

    // Create a block in the function
    BasicBlock* block = BasicBlock::Create(*context, "entry", function);
    builder.SetInsertPoint(block);

    // Create a new pass manager attached to it.

    Value* _c = function->getArg(0);
    Value* _domain = function->getArg(1);
    Value* _stack = function->getArg(2);

    //1.±äÁ¿Ñ¹½ø¶Ñ
    std::vector<Value*> __func_var_list;
    varname_map         __func_var_map;

    cpps_jit_builder_runtime runtime = {
        __moduledata,context,builder,c,domain,_c,_domain,_stack,NULL,&__func_var_map,&__func_var_list,function,create_object(SET_DEFAULT_VARS),create_object(SET_DEFAULT_VARS)
    };


    Value* _leftdomain = create_object(SET_DEFAULT_VARS);
    runtime._leftdomain = _leftdomain;



    if (domain->getidxvarcount() != 0) __func_var_list.resize((size_t)domain->getidxvarcount());
    size_t _stack_index = 0;
    for (size_t i = 0; i < _params->l.size(); i++)
    {

        node* d = _params->l[i];
        node* varname = d->l[0];
        if (varname->type == CPPS_VARNAME)
        {
            Value* bPtr = create_object(SET_DEFAULT_VARS);// builder.CreateAlloca(builder.getPtrTy(sizeof(cpps::object)), nullptr, varname->s);
            bPtr->setName(varname->s);
            //__func_var_list[_stack_index++] = bPtr;
            //__func_var_map[varname->s] = bPtr;

            if (varname->offsettype == CPPS_OFFSET_TYPE_SELF)
            {
                func_regvar(SET_DEFAULT_VARS, varname, bPtr);
                //funcdomain.regidxvar(varname->offset, v);
            }

        }
    }

    dump(_context);
    gen(SET_DEFAULT_VARS, _context);


    Value* result = builder.getInt64(0);
    builder.CreateRet(result);

    // Print the IR
    verifyFunction(*function);
    module->print(outs(), nullptr);

    //optimize_func(function);

    ModulePassManager MPM = passBuilder.buildModuleOptimizationPipeline(OptimizationLevel::O3, llvm::ThinOrFullLTOPhase::None);

    // Optimize the IR!

    MPM.run(*module, moduleAnalysisManager);

    module->print(outs(), nullptr);



    return ThreadSafeModule(std::move(module), std::move(context));
}


void cpps::cpps_jit_codegen::optimize_func(Function* F)
{

    auto FPM2 = passBuilder.buildFunctionSimplificationPipeline(llvm::OptimizationLevel::O2,llvm::ThinOrFullLTOPhase::None);
   /* FPM2.addPass(createPromoteMemoryToRegisterPass());
    FPM2.addPass(createInstructionCombiningPass());
    FPM2.addPass(createReassociatePass());
    FPM2.addPass(createGVNPass());
    FPM2.addPass(createCFGSimplificationPass());*/

    // Run the optimizations over all functions in the module being added to
    // the JIT.
    FPM2.run(*F, functionAnalysisManager);

}
ThreadSafeModule cpps::cpps_jit_codegen::optimize_module(ThreadSafeModule TSM)
{
    TSM.withModuleDo([](Module& M) {


        // Create a function pass manager.
        auto FPM = std::make_unique<legacy::FunctionPassManager>(&M);

        // Add some optimizations.
        FPM->add(createPromoteMemoryToRegisterPass());
        FPM->add(createInstructionCombiningPass());
        FPM->add(createReassociatePass());
        FPM->add(createGVNPass());
        FPM->add(createCFGSimplificationPass());
        FPM->doInitialization();
        // Run the optimizations over all functions in the module being added to
        // the JIT.
        for (auto& F : M)
            FPM->run(F);

        



        });

    return std::move(TSM);
}
int32 cpps::cpps_jit_codegen::compile(cpps_jit_data* __moduledata, cpps::C* c, cpps::cpps_domain* domain, cpps::node* _params, cpps::node* _context) {
    ExitOnError ExitOnErr;
    std::string __func_name = cpps_jit_buildlambda(c);
    auto __module = build(__moduledata, __func_name, c, domain, _params, _context);
   /* auto __module2 = optimize_module(std::move(__module));

    __module2.getModuleUnlocked()->print(outs(), nullptr);*/

    ExitOnErr(__moduledata->jit->addIRModule(std::move(__module)));
    auto functionSymbol = ExitOnErr(__moduledata->jit->lookup(__func_name.c_str()));
    __context = new (_cpps_jit_context)();
    __context->__func = (AddFunctionType)functionSymbol.getValue();
    return 0;
}

void cpps::cpps_jit_codegen::gen(DEFAULT_VARS, cpps::node* _context) {
    for (size_t i = 0; i < _context->l.size(); i++) {
        node* _step = _context->l[i];
        if (_step == NULL) continue;
        step(SET_DEFAULT_VARS, _step);
    }
}

void cpps::cpps_jit_codegen::step(DEFAULT_VARS, cpps::node* _step)
{
    switch (_step->type) {
    case CPPS_OEXPRESSION:
    {
        expression(SET_DEFAULT_VARS, _step->getleft());
        break;
    }
    case CPPS_ODEFVAR:
    {
        createvar(SET_DEFAULT_VARS, _step);
        break;
    }
    case CPPS_OIF:
    {
        Value* if_value = create_object(SET_DEFAULT_VARS);
        expression(SET_DEFAULT_VARS, _step->l[0]->l[0], if_value);
        BasicBlock* thenBlock = BasicBlock::Create(*runtime.context, "if.then", runtime.function);
        BasicBlock* elseBlock = BasicBlock::Create(*runtime.context, "if.else", runtime.function);
        BasicBlock* returnBlock = BasicBlock::Create(*runtime.context, "if.end", runtime.function);

        Value* condition = cpps_jit_to_bool(SET_DEFAULT_VARS, if_value);
        //if(tobool(if_value))
        runtime.builder.CreateCondBr(condition, thenBlock, elseBlock);
        runtime.builder.SetInsertPoint(thenBlock);
        //{
        if (!_step->l[1]->l.empty()) gen(SET_DEFAULT_VARS, _step->l[1]);

        //}
        runtime.builder.CreateBr(returnBlock);

        //else
        runtime.builder.SetInsertPoint(elseBlock);
        //{
        if (!_step->l[2]->l.empty()) gen(SET_DEFAULT_VARS, _step->l[2]);
        //}
        runtime.builder.CreateBr(returnBlock);

        runtime.builder.SetInsertPoint(returnBlock); //end if


        break;
    }
    case CPPS_OFOREACH:
    {
        node* for1 = _step->l[0];
        node* for2 = _step->l[1];
        node* for4 = _step->l[2];
        //1.map
        // auto it = object::map(v)::begin();
        // auto end = object::map(v)::end();
        // int8 type = 1;
        // while( condition(it , end, i)){
        //   ..dosomthing.
        //   inc(it,type);
        // }
        //2.vector
        //3.set
        //4.range


        BasicBlock* forConditionBlock = BasicBlock::Create(*runtime.context, "for.condition", runtime.function);
        BasicBlock* forBodyBlock = BasicBlock::Create(*runtime.context, "for.body", runtime.function);
        BasicBlock* forIncrementBlock = BasicBlock::Create(*runtime.context, "for.increment", runtime.function);
        BasicBlock* forEndBlock = BasicBlock::Create(*runtime.context, "for.end", runtime.function);
        Value* _iPtr = foreach_createvar(SET_DEFAULT_VARS, for1);
        Value* itPtr = create_object(SET_DEFAULT_VARS);
        Value* endPtr = create_object(SET_DEFAULT_VARS);
        Value* vPtr = create_object(SET_DEFAULT_VARS);
        expression(SET_DEFAULT_VARS, for2->l[0], vPtr);
        Value* typePtr = cpps_jit_foreach_type(SET_DEFAULT_VARS, vPtr);
        cpps_jit_foreach_begin(SET_DEFAULT_VARS, vPtr, itPtr, _iPtr, typePtr);
        cpps_jit_foreach_end(SET_DEFAULT_VARS, vPtr, endPtr, typePtr);


        runtime.builder.CreateBr(forConditionBlock);

        runtime.builder.SetInsertPoint(forConditionBlock);

        Value* forConditionCompare = cpps_jit_foreach_condition(SET_DEFAULT_VARS, vPtr, itPtr, endPtr, typePtr);

        runtime.builder.CreateCondBr(forConditionCompare, forBodyBlock, forEndBlock);


        runtime.builder.SetInsertPoint(forBodyBlock);
        //body
        cpps_jit_foreach_set_value(SET_DEFAULT_VARS, itPtr, _iPtr, typePtr);


        if (!for4->l.empty()) gen(SET_DEFAULT_VARS, for4);

        runtime.builder.CreateBr(forIncrementBlock);

        runtime.builder.SetInsertPoint(forIncrementBlock);
        //inc
        cpps_jit_foreach_inc(SET_DEFAULT_VARS, itPtr, typePtr);

        runtime.builder.CreateBr(forConditionBlock);


        runtime.builder.SetInsertPoint(forEndBlock);

        break;
    }
    case CPPS_OFOR:
    {

        node* for1 = _step->l[0];
        node* for2 = _step->l[1];
        node* for3 = _step->l[2];
        node* for4 = _step->l[3];

        //BasicBlock* forConditionBlock = BasicBlock::Create(*runtime.context, "for.condition", runtime.function);
        //BasicBlock* forBodyBlock = BasicBlock::Create(*runtime.context, "for.body", runtime.function);
        //BasicBlock* forIncrementBlock = BasicBlock::Create(*runtime.context, "for.increment", runtime.function);
        //BasicBlock* forEndBlock = BasicBlock::Create(*runtime.context, "for.end", runtime.function);

        //Value* iPtr = cpps_jit_createvar(SET_DEFAULT_VARS, for1);
        //runtime.builder.CreateBr(forConditionBlock);

        //runtime.builder.SetInsertPoint(forConditionBlock);

        //Value* forConditionCompare = cpps_jit_to_bool(SET_DEFAULT_VARS, if_value);

        //runtime.builder.CreateCondBr(forConditionCompare, forBodyBlock, forEndBlock);


        //runtime.builder.SetInsertPoint(forBodyBlock);
        ////body
        //runtime.builder.CreateBr(forIncrementBlock);

        //runtime.builder.SetInsertPoint(forIncrementBlock);
        ////inc
        //runtime.builder.CreateBr(forConditionBlock);


        //runtime.builder.SetInsertPoint(forEndBlock);


        // Add some basic blocks to the function
        BasicBlock* forConditionBlock = BasicBlock::Create(*runtime.context, "for.condition", runtime.function);
        BasicBlock* forBodyBlock = BasicBlock::Create(*runtime.context, "for.body", runtime.function);
        BasicBlock* forIncrementBlock = BasicBlock::Create(*runtime.context, "for.increment", runtime.function);
        BasicBlock* forEndBlock = BasicBlock::Create(*runtime.context, "for.end", runtime.function);


        // Fill the "entry" block (1):
        //   int b = 0;

        // Fill the "entry" block (2):
        //   for (int i = 0; ...)
        Value* iPtr = runtime.builder.CreateAlloca(runtime.builder.getInt64Ty(), nullptr, "i.address");
        runtime.builder.CreateStore(runtime.builder.getInt64(0), iPtr);

        Value* a = runtime.builder.CreateAlloca(runtime.builder.getInt64Ty(), nullptr, "a.address");
        runtime.builder.CreateStore(runtime.builder.getInt64(100000000), a);

        runtime.builder.CreateBr(forConditionBlock);

        // Fill the "for.condition" block:
        //   for (... i < a; ...)
        runtime.builder.SetInsertPoint(forConditionBlock);
        Value* i0 = runtime.builder.CreateLoad(runtime.builder.getInt64Ty(), iPtr);
        Value* i1 = runtime.builder.CreateLoad(runtime.builder.getInt64Ty(), a);
        Value* forConditionCompare = runtime.builder.CreateICmpSLT(i0, i1, "for.condition.compare.result");
        runtime.builder.CreateCondBr(forConditionCompare, forBodyBlock, forEndBlock);

        // Fill the "for.body" block:
        //   b = b + i;
        runtime.builder.SetInsertPoint(forBodyBlock);

        if (!for4->l.empty()) gen(SET_DEFAULT_VARS, for4);

        runtime.builder.CreateBr(forIncrementBlock);

        // Fill the "for.increment" block:
        //   for (... i++)
        runtime.builder.SetInsertPoint(forIncrementBlock);
        Value* i2 = runtime.builder.CreateLoad(runtime.builder.getInt64Ty(), iPtr);
        Value* incrementedI = runtime.builder.CreateAdd(i2, runtime.builder.getInt64(1), "i.incremented");
        runtime.builder.CreateStore(incrementedI, iPtr);
        runtime.builder.CreateBr(forConditionBlock);

        // Fill the "for.end" block:
        //   return b;
        runtime.builder.SetInsertPoint(forEndBlock);

        break;
    }
    }
}

void cpps::cpps_jit_codegen::run(cpps::C* c, cpps::cpps_domain* domain, cpps::cpps_stack* stack) {
    __context->__func(c, domain, stack);
}

void cpps::cpps_jit_codegen::expression(DEFAULT_VARS, node* _exp, Value* ret)
{
    switch (_exp->type) {
    case CPPS_ODOFUNCTION:
    {
        node* _funcname = _exp->getleft();
        node* _params = _exp->getright();

        Value* _func = runtime.temp_func;
        expression(SET_DEFAULT_VARS, _funcname, _func);
        Value* _args = NULL;
        _args = DEF_OBJECT_ARRAY(_params->l.size() == 0 ? 1 : _params->l.size());

        for (uint64_t i = 0; i < _params->l.size(); i++) {
            node* _p = _params->l[i];
            Value* _v = OBJECT_ARRAY(_args, i);
            Value* _vv = create_object(SET_DEFAULT_VARS);
            expression(SET_DEFAULT_VARS, _p, _vv);
            cpps_jit_set_value(SET_DEFAULT_VARS, _v, _vv, BOOLVALUE(SET_DEFAULT_VARS, true));
        }

        if (ret == NULL)
            cpps_jit_function_caller(SET_DEFAULT_VARS, _func, _args, INTVALUE(SET_DEFAULT_VARS, _params->l.size()));
        else
            cpps_jit_function_caller_ret(SET_DEFAULT_VARS, _func, _args, INTVALUE(SET_DEFAULT_VARS, _params->l.size()), ret);

        break;
    }
    case CPPS_VARNAME:
    {
        Value* _varname = runtime.builder.CreateGlobalStringPtr(_exp->s);
        cpps_jit_try_get_Var(SET_DEFAULT_VARS, _varname, ret);
        break;
    }
    case CPPS_OINTEGER16:
    case CPPS_OINTEGER:
    {
        Value* v = INTVALUE(SET_DEFAULT_VARS, _exp->value.integer);
        cpps_jit_set_value_integer(SET_DEFAULT_VARS, ret, v);
        break;
    }
    case CPPS_OUINTEGER:
    {
        Value* v = INTVALUE(SET_DEFAULT_VARS, _exp->value.uinteger);
        cpps_jit_set_value_uinteger(SET_DEFAULT_VARS, ret, v);
        break;
    }
    case CPPS_ONUMBER:
    {
        Value* v = NUMBERVALUE(SET_DEFAULT_VARS, _exp->value.number);
        cpps_jit_set_value_number(SET_DEFAULT_VARS, ret, v);
        break;
    }
    case CPPS_OBOOL:
    {
        Value* v = BOOLVALUE(SET_DEFAULT_VARS, _exp->s[0] == 't');
        cpps_jit_set_value_bool(SET_DEFAULT_VARS, ret, v);
        break;
    }
    case CPPS_QUOTEOFFSET:
    case CPPS_OOFFSET:
    {
        if (_exp->offsettype == CPPS_OFFSET_TYPE_SELF) {
            Value* v = runtime.__func_var_list->at(_exp->offset);
            //ÔÝʱû´¦Àíconst
            cpps_jit_set_value(SET_DEFAULT_VARS, ret, v, BOOLVALUE(SET_DEFAULT_VARS, true));
        }
        break;
    }
    case CPPS_FUNCNAME:
    {
        node* _tmp = _exp->l[0];
        node* _tmp2 = _exp->l.size() > 1 ? _exp->l[1] : NULL;
        Value* a = runtime.temp_func;
        expression(SET_DEFAULT_VARS, _tmp, a);
        if (ret == NULL) {
            ret = runtime.non_ret;
        }
        switch (_exp->symbol->symboltype)
        {
        case CPPS_SYMBOL_TYPE_RIGHTAUTOINCREASE:
        {
            cpps_jit_symbol_rightautoincrease(SET_DEFAULT_VARS, a, ret);
            break;
        }
        case CPPS_SYMBOL_TYPE_EQUEL:
        {
            Value* b = create_object(SET_DEFAULT_VARS);
            expression(SET_DEFAULT_VARS, _tmp2, b);
            cpps_jit_symbol_equel(SET_DEFAULT_VARS, a, b, ret);

            break;
        }
        case CPPS_SYMBOL_TYPE_SUBTRACT:
        {
            Value* b = create_object(SET_DEFAULT_VARS);
            expression(SET_DEFAULT_VARS, _tmp2, b);
            cpps_jit_symbol_subtract(SET_DEFAULT_VARS, a, b, ret);
            break;
        }
        default:
            break;
        }

        break;
    }
    }
}

void cpps::cpps_jit_codegen::func_regvar(DEFAULT_VARS, node* var, Value* v)
{
    if (var->offsettype == CPPS_OFFSET_TYPE_SELF)
        (*runtime.__func_var_list)[var->offset] = v;
    (*runtime.__func_var_map)[var->s] = v;
}

Value* cpps::cpps_jit_codegen::createvar(DEFAULT_VARS, cpps::node* _step)
{
    Value* _first = NULL;
    for (size_t i = 0; i < _step->l.size(); ++i) {
        node* varName = _step->l[i];
        if (varName->type == CPPS_MULTIVAR) {

        }
        else if (varName->type == CPPS_VARNAME) {
            node* var = varName->getleft();
            if (var && (var->type == CPPS_ODEFVAR_VAR || var->type == CPPS_ODEFVAR_NIL)) {
                Value* v = create_object(SET_DEFAULT_VARS);
                v->setName(varName->s);
                func_regvar(SET_DEFAULT_VARS, varName, v);
                if (_first == NULL) _first = v;
                //const  -- ??
                //closeure -- ??
                if (var->type == CPPS_ODEFVAR_VAR) {
                    Value* _value = create_object(SET_DEFAULT_VARS);
                    expression(SET_DEFAULT_VARS, var->l[0], _value);
                    if (varName->quote) {
                        cpps_jit_set_value(SET_DEFAULT_VARS, v, _value, BOOLVALUE(SET_DEFAULT_VARS, varName->quote));
                    }
                    else {
                        cpps_jit_set_value(SET_DEFAULT_VARS, v, _value, BOOLVALUE(SET_DEFAULT_VARS, varName->quote));
                    }
                }
            }
        }
    }
    return _first;
}

Value* cpps::cpps_jit_codegen::foreach_createvar(DEFAULT_VARS, cpps::node* _step) {
    Value* _first = NULL;
    for (auto _n : _step->l) {
        Value* _take = createvar(SET_DEFAULT_VARS, _n);
        if (_first == NULL) _first = _take;
    }
    return _first;
}