typedef StringMap<std::pair<GlobalVariable*,void*>> SymMapGV;

static StringMap<std::pair<GlobalVariable*,SymMapGV>> libMapGV;

#ifdef _OS_WINDOWS_

static SymMapGV symMapExe;

static SymMapGV symMapDl;

#endif

static SymMapGV symMapDefault;

template<typename Func>

struct LazyModule {

};

template<typename Func>

static LazyModule<typename std::remove_reference<Func>::type>

lazyModule(Func &&func)

}

template<typename MT>

static bool runtime_sym_gvs(const char *f_lib, const char *f_name, MT &&M,

}

static Value *runtime_sym_lookup(

IRBuilder<> &irbuilder,

PointerType *funcptype, const char *f_lib,

const char *f_name, Function *f,

GlobalVariable *libptrgv,

GlobalVariable *llvmgv, bool runtime_lib)

{

// in pseudo-code, this function emits the following:

// global HMODULE *libptrgv

// global void **llvmgv

// if (*llvmgv == NULL) {

// *llvmgv = jl_load_and_lookup(f_lib, f_name, libptrgv);

// }

// return (*llvmgv)

BasicBlock *enter_bb = irbuilder.GetInsertBlock();

BasicBlock *dlsym_lookup = BasicBlock::Create(jl_LLVMContext, "dlsym");

BasicBlock *ccall_bb = BasicBlock::Create(jl_LLVMContext, "ccall");

Constant *initnul = ConstantPointerNull::get((PointerType*)T_pvoidfunc);

LoadInst *llvmf_orig = irbuilder.CreateAlignedLoad(llvmgv, sizeof(void*));

// This in principle needs a consume ordering so that load from

// this pointer sees a valid value. However, this is not supported by

// LLVM (or agreed on in the C/C++ standard FWIW) and should be

// almost impossible to happen on every platform we support since this

// ordering is enforced by the hardware and LLVM has to speculate an

// invalid load from the `cglobal` but doesn't depend on the `cglobal`

// value for this to happen.

// llvmf_orig->setAtomic(AtomicOrdering::Consume);

irbuilder.CreateCondBr(

irbuilder.CreateICmpNE(llvmf_orig, initnul),

ccall_bb,

dlsym_lookup);

assert(f->getParent() != NULL);

f->getBasicBlockList().push_back(dlsym_lookup);

irbuilder.SetInsertPoint(dlsym_lookup);

Value *libname;

if (runtime_lib) {

libname = stringConstPtr(irbuilder, f_lib);

}

else {

// f_lib is actually one of the special sentinel values

libname = ConstantExpr::getIntToPtr(ConstantInt::get(T_size, (uintptr_t)f_lib), T_pint8);

}

Value *llvmf = irbuilder.CreateCall(prepare_call_in(jl_builderModule(irbuilder), jldlsym_func),

{ libname, stringConstPtr(irbuilder, f_name), libptrgv });

auto store = irbuilder.CreateAlignedStore(llvmf, llvmgv, sizeof(void*));

store->setAtomic(AtomicOrdering::Release);

irbuilder.CreateBr(ccall_bb);

f->getBasicBlockList().push_back(ccall_bb);

irbuilder.SetInsertPoint(ccall_bb);

PHINode *p = irbuilder.CreatePHI(T_pvoidfunc, 2);

p->addIncoming(llvmf_orig, enter_bb);

p->addIncoming(llvmf, dlsym_lookup);

return irbuilder.CreateBitCast(p, funcptype);

}

static Value *runtime_sym_lookup(

jl_codectx_t &ctx,

PointerType *funcptype, const char *f_lib,

const char *f_name, Function *f)

{

GlobalVariable *libptrgv;

GlobalVariable *llvmgv;

bool runtime_lib = runtime_sym_gvs(f_lib, f_name, f->getParent(),

libptrgv, llvmgv);

libptrgv = prepare_global(libptrgv);

llvmgv = prepare_global(llvmgv);

return runtime_sym_lookup(ctx.builder, funcptype, f_lib, f_name, f, libptrgv, llvmgv,

runtime_lib);

}

static DenseMap<AttributeList,

std::map<std::tuple<GlobalVariable*,FunctionType*,

