xo-jit: + explicit env for captured function args [wip, not tested]
This commit is contained in:
parent
fdc5d46fd7
commit
d7192c1d97
7 changed files with 991 additions and 220 deletions
|
|
@ -1,6 +1,7 @@
|
|||
/* @file activation_record.cpp */
|
||||
|
||||
#include "activation_record.hpp"
|
||||
#include "type2llvm.hpp"
|
||||
#include "xo/indentlog/print/tag.hpp"
|
||||
#include <iostream>
|
||||
|
||||
|
|
@ -9,7 +10,29 @@ namespace xo {
|
|||
using std::cerr;
|
||||
using std::endl;
|
||||
|
||||
llvm::AllocaInst *
|
||||
activation_record::activation_record(const ref::rp<Lambda> & lm)
|
||||
: lambda_{lm},
|
||||
binding_v_(lm->n_arg())
|
||||
{
|
||||
/* populate binding_v_ */
|
||||
int n_arg = lm->n_arg();
|
||||
binding_v_.resize(n_arg);
|
||||
|
||||
/* next slot# to use in explicit activation record */
|
||||
int rt_env_slot = 0;
|
||||
|
||||
for (int i_arg = 0; i_arg < n_arg; ++i_arg) {
|
||||
if (lm->is_captured(lm->i_argname(i_arg))) {
|
||||
/* local param #i_arg needs a slot in explicit activation record */
|
||||
binding_v_[i_arg] = runtime_binding_path::local(rt_env_slot);
|
||||
++rt_env_slot;
|
||||
} else {
|
||||
binding_v_[i_arg] = runtime_binding_path::stackonly();
|
||||
}
|
||||
}
|
||||
} /*ctor*/
|
||||
|
||||
const runtime_binding_detail *
|
||||
activation_record::lookup_var(const std::string & x) const {
|
||||
|
||||
auto ix = frame_.find(x);
|
||||
|
|
@ -21,13 +44,12 @@ namespace xo {
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
return ix->second;
|
||||
return &(ix->second);
|
||||
} /*lookup_var*/
|
||||
|
||||
llvm::AllocaInst *
|
||||
activation_record::alloc_var(std::size_t j_slot,
|
||||
const std::string & x,
|
||||
llvm::AllocaInst * alloca)
|
||||
const runtime_binding_detail *
|
||||
activation_record::alloc_var(const std::string & x,
|
||||
const runtime_binding_detail & binding)
|
||||
{
|
||||
if (frame_.find(x) != frame_.end()) {
|
||||
cerr << "activation_record::alloc_var: variable x already present in frame"
|
||||
|
|
@ -36,14 +58,340 @@ namespace xo {
|
|||
return nullptr;
|
||||
}
|
||||
|
||||
if (j_slot >= binding_v_.size())
|
||||
binding_v_.resize(j_slot + 1);
|
||||
frame_[x] = binding;
|
||||
|
||||
binding_v_[j_slot] = runtime_binding_path::local(j_slot);
|
||||
|
||||
frame_[x] = alloca;
|
||||
return alloca;
|
||||
return &(frame_[x]);
|
||||
} /*alloc_var*/
|
||||
|
||||
/* in kaleidoscope7.cpp: CreateEntryBlockAlloca */
|
||||
runtime_binding_detail
|
||||
activation_record::create_entry_block_alloca(ref::brw<LlvmContext> llvm_cx,
|
||||
//const llvm::DataLayout & data_layout,
|
||||
llvm::Function * llvm_fn,
|
||||
llvm::IRBuilder<> & fn_ir_builder,
|
||||
int i_arg,
|
||||
const std::string & var_name,
|
||||
TypeDescr var_type)
|
||||
{
|
||||
constexpr bool c_debug_flag = true;
|
||||
using xo::scope;
|
||||
|
||||
scope log(XO_DEBUG(c_debug_flag),
|
||||
xtag("llvm_fn", (void*)llvm_fn),
|
||||
xtag("var_name", var_name),
|
||||
xtag("var_type", var_type->short_name()));
|
||||
|
||||
llvm::Type * llvm_var_type = type2llvm::td_to_llvm_type(llvm_cx,
|
||||
var_type);
|
||||
|
||||
log && log(xtag("addr(llvm_var_type)", (void*)llvm_var_type));
|
||||
if (log) {
|
||||
std::string llvm_var_type_str;
|
||||
llvm::raw_string_ostream ss(llvm_var_type_str);
|
||||
llvm_var_type->print(ss);
|
||||
|
||||
log(xtag("llvm_var_type", llvm_var_type_str));
|
||||
}
|
||||
|
||||
if (!llvm_var_type)
|
||||
return runtime_binding_detail{}; /*sentinel*/
|
||||
|
||||
llvm::AllocaInst * stackaddr = fn_ir_builder.CreateAlloca(llvm_var_type,
|
||||
nullptr,
|
||||
var_name);
|
||||
|
||||
log && log(xtag("alloca", (void*)stackaddr),
|
||||
xtag("align", stackaddr->getAlign().value())
|
||||
//xtag("size", retval->getAllocationSize(data_layout).value())
|
||||
);
|
||||
|
||||
return {i_arg, stackaddr, llvm_var_type};
|
||||
} /*create_entry_block_alloca*/
|
||||
|
||||
#ifdef NOT_USING
|
||||
llvm::AllocaInst *
|
||||
activation_record::create_runtime_localenv_alloca(ref::brw<LlvmContext> llvm_cx,
|
||||
//const llvm::DataLayout & data_layout,
|
||||
llvm::Function * llvm_fn,
|
||||
llvm::IRBuilder<> & ir_builder)
|
||||
|
||||
{
|
||||
constexpr bool c_debug_flag = true;
|
||||
using xo::scope;
|
||||
|
||||
scope log(XO_DEBUG(c_debug_flag),
|
||||
xtag("llvm_fn", (void*)llvm_fn));
|
||||
|
||||
llvm::StructType * localenv_llvm_type
|
||||
= type2llvm::create_localenv_llvm_type(llvm_cx, lambda_.borrow());
|
||||
|
||||
if (!localenv_llvm_type)
|
||||
return nullptr;
|
||||
|
||||
llvm::AllocaInst * retval = ir_builder.CreateAlloca(localenv_llvm_type,
|
||||
nullptr /*ArraySize*/,
|
||||
"_localenv");
|
||||
|
||||
log && log(xtag("alloca", (void*)retval),
|
||||
xtag("align", retval->getAlign().value())
|
||||
//xtag("size", retval->getAllocationSize(data_layout).value())
|
||||
);
|
||||
|
||||
return retval;
|
||||
} /*create_runtime_localenv_alloca*/
|
||||
#endif
|
||||
|
||||
llvm::Value *
|
||||
activation_record::runtime_localenv_slot_addr(ref::brw<LlvmContext> llvm_cx,
|
||||
llvm::StructType * localenv_llvm_type,
|
||||
llvm::AllocaInst * localenv_alloca,
|
||||
int i_slot,
|
||||
#ifdef NOT_HERE
|
||||
llvm::Value * llvm_slot_value,
|
||||
#endif
|
||||
llvm::IRBuilder<> & tmp_ir_builder)
|
||||
{
|
||||
llvm::Value * i32_slot
|
||||
= llvm::ConstantInt::get(llvm_cx->llvm_cx_ref(),
|
||||
llvm::APInt(32 /*bits*/,
|
||||
i_slot /*value*/));
|
||||
std::array<llvm::Value*,2> index_v = {
|
||||
{i32_slot /*environment slot #0*/}};
|
||||
|
||||
llvm::Value * llvm_localenv_slot_ptr
|
||||
= tmp_ir_builder.CreateInBoundsGEP(localenv_llvm_type,
|
||||
localenv_alloca,
|
||||
index_v);
|
||||
|
||||
return llvm_localenv_slot_ptr;
|
||||
|
||||
#ifdef NOT_HERE
|
||||
tmp_ir_builder.CreateStore(llvm_value, //llvm_0ptr,
|
||||
llvm_parent_env_ptr);
|
||||
#endif
|
||||
} /*runtime_localenv_slot_addr*/
|
||||
|
||||
bool
|
||||
activation_record::bind_locals(ref::brw<LlvmContext> llvm_cx,
|
||||
//const llvm::DataLayout & data_layout,
|
||||
llvm::Function * llvm_fn,
|
||||
llvm::IRBuilder<> & ir_builder)
|
||||
{
|
||||
constexpr bool c_debug_flag = true;
|
||||
using xo::scope;
|
||||
|
||||
scope log(XO_DEBUG(c_debug_flag),
|
||||
xtag("lambda-name", lambda_->name()));
|
||||
|
||||
llvm::IRBuilder<> tmp_ir_builder(&llvm_fn->getEntryBlock(),
|
||||
llvm_fn->getEntryBlock().begin());
|
||||
|
||||
/* 1st pass: handle stackonly variables
|
||||
*
|
||||
* We presume this must come first,
|
||||
* for subsequent mem2reg optimization pass to consider
|
||||
*/
|
||||
{
|
||||
int i_arg = 0;
|
||||
for (auto & arg : llvm_fn->args()) {
|
||||
std::string arg_name = std::string(arg.getName());
|
||||
|
||||
log && log("nested environment",
|
||||
xtag("i", i_arg),
|
||||
xtag("arg[i]", arg_name),
|
||||
xtag("stackonly(i)", binding_v_[i_arg].is_stackonly()));
|
||||
|
||||
if (binding_v_[i_arg].is_stackonly()) {
|
||||
/* stack location for arg[i] */
|
||||
runtime_binding_detail binding
|
||||
= create_entry_block_alloca(llvm_cx,
|
||||
//data_layout,
|
||||
llvm_fn,
|
||||
tmp_ir_builder,
|
||||
i_arg,
|
||||
arg_name,
|
||||
lambda_->fn_arg(i_arg));
|
||||
|
||||
if (!binding.llvm_addr_)
|
||||
return false;
|
||||
|
||||
/* store on function entry
|
||||
* see codegen_variable() for corresponding load
|
||||
*/
|
||||
ir_builder.CreateStore(&arg, binding.llvm_addr_);
|
||||
|
||||
/* remember stack location for reference + assignment
|
||||
* in lambda body.
|
||||
*
|
||||
*/
|
||||
this->alloc_var(arg_name, binding);
|
||||
}
|
||||
|
||||
++i_arg;
|
||||
}
|
||||
}
|
||||
|
||||
/* REMINDER: all functions need to follow the closure pattern,
|
||||
* to accomodate cases where we don't know until runtime
|
||||
* what kind of function we are invoking.
|
||||
*
|
||||
* This means:
|
||||
* - always represent function in IR by a closure-shaped object
|
||||
*
|
||||
* +-------+
|
||||
* | o---------> native function
|
||||
* +-------+
|
||||
* | o---------> runtime localenv
|
||||
* +-------+ (possibly nullptr)
|
||||
*
|
||||
* We hope to optimize away the closures in cases where we know
|
||||
* their contents at compile time
|
||||
*
|
||||
*/
|
||||
|
||||
/* 2nd pass: handle captured formal parameters */
|
||||
if (lambda_->needs_closure_flag()) {
|
||||
llvm::StructType * localenv_llvm_type
|
||||
= type2llvm::create_localenv_llvm_type(llvm_cx, lambda_.borrow());
|
||||
#ifdef NOT_USING
|
||||
llvm::PointerType * envapiptr_llvm_type
|
||||
= type2llvm::env_api_llvm_ptr_type(llvm_cx);
|
||||
#endif
|
||||
|
||||
if (!localenv_llvm_type)
|
||||
return false;
|
||||
|
||||
/*
|
||||
* runtime localenv: ^
|
||||
* | parent
|
||||
* +-------+ |
|
||||
* parent_env [0] | o-------/
|
||||
* +-------+
|
||||
* unwind_fn [1] | o-------> env * (*)(env*, ctl)
|
||||
* +-------+
|
||||
* arg[i] [2+i] . ... .
|
||||
* . ... .
|
||||
* +-------+
|
||||
*
|
||||
* ctl=0 unwind. finalization for any arg[i] that requires it.
|
||||
* returns nullptr
|
||||
* ctl=1 copy. copy runtime environment to heap destination
|
||||
* and return address of the copy
|
||||
*
|
||||
* arg[] comprises the subset of lambda arg names arg[j] for which
|
||||
* lambda->is_captured(arg[j]) is true
|
||||
*/
|
||||
llvm::AllocaInst * localenv_alloca
|
||||
= tmp_ir_builder.CreateAlloca(localenv_llvm_type,
|
||||
nullptr /*ArraySize*/,
|
||||
"_localenv");
|
||||
|
||||
if (!localenv_alloca)
|
||||
return false;
|
||||
|
||||
/* remember environemnt location.
|
||||
* Will need this if need to copy-to-stack
|
||||
*/
|
||||
this->localenv_alloca_ = localenv_alloca;
|
||||
|
||||
int i_localenv_slot = 0;
|
||||
|
||||
/* store localenv->parent_env */
|
||||
{
|
||||
llvm::Value * slot_addr
|
||||
= runtime_localenv_slot_addr(llvm_cx,
|
||||
localenv_llvm_type,
|
||||
localenv_alloca,
|
||||
i_localenv_slot,
|
||||
//llvm_0ptr,
|
||||
tmp_ir_builder);
|
||||
|
||||
if (!slot_addr)
|
||||
return false;
|
||||
|
||||
++i_localenv_slot;
|
||||
|
||||
/* null pointer for now */
|
||||
/* TODO: get parent environment (from runtime closure created for this function) */
|
||||
llvm::Value * llvm_0ptr
|
||||
= llvm::ConstantPointerNull::get(type2llvm::env_api_llvm_ptr_type(llvm_cx));
|
||||
|
||||
tmp_ir_builder.CreateStore(llvm_0ptr,
|
||||
slot_addr);
|
||||
}
|
||||
|
||||
/* store localenv->unwind_fn */
|
||||
{
|
||||
llvm::Value * slot_addr
|
||||
= runtime_localenv_slot_addr(llvm_cx,
|
||||
localenv_llvm_type,
|
||||
localenv_alloca,
|
||||
i_localenv_slot,
|
||||
//llvm_0ptr,
|
||||
tmp_ir_builder);
|
||||
|
||||
if (!slot_addr)
|
||||
return false;
|
||||
|
||||
++i_localenv_slot;
|
||||
|
||||
/* null function pointer for now */
|
||||
/* TODO: construct unwind function */
|
||||
llvm::Value * llvm_0ptr
|
||||
= (llvm::ConstantPointerNull::get
|
||||
(type2llvm::require_localenv_unwind_llvm_fnptr_type(llvm_cx)));
|
||||
|
||||
tmp_ir_builder.CreateStore(llvm_0ptr,
|
||||
slot_addr);
|
||||
}
|
||||
|
||||
int i_arg = 0;
|
||||
|
||||
for (llvm::Argument & arg : llvm_fn->args()) {
|
||||
std::string arg_name = std::string(arg.getName());
|
||||
|
||||
log && log("nested environment",
|
||||
xtag("i", i_arg),
|
||||
xtag("arg[i]", arg_name),
|
||||
xtag("captured(i)", binding_v_[i_arg].is_captured()));
|
||||
|
||||
if (binding_v_[i_arg].is_captured()) {
|
||||
// do something with runtime-local-env for this llvm_fn
|
||||
|
||||
/* remember stack location for reference + assignment
|
||||
* in lambda body.
|
||||
*
|
||||
*/
|
||||
|
||||
TypeDescr arg_td = lambda_->fn_arg(i_arg);
|
||||
|
||||
llvm::Type * llvm_var_type = type2llvm::td_to_llvm_type(llvm_cx, arg_td);
|
||||
|
||||
llvm::Value * slot_addr
|
||||
= runtime_localenv_slot_addr(llvm_cx,
|
||||
localenv_llvm_type,
|
||||
localenv_alloca,
|
||||
i_localenv_slot,
|
||||
tmp_ir_builder);
|
||||
|
||||
if (!slot_addr)
|
||||
return false;
|
||||
|
||||
++i_localenv_slot;
|
||||
|
||||
tmp_ir_builder.CreateStore(&arg, slot_addr);
|
||||
|
||||
runtime_binding_detail binding = { i_arg, slot_addr, llvm_var_type };
|
||||
|
||||
this->alloc_var(arg_name, binding);
|
||||
}
|
||||
|
||||
++i_arg;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
} /*bind_locals*/
|
||||
} /*namespace jit*/
|
||||
} /*namespace xo*/
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue