SimNode_Jit ( const LineInfo & at, JitFunction eval )

: SimNode(at), func(eval) {}

virtual SimNode * visit ( SimVisitor & vis ) override;

DAS_EVAL_ABI virtual vec4f eval ( Context & context ) override;

virtual bool rtti_node_isJit() const override { return true; }

JitFunction func = nullptr;

// saved original node

SimNode * saved_code = nullptr;

bool saved_aot = false;

void * saved_aot_function = nullptr;

SimNode_JitBlock ( const LineInfo & at, JitBlockFunction eval, Block * bptr, uint64_t ad )

: SimNode_ClosureBlock(at,false,false,ad), func(eval), blockPtr(bptr) {}

virtual SimNode * visit ( SimVisitor & vis ) override;

DAS_EVAL_ABI virtual vec4f eval ( Context & context ) override;

JitBlockFunction func = nullptr;

Block * blockPtr = nullptr;

auto result = func(&context, context.abiArg, context.abiCMRES);

context.result = result;

return result;

vec4f * arguments = cast<vec4f *>::to(anything);

vec4f (*fun)(Context *, vec4f *, void *) = (vec4f(*)(Context *, vec4f *, void *)) pfun;

vec4f res = fun ( context, arguments, cmres );

return res;

auto simfn = func.PTR;

if ( !simfn ) return false;

if ( simfn->code && simfn->code->rtti_node_isJit() ) {

auto jitNode = static_cast<SimNode_Jit *>(simfn->code);

simfn->code = jitNode->saved_code;

simfn->aot = jitNode->saved_aot;

simfn->aotFunction = jitNode->saved_aot_function;

simfn->jitFunction = nullptr; // pre-instrument mirror is always null (aot/jit exclusive)

simfn->jit = false;

return true;

} else {

return false;

}

// test rail: is the invoke fastpath armed for this function (SimFunction::jitFunction mirror set)?

auto simfn = func.PTR;

return simfn && simfn->jitFunction;

auto simfn = func.PTR;

if ( !simfn ) return false;

if ( simfn->code && simfn->code->rtti_node_isJit() ) {

auto jitNode = static_cast<SimNode_Jit *>(simfn->code);

jitNode->func = (JitFunction) pfun;

jitNode->debugInfo = lineInfo;

simfn->jitFunction = pfun;

} else {

auto node = context.code->makeNode<SimNode_Jit>(lineInfo, (JitFunction)pfun);

node->saved_code = simfn->code;

node->saved_aot = simfn->aot;

node->saved_aot_function = simfn->aotFunction;

simfn->code = node;

simfn->aot = false;

simfn->aotFunction = nullptr;

simfn->jitFunction = pfun; // the invoke-fastpath mirror of node->func

simfn->jit = true;

}

return true;

if ( fn->jitFunction ) {

// JIT->JIT direct call: skip the stack push/prologue (JIT'd bodies push their own

// frame via jit_prologue when they need one) and the virtual SimNode_Jit::eval.

auto res = ((JitFunction) fn->jitFunction)(context, args, nullptr);

context->stopFlags = 0; // mirror callOrFastcall (an invoked interpreted block may leak stopForReturn)

return res;

}

return context->callOrFastcall(fn, args, nullptr);

auto res = new(ptr) SimNode_AotInteropBase();

res->argumentValues = nullptr;

res->nArguments = argCount;

res->types = types;

public:

~JitContext() = default;

JitContext(size_t totalVariables, size_t totalFunctions, size_t globalStringHeapSize,

size_t globSize, size_t shrSize, bool pinvoke, uint32_t stackSize = 16*1024,

bool persistentHeap = false, bool gcEnabled = false)

: Context(stackSize) {

auto &context = *this;

CodeOfPolicies policies;

policies.debugger = false;

// standalone exe skips Program::simulate (which would read `options

// persistent_heap` / `options gc`), so set the heap mode here. Without a

// persistent heap + gcEnabled, heap_collect() throws at runtime.

policies.persistent_heap = persistentHeap;

context.setup(totalVariables, globalStringHeapSize, policies, {});

context.gcEnabled = gcEnabled;

context.globalsSize = globSize;

context.sharedSize = shrSize;

context.sharedOwner = true;

for (size_t i = 0; i < totalVariables; i++) {

globalVariables[i] = GlobalVariable{};

}

context.allocateGlobalsAndShared();

// UBSAN forbid memset(null, 0, 0)

if (context.globalsSize) memset(context.globals, 0, context.globalsSize);

if (context.sharedSize) memset(context.shared, 0, context.sharedSize);

if ( pinvoke ) {

context.contextMutex = new recursive_mutex;

}

}

void allocFunctions ( uint64_t count ) {

functions = (SimFunction *) code->allocate(count * sizeof(SimFunction));

memset(functions, 0, count * sizeof(SimFunction));

totalFunctions = (int) count;

// Allocate stub debugInfo for all function slots so that

// runShutdownScript can safely iterate them.

auto stubInfo = (FuncInfo *) code->allocate(count * sizeof(FuncInfo));

memset(stubInfo, 0, count * sizeof(FuncInfo));

for ( uint64_t i = 0; i < count; i++ ) {

stubInfo[i].name = (char *) "unimplemented";

functions[i].name = (char *) "unimplemented";

functions[i].debugInfo = &stubInfo[i];

}

tabMnLookup = make_shared<das_hash_map<uint64_t,SimFunction *>>();

tabGMnLookup = make_shared<das_hash_map<uint64_t,uint32_t>>();

}

void *registerJitFunction ( uint64_t index, const char * funcName, const char * mangledName,

uint64_t mnh, uint32_t stackSize, void * fnPtr,

bool cmres, bool fastcall, bool pinvoke, uint32_t nArguments ) {

DAS_ASSERT(index < (uint64_t) totalFunctions);

auto & fn = functions[index];

fn.name = code->allocateName(funcName);

fn.mangledName = code->allocateName(mangledName);

fn.mangledNameHash = mnh;

fn.stackSize = stackSize;

fn.flags = 0;

fn.cmres = cmres;

fn.fastcall = fastcall;

fn.pinvoke = pinvoke;

fn.jit = true;

auto finfo = (FuncInfo *) code->allocate(sizeof(FuncInfo));

memset(finfo, 0, sizeof(FuncInfo));

finfo->name = fn.name;

finfo->stackSize = stackSize;

finfo->count = nArguments;

fn.debugInfo = finfo;

auto node = code->makeNode<SimNode_Jit>(LineInfo{}, (JitFunction) fnPtr);

fn.code = node;

fn.jitFunction = fnPtr; // the invoke-fastpath mirror

(*tabMnLookup)[mnh] = &fn;

return &fn;

}

void registerJitGlobalVariable(uint64_t mnh, size_t offset) {

(*tabGMnLookup)[mnh] = offset;

}

// A standalone -exe leaves globalVariables[] zeroed (registerJitGlobalVariable

// only fills tabGMnLookup). collectHeap walks globalVariables[i] via

// .offset/.debugInfo/.shared, so they must be populated or the GC dereferences

// a NULL debugInfo. Called from the JIT'd init function (debugInfo is the

// exe-resident TypeInfo emitted by create_type_info_global).

void setStandaloneGlobalInfo(uint64_t index, uint64_t offset, void* debugInfo, int shared) {

DAS_ASSERT(index < (uint64_t) totalVariables);

auto & gv = globalVariables[index];

gv.offset = (uint32_t) offset;

gv.debugInfo = (VarInfo *) debugInfo;

gv.flags = shared ? 1u : 0u;

}

void initFunctionAddr ( uint64_t index, void * globPtr ) {

DAS_ASSERT(index < (uint64_t) totalFunctions);

*((SimFunction **) globPtr) = &functions[index];

}

const char * funcMangledName,