CallingConv::ID>,GlobalVariable*>> allPltMap;

static GlobalVariable *emit_plt_thunk(

Module *M, FunctionType *functype,

const AttributeList &attrs,

CallingConv::ID cc, const char *f_lib, const char *f_name,

GlobalVariable *libptrgv, GlobalVariable *llvmgv,

void *symaddr, bool runtime_lib)

{

PointerType *funcptype = PointerType::get(functype, 0);

libptrgv = prepare_global_in(M, libptrgv);

llvmgv = prepare_global_in(M, llvmgv);

std::stringstream funcName;

funcName << "jlplt_" << f_name << "_" << globalUnique++;

auto fname = funcName.str();

Function *plt = Function::Create(functype,

GlobalVariable::ExternalLinkage,

fname, M);

jl_init_function(plt);

plt->setAttributes(attrs);

if (cc != CallingConv::C)

plt->setCallingConv(cc);

funcName << "_got";

auto gname = funcName.str();

GlobalVariable *got = new GlobalVariable(*M, T_pvoidfunc, false,

GlobalVariable::ExternalLinkage,

nullptr, gname);

*(void**)jl_emit_and_add_to_shadow(got) = symaddr;

BasicBlock *b0 = BasicBlock::Create(jl_LLVMContext, "top", plt);

IRBuilder<> irbuilder(b0);

Value *ptr = runtime_sym_lookup(irbuilder, funcptype, f_lib, f_name, plt, libptrgv,

llvmgv, runtime_lib);

auto store = irbuilder.CreateAlignedStore(irbuilder.CreateBitCast(ptr, T_pvoidfunc), got, sizeof(void*));

store->setAtomic(AtomicOrdering::Release);

SmallVector<Value*, 16> args;

for (Function::arg_iterator arg = plt->arg_begin(), arg_e = plt->arg_end(); arg != arg_e; ++arg)

args.push_back(&*arg);

CallInst *ret = irbuilder.CreateCall(ptr, ArrayRef<Value*>(args));

ret->setAttributes(attrs);

if (cc != CallingConv::C)

ret->setCallingConv(cc);

// NoReturn function can trigger LLVM verifier error when declared as

// MustTail since other passes might replace the `ret` with

// `unreachable` (LLVM should probably accept `unreachable`).

if (attrs.hasAttribute(AttributeList::FunctionIndex,

Attribute::NoReturn)) {

irbuilder.CreateUnreachable();

}

else {

// musttail support is very bad on ARM, PPC, PPC64 (as of LLVM 3.9)

// Known failures includes vararg (not needed here) and sret.

#if (defined(_CPU_X86_) || defined(_CPU_X86_64_) || \

defined(_CPU_AARCH64_))

ret->setTailCallKind(CallInst::TCK_MustTail);

#endif

if (functype->getReturnType() == T_void) {

irbuilder.CreateRetVoid();

}

else {

irbuilder.CreateRet(ret);

}

}

irbuilder.ClearInsertionPoint();

got = global_proto(got); // exchange got for the permanent global before jl_finalize_module destroys it

jl_finalize_module(M, true);

auto shadowgot =

cast<GlobalVariable>(shadow_output->getNamedValue(gname));

auto shadowplt = cast<Function>(shadow_output->getNamedValue(fname));

shadowgot->setInitializer(ConstantExpr::getBitCast(shadowplt,

T_pvoidfunc));

return got;

}

static Value *emit_plt(

jl_codectx_t &ctx,

FunctionType *functype,

const AttributeList &attrs,

CallingConv::ID cc, const char *f_lib, const char *f_name)

{

assert(imaging_mode);

// Don't do this for vararg functions so that the `musttail` is only

// an optimization and is not required to function correctly.

assert(!functype->isVarArg());

GlobalVariable *libptrgv;

GlobalVariable *llvmgv;

void *symaddr;

auto LM = lazyModule([&] {

Module *m = new Module(f_name, jl_LLVMContext);

jl_setup_module(m);

return m;

});

bool runtime_lib = runtime_sym_gvs(f_lib, f_name, LM,

libptrgv, llvmgv, &symaddr);

PointerType *funcptype = PointerType::get(functype, 0);

auto &pltMap = allPltMap[attrs];

auto key = std::make_tuple(llvmgv, functype, cc);

GlobalVariable *&shadowgot = pltMap[key];

if (!shadowgot) {

shadowgot = emit_plt_thunk(LM.get(), functype, attrs, cc, f_lib, f_name, libptrgv, llvmgv, symaddr, runtime_lib);

}

else {

// `runtime_sym_gvs` shouldn't have created anything in a new module

// if it returns a GV that already exists.

assert(!LM.m);

}

GlobalVariable *got = prepare_global(shadowgot);

LoadInst *got_val = ctx.builder.CreateAlignedLoad(got, sizeof(void*));

// See comment in `runtime_sym_lookup` above. This in principle needs a

// consume ordering too. This is even less likely to cause issues though

// since the only thing we do to this loaded pointer is to call it

// immediately.

// got_val->setAtomic(AtomicOrdering::Consume);

return ctx.builder.CreateBitCast(got_val, funcptype);

}

class AbiLayout {

};

static bool is_native_simd_type(jl_datatype_t *dt) {

}

#include "abi_llvm.cpp"

#include "abi_arm.cpp"

#include "abi_aarch64.cpp"

#include "abi_ppc64le.cpp"

#include "abi_win32.cpp"

#include "abi_win64.cpp"

#include "abi_x86_64.cpp"

#include "abi_x86.cpp"

#if defined ABI_LLVM

typedef ABI_LLVMLayout DefaultAbiState;

#elif defined _CPU_X86_64_

# if defined _OS_WINDOWS_

typedef ABI_Win64Layout DefaultAbiState;

# else

typedef ABI_x86_64Layout DefaultAbiState;

# endif

#elif defined _CPU_X86_

# if defined _OS_WINDOWS_

typedef ABI_Win32Layout DefaultAbiState;

# else

typedef ABI_x86Layout DefaultAbiState;

# endif

#elif defined _CPU_ARM_

typedef ABI_ARMLayout DefaultAbiState;

#elif defined _CPU_AARCH64_

typedef ABI_AArch64Layout DefaultAbiState;

#elif defined _CPU_PPC64_

typedef ABI_PPC64leLayout DefaultAbiState;

#else

# warning "ccall is defaulting to llvm ABI, since no platform ABI has been defined for this CPU/OS combination"

typedef ABI_LLVMLayout DefaultAbiState;

#endif

static Value *llvm_type_rewrite(

jl_codectx_t &ctx,

Value *v, Type *target_type,

bool issigned) /* determines whether an integer value should be zero or sign extended */

{

Type *from_type = v->getType();

if (target_type == from_type)

return v;

if (from_type == T_void || isa<UndefValue>(v))

return UndefValue::get(target_type); // convert undef (unreachable) -> undef (target_type)

assert(from_type->isPointerTy() == target_type->isPointerTy()); // expect that all ABIs consider all pointers to be equivalent

if (target_type->isPointerTy())

return emit_bitcast(ctx, v, target_type);

// simple integer and float widening & conversion cases

if (from_type->getPrimitiveSizeInBits() > 0 &&

target_type->getPrimitiveSizeInBits() == from_type->getPrimitiveSizeInBits())

return emit_bitcast(ctx, v, target_type);

if (target_type->isFloatingPointTy() && from_type->isFloatingPointTy()) {

if (target_type->getPrimitiveSizeInBits() > from_type->getPrimitiveSizeInBits())

return ctx.builder.CreateFPExt(v, target_type);

else if (target_type->getPrimitiveSizeInBits() < from_type->getPrimitiveSizeInBits())

return ctx.builder.CreateFPTrunc(v, target_type);

else

return v;

}

if (target_type->isIntegerTy() && from_type->isIntegerTy()) {

if (issigned)

return ctx.builder.CreateSExtOrTrunc(v, target_type);

else

return ctx.builder.CreateZExtOrTrunc(v, target_type);

}

// one or both of from_type and target_type is a VectorType or AggregateType

// LLVM doesn't allow us to cast these values directly, so

// we need to use this alloca copy trick instead

// On ARM and AArch64, the ABI requires casting through memory to different

// sizes.

Value *from;

Value *to;

const DataLayout &DL = jl_data_layout;

if (DL.getTypeAllocSize(target_type) >= DL.getTypeAllocSize(from_type)) {

to = emit_static_alloca(ctx, target_type);

from = emit_bitcast(ctx, to, from_type->getPointerTo());

}

else {

from = emit_static_alloca(ctx, from_type);

to = emit_bitcast(ctx, from, target_type->getPointerTo());

}

ctx.builder.CreateStore(v, from);

return ctx.builder.CreateLoad(to);

}

