SEXP
R_cuCtxGetCurrent()
{
SEXP r_ans = R_NilValue;
CUcontext pctx;
CUresult ans;
ans = cuCtxGetCurrent(& pctx);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(pctx, "CUcontext") ;
return(r_ans);
}
SEXP R_clang_getIncludedFile(SEXP r_cursor)
{
SEXP r_ans = R_NilValue;
CXCursor cursor = * GET_REF(r_cursor, CXCursor);
CXFile ans;
ans = clang_getIncludedFile(cursor);
r_ans = R_createRef(ans, "CXFile") ;
return(r_ans);
}
SEXP
R_IRBuilder_CreateSIToFP(SEXP r_builder, SEXP r_val, SEXP r_type)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *val = GET_REF(r_val, Value);
llvm::Type *type = GET_REF(r_type, Type);
llvm::Value * ans = builder->CreateSIToFP(val, type);
return(R_createRef(ans, "Value"));
}
SEXP
R_auto_cuMemAllocHost(SEXP r_bytesize)
{
SEXP r_ans = R_NilValue;
void * pp;
size_t bytesize = REAL(r_bytesize)[0];
CUresult ans;
ans = cuMemAllocHost(& pp, bytesize);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(pp, "voidPtr") ;
return(r_ans);
}
SEXP
R_Function_clone(SEXP r_func)
{
llvm::Function *func = GET_REF(r_func, Function);
IdentityMapper VMap;
llvm::Function* duplicateFunction = llvm::CloneFunction(func, VMap,
/*ModuleLevelChanges=*/false);
func->getParent()->getFunctionList().push_back(duplicateFunction);
return(R_createRef(duplicateFunction, "Function"));
}
SEXP
R_auto_cuEventCreate(SEXP r_Flags)
{
SEXP r_ans = R_NilValue;
CUevent phEvent;
unsigned int Flags = REAL(r_Flags)[0];
CUresult ans;
ans = cuEventCreate(& phEvent, Flags);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(phEvent, "CUevent") ;
return(r_ans);
}
SEXP
R_auto_cuMemAlloc(SEXP r_bytesize)
{
SEXP r_ans = R_NilValue;
CUdeviceptr dptr;
size_t bytesize = REAL(r_bytesize)[0];
CUresult ans;
ans = cuMemAlloc(& dptr, bytesize);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef((void*) dptr, "CUdeviceptr") ;
return(r_ans);
}
SEXP
R_auto_cuModuleLoad(SEXP r_fname)
{
SEXP r_ans = R_NilValue;
CUmodule module;
const char * fname = CHAR(STRING_ELT(r_fname, 0));
CUresult ans;
ans = cuModuleLoad(& module, fname);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(module, "CUmodule") ;
return(r_ans);
}
SEXP
R_IRBuilder_CreateGlobalString(SEXP r_builder, SEXP r_val, SEXP r_id)
{
llvm::IRBuilder<> *builder;
llvm::Value *ans;
builder = GET_REF(r_builder, IRBuilder<>);
ans = builder->CreateGlobalString(llvm::StringRef(strdup(CHAR(STRING_ELT(r_val, 0)))));
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "Value"));
}
SEXP
R_IRBuilder_CreatePHI(SEXP r_builder, SEXP r_type, SEXP r_numReservedValues, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Type *type = GET_REF(r_type, Type);
llvm::PHINode *ret = builder->CreatePHI(type, INTEGER(r_numReservedValues)[0]);
if(Rf_length(r_id))
ret->setName(makeTwine(r_id));
return(R_createRef(ret, "PHINode"));
}
SEXP
R_IRBuilder_CreateUnwind(SEXP r_builder, SEXP r_id)
{
#if LLVM_VERSION > 2
PROBLEM "cannot (yet) create unwind instruction for this version of LLVM"
WARN;
return(R_NilValue);
#else
llvm::IRBuilder<> *builder;
llvm::UnwindInst *ans = builder->CreateUnwind();
return(R_createRef(ans, "UnwindInst"));
#endif
}
SEXP
R_IRBuilder_CreateStructGEP(SEXP r_builder, SEXP r_value, SEXP r_index, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *ans, *value;
value = GET_REF(r_builder, Value);
ans = builder->CreateStructGEP(NULL, value, INTEGER(r_index)[0]);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "Value"));
}
SEXP
R_auto_cuModuleLoadData(SEXP r_image)
{
SEXP r_ans = R_NilValue;
CUmodule module;
const void * image = GET_REF(r_image, const void );
CUresult ans;
ans = cuModuleLoadData(& module, image);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(module, "CUmodule") ;
return(r_ans);
}
SEXP
R_IRBuilder_CreateCondBr(SEXP r_builder, SEXP r_cond, SEXP r_true, SEXP r_false)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *cond = GET_REF(r_cond, Value);
llvm::BasicBlock *block1 = GET_REF(r_true, BasicBlock);
llvm::BasicBlock *block2 = GET_REF(r_false, BasicBlock);
llvm::BranchInst *ans = builder->CreateCondBr(cond, block1, block2);
return(R_createRef(ans, "BranchInst"));
}
SEXP
R_auto_cuModuleLoadFatBinary(SEXP r_fatCubin)
{
SEXP r_ans = R_NilValue;
CUmodule module;
const void * fatCubin = GET_REF(r_fatCubin, const void );
CUresult ans;
ans = cuModuleLoadFatBinary(& module, fatCubin);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(module, "CUmodule") ;
return(r_ans);
}
SEXP
R_Target_createTargetMachine(SEXP r_target, SEXP r_triple, SEXP r_cpu, SEXP r_features, SEXP r_opts)
{
const llvm::Target *tgt = GET_REF(r_target, Target);
// llvm::Module *mod = GET_REF(r_module, Module);
std::string triple(CHAR(STRING_ELT(r_triple, 0)));
llvm::TargetOptions *opts = NULL, defaultOpts;
llvm::TargetMachine *ans;
if(Rf_length(r_opts))
opts = GET_REF(r_opts, TargetOptions);
else {
/* taken from Halide's CodeGen.cpp */
defaultOpts.LessPreciseFPMADOption = true;
//defaultOpts.NoFramePointerElim = false;
#ifdef LLVM_HAS_NOFRAMEPOINTERELIMNONLEAF
defaultOpts.NoFramePointerElimNonLeaf = false;
#endif
defaultOpts.AllowFPOpFusion = llvm::FPOpFusion::Fast;
defaultOpts.UnsafeFPMath = true;
defaultOpts.NoInfsFPMath = true;
defaultOpts.NoNaNsFPMath = true;
defaultOpts.HonorSignDependentRoundingFPMathOption = false;
//defaultOpts.UseSoftFloat = false;
defaultOpts.FloatABIType = llvm::FloatABI::Soft;
defaultOpts.NoZerosInBSS = false;
defaultOpts.GuaranteedTailCallOpt = false;
//defaultOpts.DisableTailCalls = false;
defaultOpts.StackAlignmentOverride = 32;
#ifdef LLVM_HAS_REALIGNSTACK
defaultOpts.RealignStack = true;
#endif
//defaultOpts.TrapFuncName = "";
defaultOpts.PositionIndependentExecutable = true;
#if LLVM_VERSION == 3 && LLVM_MINOR_VERSION < 5
defaultOpts.EnableSegmentedStacks = false;
#endif
defaultOpts.UseInitArray = false;
#ifdef LLVM_HAS_SSPBUFFERSIZE
defaultOpts.SSPBufferSize = 0;
#endif
opts = &defaultOpts;
}
ans = tgt->createTargetMachine(triple, std::string(CHAR(STRING_ELT(r_cpu, 0))),
std::string(CHAR(STRING_ELT(r_features, 0))), *opts);
return(R_createRef(ans, "TargetMachine"));
}
SEXP
R_IRBuilder_CreateTrunc(SEXP r_builder, SEXP r_value, SEXP r_type, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *value = GET_REF(r_value, Value);
llvm::Type *type = GET_REF(r_type, Type);
llvm::Value *ans = builder->CreateTrunc(value, type);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "TruncInst"));
}
SEXP
R_IRBuilder_CreateCast(SEXP r_builder, SEXP r_op, SEXP r_lhs, SEXP r_type, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *lhs = GET_REF(r_lhs, Value);
llvm::Type *rhs = GET_REF(r_type, Type);
llvm::Value *ret = builder->CreateCast((llvm::Instruction::CastOps) INTEGER(r_op)[0], lhs, rhs);
if(Rf_length(r_id))
ret->setName(makeTwine(r_id));
return(R_createRef(ret, "Value"));
}
SEXP
R_new_BasicBlock(SEXP r_context, SEXP r_name, SEXP r_fun)
{
llvm::LLVMContext *context = GET_REF(r_context, LLVMContext);
llvm::Function *fun = GET_REF(r_fun, Function);
const char * name;
if(Rf_length(r_name))
name = CHAR(STRING_ELT(r_name, 0));
else
name = "";
llvm::BasicBlock *ans = llvm::BasicBlock::Create(*context, name, fun);
return(R_createRef(ans, "BasicBlock"));
}
SEXP
R_IRBuilder_CreateIsNotNull(SEXP r_builder, SEXP r_val, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *val = GET_REF(r_val, Value);
llvm::Value* ans = builder->CreateIsNotNull(val);
if(Rf_length(r_id))
ans->setName(makeTwine(r_id));
return(R_createRef(ans, "Value"));
}
SEXP
R_auto_cuModuleGetSurfRef(SEXP r_hmod, SEXP r_name)
{
SEXP r_ans = R_NilValue;
CUsurfref pSurfRef;
CUmodule hmod = (CUmodule) getRReference(r_hmod);
const char * name = CHAR(STRING_ELT(r_name, 0));
CUresult ans;
ans = cuModuleGetSurfRef(& pSurfRef, hmod, name);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(pSurfRef, "CUsurfref") ;
return(r_ans);
}
SEXP
R_IRBuilder_CreateFCmp(SEXP r_builder, SEXP r_op, SEXP r_lhs, SEXP r_rhs)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *lhs = GET_REF(r_lhs, Value);
llvm::Value *rhs = GET_REF(r_rhs, Value);
llvm::FCmpInst::Predicate op = (llvm::FCmpInst::Predicate) INTEGER(r_op)[0];
llvm::Value* ans = builder->CreateFCmp(op, lhs, rhs);
return(R_createRef(ans, "Value"));
}
SEXP
R_auto_cuMemHostAlloc(SEXP r_bytesize, SEXP r_Flags)
{
SEXP r_ans = R_NilValue;
void * pp;
size_t bytesize = REAL(r_bytesize)[0];
unsigned int Flags = REAL(r_Flags)[0];
CUresult ans;
ans = cuMemHostAlloc(& pp, bytesize, Flags);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(pp, "voidPtr") ;
return(r_ans);
}
SEXP
R_Module_getGlobalVariable(SEXP r_module, SEXP r_name, SEXP r_allowInternal)
{
llvm::Module *module;
module = GET_REF(r_module, Module);
llvm::GlobalVariable *var;
llvm::StringRef strRef(CHAR(STRING_ELT(r_name, 0)));
var = module->getGlobalVariable(strRef, LOGICAL(r_allowInternal)[0]);
if(!var)
return(R_NilValue);
return(R_createRef(var, "GlobalVariable"));
}
SEXP
R_new_Module(SEXP r_name, SEXP r_context)
{
llvm::Module *ans;
llvm::LLVMContext *context;
if(Rf_length(r_context))
context = (GET_REF(r_context, LLVMContext)); // llvm::cast<llvm::LLVMContext>
else
context = & llvm::getGlobalContext();
ans = new llvm::Module(CHAR(STRING_ELT(r_name, 0)), *context);
return(R_createRef(ans, "Module"));
}
SEXP
R_auto_cuMemHostGetDevicePointer(SEXP r_p, SEXP r_Flags)
{
SEXP r_ans = R_NilValue;
CUdeviceptr pdptr;
void * p = GET_REF(r_p, void );
unsigned int Flags = REAL(r_Flags)[0];
CUresult ans;
ans = cuMemHostGetDevicePointer(& pdptr, p, Flags);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef((void*) pdptr, "CUdeviceptr") ;
return(r_ans);
}
SEXP
R_cuCtxCreate(SEXP r_flags, SEXP r_dev)
{
SEXP r_ans = R_NilValue;
CUcontext pctx;
unsigned int flags = REAL(r_flags)[0];
int dev = INTEGER(r_dev)[0];
CUresult ans;
ans = cuCtxCreate(& pctx, flags, dev);
if(ans)
return(R_cudaErrorInfo(ans));
r_ans = R_createRef(pctx, "CUcontext") ;
return(r_ans);
}
SEXP
R_DIBuilder_CreateBasicType(SEXP r_builder,SEXP r_name, SEXP r_size, SEXP r_align, SEXP r_dwarf_type) {
llvm::DIBuilder *builder;
builder = GET_REF(r_builder, DIBuilder);
const char * name=CHAR(STRING_ELT(r_name, 0));
int size=asInteger(r_size);
int align=asInteger(r_align);
int dwarf_type=asInteger(r_dwarf_type);
llvm::DIType* ans = builder->createBasicType(llvm::StringRef(name), size, align, dwarf_type);
return(R_createRef(ans,"DIType"));
}
SEXP
R_llvm_ParseIRFile(SEXP r_content, SEXP r_inMemory, SEXP r_context)
{
llvm::Module *mod;
llvm::SMDiagnostic err;
llvm::LLVMContext *context;
if(Rf_length(r_context))
context = (GET_REF(r_context, LLVMContext)); // llvm::cast<llvm::LLVMContext>
else
context = & llvm::getGlobalContext();
std::string fn(CHAR(STRING_ELT(r_content, 0)));
if(LOGICAL(r_inMemory)[0]) {
llvm::MemoryBuffer *buf;
#if LLVM_VERSION == 3 && LLVM_MINOR_VERSION > 5
buf = llvm::MemoryBuffer::getMemBuffer(fn).get();
mod = llvm::parseIR(buf->getMemBufferRef(), err, *context).get();
#else
buf = llvm::MemoryBuffer::getMemBuffer(fn);
mod = llvm::ParseIR(buf, err, *context);
#endif
} else {
#if LLVM_VERSION == 3 && LLVM_MINOR_VERSION > 5
std::unique_ptr<llvm::Module> tmp;
tmp = llvm::parseIRFile(fn, err, *context);
mod = tmp.get();
tmp.reset(NULL);
// mod = llvm::parseIRFile(fn, err, *context).get();
#else
mod = llvm::ParseIRFile(fn, err, *context);
#endif
}
if(!mod) {
raiseError(err);
char msg[1000];
sprintf(msg, "(%d) %s", (int) strlen(err.getMessage().data()), err.getMessage().data());
msg[120] = '\0';
// Rprintf("%s", msg);
Rf_error(msg);
PROBLEM "failed to parse IR: (line = %d, col = %d) %s",
err.getLineNo(), err.getColumnNo(), msg
// err.getMessage().data() // c_str()
ERROR;
}
return(mod ? R_createRef(mod, "Module") : R_NilValue );
}
SEXP
R_IRBuilder_CreatePtrDiff(SEXP r_builder, SEXP r_lhs, SEXP r_rhs, SEXP r_id)
{
llvm::IRBuilder<> *builder;
builder = GET_REF(r_builder, IRBuilder<>);
llvm::Value *lhs = GET_REF(r_lhs, Value);
llvm::Value *rhs = GET_REF(r_rhs, Value);
llvm::Value *ret = builder->CreatePtrDiff(lhs, rhs);
if(Rf_length(r_id))
ret->setName(makeTwine(r_id));
return(R_createRef(ret, "PtrDiff"));
}