void ** dllGlobal ) {

bool found = false;

Module::foreach([&](Module * module) -> bool {

if ( module->name != moduleName ) return true;

auto fn = module->findFunction(funcMangledName);

if ( fn && fn->builtIn ) {

*dllGlobal = static_cast<BuiltInFunction *>(fn)->getBuiltinAddress();

found = *dllGlobal != nullptr;

return !found;

}

return true;

});

if ( !found && strcmp(moduleName, "dasbind") == 0 && strncmp(funcMangledName, "@dasbind::__dasbind__", 21) == 0 ) {

Module::foreach([&](Module * module) -> bool {

if ( module->name != "dasbind" ) return true;

auto resolverFn = module->findUniqueFunction("__dasbind_resolve");

if ( resolverFn && resolverFn->builtIn ) {

auto resolver = (void * (*)(const char *))

static_cast<BuiltInFunction *>(resolverFn)->getBuiltinAddress();

if ( resolver ) {

*dllGlobal = resolver(funcMangledName);

found = *dllGlobal != nullptr;

}

}

return false;

});

}

if (!found) {

DAS_FATAL_ERROR("Failed to find %s in module %s.\n", funcMangledName, moduleName);

}

const char * typeName,

const char * fieldName ) {

uint32_t offset = (uint32_t)-1;

Module::foreach([&](Module * module) -> bool {

if ( module->name != moduleName ) return true;

auto ann = module->findAnnotation(typeName);

// handled-type annotations only — StructureAnnotation isn't a TypeAnnotation (see note in

// jit_find_handled_annotation); the JIT only resolves offsets for handled-type fields.

if ( ann && ann->rtti_isHandledTypeAnnotation() ) {

offset = ((TypeAnnotation *)ann)->getFieldOffset(fieldName);

return false; // stop iterating

}

return true;

});

// Compiler only requests offsets for fields it resolved on the host annotation; a

// miss = target runtime annotation diverges (ABI/module mismatch). Fail loud, not -1.

if ( offset == (uint32_t)-1 ) {

DAS_FATAL_ERROR("jit: unresolved handled-type field offset %s::%s.%s (target runtime annotation diverges from the host).\n",

moduleName, typeName, fieldName);

}

return offset;

auto ann = jit_find_handled_annotation(moduleName, typeName);

if ( !ann ) { g_abi_types_skipped ++; return; } // not registered on target -> module not linked here

g_abi_types_checked ++;

uint32_t targetSize = uint32_t(ann->getSizeOf());

if ( targetSize != hostSize ) {

char buf[256];

snprintf(buf, sizeof(buf), " size %s::%s host=%u target=%u\n",

moduleName, typeName, hostSize, targetSize);

g_abi_check_report += buf;

g_abi_check_count ++;

}

const char * fieldName, uint32_t hostOffset ) {

auto ann = jit_find_handled_annotation(moduleName, typeName);

if ( !ann ) { g_abi_fields_skipped ++; return; }

g_abi_fields_checked ++;

uint32_t targetOffset = ann->getFieldOffset(fieldName);

if ( targetOffset != hostOffset ) {

char buf[256];

if ( targetOffset == (uint32_t)-1 ) // field absent on the target annotation

snprintf(buf, sizeof(buf), " offset %s::%s.%s host=%u target=MISSING\n",

moduleName, typeName, fieldName, hostOffset);

else

snprintf(buf, sizeof(buf), " offset %s::%s.%s host=%u target=%u\n",

moduleName, typeName, fieldName, hostOffset, targetOffset);

g_abi_check_report += buf;

g_abi_check_count ++;

}

DAS_FATAL_LOG("JIT ABI CHECK: types %d checked / %d skipped, fields %d checked / %d skipped, %d mismatch(es)\n",

g_abi_types_checked, g_abi_types_skipped, g_abi_fields_checked, g_abi_fields_skipped, g_abi_check_count);

if ( g_abi_check_count==0 ) {

// reset so a subsequent sweep in the same process reports only its own results

g_abi_types_checked = g_abi_types_skipped = g_abi_fields_checked = g_abi_fields_skipped = 0;

g_abi_check_report.clear();

return;

}

DAS_FATAL_ERROR("JIT ABI CHECK: %d handled-type layout mismatch(es) (host-baked vs target runtime):\n%s",

g_abi_check_count, g_abi_check_report.c_str());

int32_t stackSize, JitStackState * stackState,

Context * context, LineInfoArg * at ) {

if (!context->stack.push(stackSize, stackState->EP, stackState->SP)) {

context->throw_error_at(at, "stack overflow");

}

#if DAS_ENABLE_STACK_WALK

Prologue * pp = (Prologue *)context->stack.sp();

pp->info = nullptr;

pp->fileName = funcName;

pp->functionLine = (LineInfo *) funcLineInfo;

pp->stackSize = stackSize;

pp->is_jit = true;

#endif

DAS_ASSERTF(lineInfo != nullptr, "Line info should not be null");

JitBlock * block = (JitBlock *) blk;

block->stackOffset = context->stack.spi();

block->argumentsOffset = argStackTop ? (context->stack.spi() + argStackTop) : 0;

block->body = (SimNode *)(void*) block->node;

block->aotFunction = nullptr;

block->jitFunction = jitImpl;

block->functionArguments = context->abiArguments();

block->info = (FuncInfo *) funcInfo;

new (block->node) SimNode_JitBlock(*static_cast<LineInfo*>(lineInfo), (JitBlockFunction) bodyNode, blk, ad);

FPE_DISABLE;

TextWriter ssw;

if ( message ) ssw << message << " ";

ssw << debug_type(typeInfo) << " = " << debug_value(res, typeInfo, PrintFlags::debugger) << "\n";

context->to_out(at, ssw.str().c_str());

TextWriter tw;

tw << string(context->fnDepth, '\t'); context->fnDepth ++;

tw << ">>";

if ( !context->name.empty() ) tw << "(" << context->name << ")";

tw << ": ";

if ( message ) tw << message;

if ( at && at->line ) tw << " at " << at->describe();

tw << "\n";

context->to_out(at, tw.str().c_str());

TextWriter tw;

context->fnDepth --; tw << string(context->fnDepth, '\t');

tw << " -";

if ( !context->name.empty() ) tw << "(" << context->name << ")";

tw << ": ";

if ( message ) tw << message;

if ( at && at->line ) tw << " at " << at->describe();

tw << "\n";

context->to_out(at, tw.str().c_str());

TextWriter tw;

tw << string(context->fnDepth + 1, '\t');

tw << ">>";

if ( !context->name.empty() ) tw << "(" << context->name << ")";

tw << ": ";

if ( message ) tw << message;

if ( at && at->line ) tw << " at " << at->describe();

tw << "\n";

context->to_out(at, tw.str().c_str());

new (dummy) FileInfo();

auto fileInfoPtr = reinterpret_cast<FileInfo*>(dummy);

fileInfoPtr->name = filename;

if ( tab->isLocked() ) context->throw_error_at(at, "can't insert to a locked table");

TableHash<KeyType> thh(context,valueTypeSize);

auto hfn = hash_function(*context, key);

int64_t idx = thh.reserve(*tab, key, hfn, at);

// TODO Phase 7: widen JIT helper return to int64_t. Until then, guard the narrowing

// so JIT-emitted code never gets a wrapped-negative slot index for huge tables.

if ( idx > int64_t(INT32_MAX) ) context->throw_error_at(at, "JIT table slot index %lld exceeds INT32_MAX; JIT does not yet support tables past INT_MAX slots", (long long)idx);

return (int32_t) idx;

if ( tab->isLocked() ) context->throw_error_at(at, "can't erase from locked table");

TableHash<KeyType> thh(context,valueTypeSize);

auto hfn = hash_function(*context, key);

return thh.erase(*tab, key, hfn) != -1;

TableHash<KeyType> thh(context,valueTypeSize);

auto hfn = hash_function(*context, key);

int64_t idx = thh.find(*tab, key, hfn);

// TODO Phase 7: widen JIT helper return to int64_t. Until then, guard the narrowing

// so JIT-emitted code never gets a wrapped-negative slot index for huge tables.

if ( idx > int64_t(INT32_MAX) ) context->throw_error("JIT table slot index exceeds INT32_MAX; JIT does not yet support tables past INT_MAX slots");

return (int32_t) idx;

if ( tab->isLocked() ) context->throw_error_at(at, "can't insert to a locked table");

TableHash<char *> thh(context,valueTypeSize);

int64_t idx = thh.reserve(*tab, key, hfn, at);

if ( idx > int64_t(INT32_MAX) ) context->throw_error_at(at, "JIT table slot index %lld exceeds INT32_MAX; JIT does not yet support tables past INT_MAX slots", (long long)idx);

return (int32_t) idx;

TableHash<char *> thh(context,valueTypeSize);

int64_t idx = thh.reserveAfterPackedMiss(*tab, key, hfn, at);

if ( idx > int64_t(INT32_MAX) ) context->throw_error_at(at, "JIT table slot index %lld exceeds INT32_MAX; JIT does not yet support tables past INT_MAX slots", (long long)idx);

return (int32_t) idx;

if ( FILE * file = fopen(filename, "r"); file == NULL ) {

return false;

} else {

fclose(file);

return true;

}

string linker;

string runtimeLibrary; // always needed

string compilerLibrary; // non-empty when linkWholeLib — exe also needs compiler lib

if ( custom != nullptr && custom[0] != '\0' ) return custom;

string bundled = getDasRoot() + "/bin/" + bundledName;

if ( check_file_present(bundled.c_str()) ) return bundled;

return fallback;

LinkerPaths result;

result.linker = customLinker != nullptr ? customLinker : "";

result.runtimeLibrary = dasLib != nullptr ? dasLib : "";

if (result.linker.empty() || result.runtimeLibrary.empty()) {

#if defined(_WIN32) || defined(_WIN64)

// Two distinct Windows toolchains share the _WIN32 macro: