LLVMModuleRef ac_create_module(LLVMTargetMachineRef tm, LLVMContextRef ctx)
{
llvm::TargetMachine *TM = reinterpret_cast<llvm::TargetMachine*>(tm);
LLVMModuleRef module = LLVMModuleCreateWithNameInContext("mesa-shader", ctx);
llvm::unwrap(module)->setTargetTriple(TM->getTargetTriple().getTriple());
llvm::unwrap(module)->setDataLayout(TM->createDataLayout());
return module;
}
static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
{
c->opt = opt;
// Get the first package and the builtin package.
ast_t* package = ast_child(program);
ast_t* builtin = ast_sibling(package);
// If we have only one package, we are compiling builtin itself.
if(builtin == NULL)
builtin = package;
c->reach = reach_new();
// The name of the first package is the name of the program.
c->filename = package_filename(package);
// LLVM context and machine settings.
if(c->opt->library || target_is_ilp32(opt->triple))
c->callconv = LLVMCCallConv;
else
c->callconv = LLVMFastCallConv;
if(!c->opt->release || c->opt->library || c->opt->extfun)
c->linkage = LLVMExternalLinkage;
else
c->linkage = LLVMPrivateLinkage;
c->context = LLVMContextCreate();
c->machine = make_machine(opt);
c->target_data = LLVMGetTargetMachineData(c->machine);
// Create a module.
c->module = LLVMModuleCreateWithNameInContext(c->filename, c->context);
// Set the target triple.
LLVMSetTarget(c->module, opt->triple);
// Set the data layout.
char* layout = LLVMCopyStringRepOfTargetData(c->target_data);
LLVMSetDataLayout(c->module, layout);
LLVMDisposeMessage(layout);
// IR builder.
c->builder = LLVMCreateBuilderInContext(c->context);
c->di = LLVMNewDIBuilder(c->module);
// TODO: what LANG id should be used?
c->di_unit = LLVMDIBuilderCreateCompileUnit(c->di, 0x0004,
package_filename(package), package_path(package), "ponyc-" PONY_VERSION,
c->opt->release);
// Empty frame stack.
c->frame = NULL;
}
int
main(int argc, char **argv)
{
int n = argc > 1 ? atol(argv[1]) : 24;
LLVMInitializeNativeTarget();
LLVMLinkInInterpreter();
LLVMContextRef Context = LLVMContextCreate();
// Create some module to put our function into it.
LLVMModuleRef M = LLVMModuleCreateWithNameInContext("test", Context);
// We are about to create the "fib" function:
LLVMValueRef FibF = CreateFibFunction(M, Context);
// Now we going to create JIT
LLVMExecutionEngineRef EE;
char * outError;
if (LLVMCreateInterpreterForModule(&EE, M, &outError) != 0) {
printf("%s\n", outError);
return 1;
}
printf("verifying...\n");
if (LLVMVerifyModule(M, LLVMReturnStatusAction, &outError) != 0) {
printf("%s\n", outError);
return 1;
}
printf("OK\n");
printf("We just constructed this LLVM module:\n\n---------\n");
printf("%s\n", LLVMPrintModuleToString(M));
LLVMGenericValueRef Args = LLVMCreateGenericValueOfInt(LLVMInt32TypeInContext(Context), n, 0);
LLVMGenericValueRef Result = LLVMRunFunction(EE, FibF, 1, &Args);
printf("Result: %llu\n", LLVMGenericValueToInt(Result, 0));
return 0;
}
static void init_module(compile_t* c, ast_t* program, pass_opt_t* opt)
{
c->opt = opt;
// Get the first package and the builtin package.
ast_t* package = ast_child(program);
ast_t* builtin = ast_sibling(package);
// If we have only one package, we are compiling builtin itself.
if(builtin == NULL)
builtin = package;
c->reachable = reach_new();
reach_primitives(c->reachable, opt, builtin);
// The name of the first package is the name of the program.
c->filename = package_filename(package);
// LLVM context and machine settings.
c->context = LLVMContextCreate();
c->machine = make_machine(opt);
c->target_data = LLVMGetTargetMachineData(c->machine);
// Create a module.
c->module = LLVMModuleCreateWithNameInContext(c->filename, c->context);
// Set the target triple.
LLVMSetTarget(c->module, opt->triple);
// Set the data layout.
char* layout = LLVMCopyStringRepOfTargetData(c->target_data);
LLVMSetDataLayout(c->module, layout);
LLVMDisposeMessage(layout);
// IR builder.
c->builder = LLVMCreateBuilderInContext(c->context);
// Empty frame stack.
c->frame = NULL;
}
/**
* Allocate gallivm LLVM objects.
* \return TRUE for success, FALSE for failure
*/
static boolean
init_gallivm_state(struct gallivm_state *gallivm)
{
assert(!gallivm->context);
assert(!gallivm->module);
assert(!gallivm->provider);
lp_build_init();
gallivm->context = LLVMContextCreate();
if (!gallivm->context)
goto fail;
gallivm->module = LLVMModuleCreateWithNameInContext("gallivm",
gallivm->context);
if (!gallivm->module)
goto fail;
gallivm->provider =
LLVMCreateModuleProviderForExistingModule(gallivm->module);
if (!gallivm->provider)
goto fail;
if (!GlobalEngine) {
/* We can only create one LLVMExecutionEngine (w/ LLVM 2.6 anyway) */
enum LLVM_CodeGenOpt_Level optlevel;
char *error = NULL;
if (gallivm_debug & GALLIVM_DEBUG_NO_OPT) {
optlevel = None;
}
else {
optlevel = Default;
}
if (LLVMCreateJITCompiler(&GlobalEngine, gallivm->provider,
(unsigned) optlevel, &error)) {
_debug_printf("%s\n", error);
LLVMDisposeMessage(error);
goto fail;
}
#if defined(DEBUG) || defined(PROFILE)
lp_register_oprofile_jit_event_listener(GlobalEngine);
#endif
}
gallivm->engine = GlobalEngine;
LLVMAddModuleProvider(gallivm->engine, gallivm->provider);//new
gallivm->target = LLVMGetExecutionEngineTargetData(gallivm->engine);
if (!gallivm->target)
goto fail;
if (!create_pass_manager(gallivm))
goto fail;
gallivm->builder = LLVMCreateBuilderInContext(gallivm->context);
if (!gallivm->builder)
goto fail;
return TRUE;
fail:
free_gallivm_state(gallivm);
return FALSE;
}
/**
* Allocate gallivm LLVM objects.
* \return TRUE for success, FALSE for failure
*/
static boolean
init_gallivm_state(struct gallivm_state *gallivm)
{
assert(!gallivm->context);
assert(!gallivm->module);
assert(!gallivm->provider);
lp_build_init();
if (!gallivm_context) {
gallivm_context = LLVMContextCreate();
}
gallivm->context = gallivm_context;
if (!gallivm->context)
goto fail;
gallivm->module = LLVMModuleCreateWithNameInContext("gallivm",
gallivm->context);
if (!gallivm->module)
goto fail;
gallivm->provider =
LLVMCreateModuleProviderForExistingModule(gallivm->module);
if (!gallivm->provider)
goto fail;
gallivm->builder = LLVMCreateBuilderInContext(gallivm->context);
if (!gallivm->builder)
goto fail;
/* FIXME: MC-JIT only allows compiling one module at a time, and it must be
* complete when MC-JIT is created. So defer the MC-JIT engine creation for
* now.
*/
#if !USE_MCJIT
if (!init_gallivm_engine(gallivm)) {
goto fail;
}
#else
/*
* MC-JIT engine compiles the module immediately on creation, so we can't
* obtain the target data from it. Instead we create a target data layout
* from a string.
*
* The produced layout strings are not precisely the same, but should make
* no difference for the kind of optimization passes we run.
*
* For reference this is the layout string on x64:
*
* e-p:64:64:64-S128-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f16:16:16-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-f128:128:128-n8:16:32:64
*
* See also:
* - http://llvm.org/docs/LangRef.html#datalayout
*/
{
const unsigned pointer_size = 8 * sizeof(void *);
char layout[512];
util_snprintf(layout, sizeof layout, "%c-p:%u:%u:%u-i64:64:64-a0:0:%u-s0:%u:%u",
#ifdef PIPE_ARCH_LITTLE_ENDIAN
'e', // little endian
#else
'E', // big endian
#endif
pointer_size, pointer_size, pointer_size, // pointer size, abi alignment, preferred alignment
pointer_size, // aggregate preferred alignment
pointer_size, pointer_size); // stack objects abi alignment, preferred alignment
gallivm->target = LLVMCreateTargetData(layout);
if (!gallivm->target) {
return FALSE;
}
}
#endif
if (!create_pass_manager(gallivm))
goto fail;
return TRUE;
fail:
free_gallivm_state(gallivm);
return FALSE;
}