static Value *runtime_apply_type_env(jl_codectx_t &ctx, jl_value_t *ty)

{

// box if concrete type was not statically known

Value *args[] = {

literal_pointer_val(ctx, ty),

literal_pointer_val(ctx, (jl_value_t*)ctx.linfo->def.method->sig),

ctx.builder.CreateInBoundsGEP(

T_prjlvalue,

ctx.spvals_ptr,

ConstantInt::get(T_size, sizeof(jl_svec_t) / sizeof(jl_value_t*)))

};

return ctx.builder.CreateCall(prepare_call(jlapplytype_func), makeArrayRef(args));

}

static const std::string make_errmsg(const char *fname, int n, const char *err)

}

static void typeassert_input(jl_codectx_t &ctx, const jl_cgval_t &jvinfo, jl_value_t *jlto, jl_unionall_t *jlto_env, int argn, bool addressOf)

}

static Value *julia_to_address(

jl_codectx_t &ctx,

Type *to, jl_value_t *jlto, jl_unionall_t *jlto_env,

const jl_cgval_t &jvinfo,

int argn, bool *needStackRestore)

{

assert(jl_is_datatype(jlto) && julia_struct_has_layout((jl_datatype_t*)jlto, jlto_env));

if (!jl_is_cpointer_type(jlto) || to != T_size) {

emit_error(ctx, "ccall: & on argument was not matched by Ptr{T} argument type");

return UndefValue::get(to);

}

jl_value_t *ety;

if (jlto == (jl_value_t*)jl_voidpointer_type) {

ety = jvinfo.typ; // skip the type-check

}

else {

ety = jl_tparam0(jlto);

typeassert_input(ctx, jvinfo, ety, jlto_env, argn, true);

}

if (jvinfo.isboxed) {

if (!jl_is_abstracttype(ety)) {

if (jl_is_mutable_datatype(ety)) {

// no copy, just reference the data field

return ctx.builder.CreateBitCast(emit_pointer_from_objref(ctx, data_pointer(ctx, jvinfo)), to);

}

else if (jl_is_immutable_datatype(ety) && jlto != (jl_value_t*)jl_voidpointer_type) { // anything declared `struct`, except Ptr{Cvoid}

// yes copy

Value *nbytes;

AllocaInst *ai;

if (((jl_datatype_t*)ety)->layout) {

int nb = jl_datatype_size(ety);

nbytes = ConstantInt::get(T_int32, nb);

ai = emit_static_alloca(ctx, T_int8, nb);

}

else {

nbytes = emit_datatype_size(ctx, emit_typeof_boxed(ctx, jvinfo));

ai = ctx.builder.CreateAlloca(T_int8, nbytes);

*needStackRestore = true;

}

ai->setAlignment(16);

// minimum gc-alignment in julia is pointer size

emit_memcpy(ctx, ai, jvinfo.tbaa, jvinfo, nbytes, sizeof(void*));

return ctx.builder.CreatePtrToInt(ai, to);

}

}

// emit maybe copy

*needStackRestore = true;

Value *jvt = emit_typeof_boxed(ctx, jvinfo);

BasicBlock *mutableBB = BasicBlock::Create(jl_LLVMContext, "is-mutable", ctx.f);

BasicBlock *immutableBB = BasicBlock::Create(jl_LLVMContext, "is-immutable", ctx.f);

BasicBlock *afterBB = BasicBlock::Create(jl_LLVMContext, "after", ctx.f);

Value *ismutable = emit_datatype_mutabl(ctx, jvt);

ctx.builder.CreateCondBr(ismutable, mutableBB, immutableBB);

ctx.builder.SetInsertPoint(mutableBB);

Value *p1 = ctx.builder.CreateBitCast(emit_pointer_from_objref(ctx, data_pointer(ctx, jvinfo)), to);

ctx.builder.CreateBr(afterBB);

ctx.builder.SetInsertPoint(immutableBB);

Value *nbytes = emit_datatype_size(ctx, jvt);

AllocaInst *ai = ctx.builder.CreateAlloca(T_int8, nbytes);

ai->setAlignment(16);

emit_memcpy(ctx, ai, jvinfo.tbaa, jvinfo, nbytes, sizeof(void*)); // minimum gc-alignment in julia is pointer size

Value *p2 = ctx.builder.CreatePtrToInt(ai, to);

ctx.builder.CreateBr(afterBB);

ctx.builder.SetInsertPoint(afterBB);

PHINode *p = ctx.builder.CreatePHI(to, 2);

p->addIncoming(p1, mutableBB);

p->addIncoming(p2, immutableBB);

return p;

}

Type *slottype = julia_struct_to_llvm(jvinfo.typ, NULL, NULL);

// pass the address of an alloca'd thing, not a box

// since those are immutable.

Value *slot = emit_static_alloca(ctx, slottype);

if (!jvinfo.ispointer()) {

tbaa_decorate(jvinfo.tbaa, ctx.builder.CreateStore(emit_unbox(ctx, slottype, jvinfo, ety), slot));

}

else {

emit_memcpy(ctx, slot, jvinfo.tbaa, jvinfo, jl_datatype_size(ety), jl_datatype_align(ety));

}

return ctx.builder.CreatePtrToInt(slot, to);

}

static Value *julia_to_native(

jl_codectx_t &ctx,

Type *to, bool toboxed, jl_value_t *jlto, jl_unionall_t *jlto_env,

const jl_cgval_t &jvinfo,

bool byRef, int argn,

bool *needStackRestore)

{

// We're passing Any

if (toboxed) {

assert(!byRef); // don't expect any ABI to pass pointers by pointer

return maybe_decay_untracked(boxed(ctx, jvinfo));

}

assert(jl_is_datatype(jlto) && julia_struct_has_layout((jl_datatype_t*)jlto, jlto_env));

typeassert_input(ctx, jvinfo, jlto, jlto_env, argn, false);

if (!byRef)

return emit_unbox(ctx, to, jvinfo, jlto);

// pass the address of an alloca'd thing, not a box

// since those are immutable.

Value *slot = emit_static_alloca(ctx, to);

if (!jvinfo.ispointer()) {

tbaa_decorate(jvinfo.tbaa, ctx.builder.CreateStore(emit_unbox(ctx, to, jvinfo, jlto), slot));

}

else {

emit_memcpy(ctx, slot, jvinfo.tbaa, jvinfo, jl_datatype_size(jlto), jl_datatype_align(jlto));

}

return slot;

}

typedef struct {

Value *jl_ptr; // if the argument is a run-time computed pointer

void (*fptr)(void); // if the argument is a constant pointer

const char *f_name; // if the symbol name is known

const char *f_lib; // if a library name is specified

jl_value_t *gcroot;

} native_sym_arg_t;

static void interpret_symbol_arg(jl_codectx_t &ctx, native_sym_arg_t &out, jl_value_t *arg, const char *fname, bool llvmcall)

}

static jl_value_t* try_eval(jl_codectx_t &ctx, jl_value_t *ex, const char *failure)

{

jl_value_t *constant = static_eval(ctx, ex, true, true);

if (jl_is_ssavalue(ex) && !constant)

jl_error(failure);

else if (constant)

return constant;

JL_TRY {

size_t last_age = jl_get_ptls_states()->world_age;

jl_get_ptls_states()->world_age = ctx.world;

constant = jl_interpret_toplevel_expr_in(ctx.module, ex, ctx.source, ctx.linfo->sparam_vals);

jl_get_ptls_states()->world_age = last_age;

}

JL_CATCH {

jl_rethrow_with_add(failure);

}

return constant;

}

static jl_cgval_t emit_runtime_call(jl_codectx_t &ctx, JL_I::intrinsic f, const jl_cgval_t *argv, size_t nargs);

static jl_cgval_t emit_cglobal(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)

}

class FunctionMover final : public ValueMaterializer

};

static jl_cgval_t emit_llvmcall(jl_codectx_t &ctx, jl_value_t **args, size_t nargs)