jit.c

Include dependency graph for jit.c:

Defines

ELF_ST_TYPE(info) ((info) &0xf)

PROCESS_MAYBE_TRAP_RETURN_VALUE(return_value, offset)     if (term_is_invalid_term (return_value)) {                 \ if ( UNLIKELY(!context_get_flags(ctx, Trap ))) {        \ return jit_handle_error (ctx, jit_state, offset); \ } else {                                              \ return jit_schedule_wait_cp (ctx, jit_state);      \ }                                                     \ } 

PROCESS_MAYBE_TRAP_RETURN_VALUE_LAST(return_value, offset)     if (term_is_invalid_term (return_value)) {                                   \ if ( UNLIKELY(!context_get_flags(ctx, Trap ))) {                          \ return jit_handle_error (ctx, jit_state, offset);                    \ } else {                                                                \ return jit_schedule_wait_cp(jit_return (ctx, jit_state), jit_state); \ }                                                                       \ } 

PROCESS_MAYBE_TRAP_RETURN_VALUE_LAST_MFA(return_value, offset, m, i, a)     if (term_is_invalid_term (return_value)) {                                             \ if ( UNLIKELY(!context_get_flags(ctx, Trap))) {                                    \             term module_atom;                                                             \             term function_atom;                                                           \             module_get_imported_function_module_and_name_atoms (                           \ (m), (i), &module_atom, &function_atom);                                  \ ctx->exception_stacktrace = stacktrace_create_raw_mfa (ctx, jit_state->module, \ (offset), module_atom, function_atom, (a));                               \ return jit_handle_error (ctx, jit_state, 0);                                   \ } else {                                                                          \ return jit_schedule_wait_cp(jit_return (ctx, jit_state), jit_state);           \ }                                                                                 \ } 

MIN(X, Y) ((X) < (Y) ? (X) : (Y))

TRIM_LIVE_REGS(live_regs_no) jit_trim_live_regs (ctx, live_regs_no); \ if ( UNLIKELY(live_regs_no > MAX_REG )) { \ live_regs_no = MAX_REG ; \ } 

MAXI(A, B) ((A > B) ? (A) : (B))

MINI(A, B) ((A > B) ? (B) : (A))

Enums

enum jit_actions_t

Values:

enumerator JIT_NOACTION = 0

enumerator JIT_REGISTER_FN

enumerator JIT_UNREGISTER_FN

Functions

_Static_assert (OK_ATOM_INDEX==2, "OK_ATOM_INDEX is 2 in libs/jit/src/default_atoms.hrl ")

_Static_assert (ERROR_ATOM_INDEX==3, "ERROR_ATOM_INDEX is 3 in libs/jit/src/default_atoms.hrl ")

_Static_assert (BADARG_ATOM_INDEX==4, "BADARG_ATOM_INDEX is 4 in libs/jit/src/default_atoms.hrl ")

_Static_assert (BADARITH_ATOM_INDEX==5, "BADARITH_ATOM_INDEX is 5 in libs/jit/src/default_atoms.hrl ")

_Static_assert (BADFUN_ATOM_INDEX==6, "BADFUN_ATOM_INDEX is 6 in libs/jit/src/default_atoms.hrl ")

_Static_assert (FUNCTION_CLAUSE_ATOM_INDEX==7, "FUNCTION_CLAUSE_ATOM_INDEX is 7 in libs/jit/src/default_atoms.hrl ")

_Static_assert (TRY_CLAUSE_ATOM_INDEX==8, "TRY_CLAUSE_ATOM_INDEX is 8 in libs/jit/src/default_atoms.hrl ")

_Static_assert (OUT_OF_MEMORY_ATOM_INDEX==9, "OUT_OF_MEMORY_ATOM_INDEX is 9 in libs/jit/src/default_atoms.hrl ")

_Static_assert (BADMATCH_ATOM_INDEX==10, "BADMATCH_ATOM_INDEX is 10 in libs/jit/src/default_atoms.hrl ")

_Static_assert (CASE_CLAUSE_ATOM_INDEX==11, "CASE_CLAUSE_ATOM_INDEX is 11 in libs/jit/src/default_atoms.hrl ")

_Static_assert (IF_CLAUSE_ATOM_INDEX==12, "IF_CLAUSE_ATOM_INDEX is 12 in libs/jit/src/default_atoms.hrl ")

_Static_assert (THROW_ATOM_INDEX==13, "THROW_ATOM_INDEX is 13 in libs/jit/src/default_atoms.hrl ")

_Static_assert (UNSUPPORTED_ATOM_INDEX==14, "UNSUPPORTED_ATOM_INDEX is 14 in libs/jit/src/default_atoms.hrl ")

_Static_assert (ALL_ATOM_INDEX==15, "ALL_ATOM_INDEX is 15 in libs/jit/src/default_atoms.hrl ")

_Static_assert (LOWERCASE_EXIT_ATOM_INDEX==16, "LOWERCASE_EXIT_ATOM_INDEX is 16 in libs/jit/src/default_atoms.hrl ")

_Static_assert (BADRECORD_ATOM_INDEX==17, "BADRECORD_ATOM_INDEX is 17 in libs/jit/src/default_atoms.hrl ")

_Static_assert (-1==-1, "CALL_EXT_NO_DEALLOC is -1 in libs/jit/src/primitives.hrl")

_Static_assert (-2==-2, "CALL_EXT_NO_DEALLOC_MFA is -2 in libs/jit/src/primitives.hrl")

_Static_assert (sizeof(avm_float_t)==0x8, "sizeof(avm_float_t) is 0x8 for double precision")

static void destroy_extended_registers(Context *ctx, unsigned int live)

static void jit_trim_live_regs(Context *ctx, uint32_t live)

static Context *jit_return(Context *ctx, JITState *jit_state)

static Context *jit_terminate_context(Context *ctx, JITState *jit_state)

static Context *jit_handle_error(Context *ctx, JITState *jit_state, int offset)

static void set_error(Context *ctx, JITState *jit_state, int offset, term error_term)

static Context *jit_raise_error(Context *ctx, JITState *jit_state, int offset, term error_type_atom)

static Context *jit_raise_error_mfa(Context *ctx, JITState *jit_state, int offset, int function_atom_index, int arity)

static Context *jit_raise_error_tuple(Context *ctx, JITState *jit_state, int offset, term error_atom, term arg1)

static Context *jit_raise(Context *ctx, JITState *jit_state, term stacktrace, term exc_value)

static Context *jit_raw_raise(Context *ctx, JITState *jit_state)

static Context *jit_schedule_next_cp(Context *ctx, JITState *jit_state)

static Context *jit_schedule_wait_cp(Context *ctx, JITState *jit_state)

enum TrapAndLoadResult jit_trap_and_load(Context *ctx, Module *mod, uint32_t label)

Trap a process and load module, process shall be resumed at given label.

Parameters:

ctx – the process to trap
mod – the module to load
label – the label to resume the process to

static Context *jit_call_ext(Context *ctx, JITState *jit_state, int offset, int arity, int index, int n_words)

static term jit_module_get_atom_term_by_id(JITState *jit_state, int atom_index)

static bool jit_allocate(Context *ctx, JITState *jit_state, uint32_t stack_need, uint32_t heap_need, uint32_t live)

static BifImpl0 jit_get_imported_bif(JITState *jit_state, uint32_t bif)

static bool jit_deallocate(Context *ctx, JITState *jit_state, uint32_t n_words)

static TermCompareResult jit_term_compare(Context *ctx, JITState *jit_state, term t, term other, TermCompareOpts opts)

static bool jit_test_heap(Context *ctx, JITState *jit_state, uint32_t heap_need, uint32_t live_registers)

static term jit_put_list(Context *ctx, term head, term tail)

static term jit_module_load_literal(Context *ctx, JITState *jit_state, int index)

static term jit_alloc_boxed_integer_fragment(Context *ctx, avm_int64_t value)

static term maybe_alloc_boxed_integer_fragment(Context *ctx, avm_int64_t value)

static term jit_alloc_big_integer_fragment(Context *ctx, size_t digits_len, term_integer_sign_t sign)

static term jit_term_alloc_tuple(Context *ctx, uint32_t size)

static term jit_term_alloc_fun(Context *ctx, JITState *jit_state, uint32_t fun_index, uint32_t numfree)

static bool jit_send(Context *ctx, JITState *jit_state)

static term *jit_extended_register_ptr(Context *ctx, unsigned int index)

static Context *jit_process_signal_messages(Context *ctx, JITState *jit_state)

static term jit_mailbox_peek(Context *ctx)

static void jit_mailbox_remove_message(Context *ctx)

static void jit_timeout(Context *ctx)

static void jit_mailbox_next(Context *ctx)

static void jit_cancel_timeout(Context *ctx)

static void jit_clear_timeout_flag(Context *ctx)

static Context *jit_wait_timeout(Context *ctx, JITState *jit_state, term timeout, int label)

static Context *jit_wait_timeout_trap_handler(Context *ctx, JITState *jit_state, int label)

static bool maybe_call_native(Context *ctx, atom_index_t module_name, atom_index_t function_name, int arity, term *return_value)

static Context *jit_call_fun(Context *ctx, JITState *jit_state, int offset, term fun, unsigned int args_count)

static term jit_term_from_float(Context *ctx, int freg)

static void jit_term_conv_to_float(Context *ctx, term t, int freg)

static bool jit_fadd(Context *ctx, int freg1, int freg2, int freg3)

static bool jit_fsub(Context *ctx, int freg1, int freg2, int freg3)

static bool jit_fmul(Context *ctx, int freg1, int freg2, int freg3)

static bool jit_fdiv(Context *ctx, int freg1, int freg2, int freg3)

static void jit_fnegate(Context *ctx, int freg1, int freg2)

static bool jit_catch_end(Context *ctx, JITState *jit_state)

static bool jit_memory_ensure_free_with_roots(Context *ctx, JITState *jit_state, int sz, int live, int flags)

static term jit_term_alloc_bin_match_state(Context *ctx, term src, int slots)

static term make_bigint_from_digits(Context *ctx, JITState *jit_state, intn_digit_t *bigint, intn_integer_sign_t sign, int count)

static term extract_bigint(Context *ctx, JITState *jit_state, const uint8_t *bytes, size_t bytes_size, intn_from_integer_options_t opts)

static term jit_bitstring_extract_integer(Context *ctx, JITState *jit_state, term *bin_ptr, size_t offset, int n, int bs_flags)

static term jit_bitstring_extract_float(Context *ctx, term *bin_ptr, size_t offset, int n, int bs_flags)

static size_t jit_term_sub_binary_heap_size(term *bin_ptr, size_t size)

static term jit_term_maybe_create_sub_binary(Context *ctx, term binary, size_t offset, size_t len)

static int jit_term_find_map_pos(Context *ctx, term map, term key)

static int jit_bitstring_utf8_size(int c)

static int jit_bitstring_utf16_size(int c)

static term jit_term_create_empty_binary(Context *ctx, size_t len)

static term jit_term_reuse_binary(Context *ctx, term src, size_t len)

static int jit_decode_flags_list(Context *ctx, JITState *jit_state, term flags)

static int jit_bitstring_insert_utf8(term bin, size_t offset, int c)

static int jit_bitstring_insert_utf16(term bin, size_t offset, int c, enum BitstringFlags flags)

static bool jit_bitstring_insert_integer(term bin, size_t offset, term value, size_t n, enum BitstringFlags flags)

static bool jit_bitstring_insert_float(term bin, size_t offset, term value, size_t n, enum BitstringFlags flags)

static void jit_bitstring_copy_module_str(Context *ctx, JITState *jit_state, term bin, size_t offset, int str_id, size_t len)

static int jit_bitstring_copy_binary(Context *ctx, JITState *jit_state, term t, size_t offset, term src, term size)

static Context *jit_apply(Context *ctx, JITState *jit_state, int offset, term module, term function, unsigned int arity)

static void *jit_malloc(Context *ctx, JITState *jit_state, size_t sz)

static bool sort_kv_pairs(term *kv, int size, GlobalContext *global)

static term jit_put_map_assoc(Context *ctx, JITState *jit_state, term src, size_t new_entries, size_t num_elements, term *kv)

static int jit_module_get_fun_arity(Module *fun_module, uint32_t fun_index)

static bool jit_bitstring_match_module_str(Context *ctx, JITState *jit_state, term bs_bin, size_t bs_offset, int str_id, size_t bits)

static term jit_bitstring_get_utf8(term src)

static term jit_bitstring_get_utf16(term src, int flags_value)

static term jit_bitstring_get_utf32(term src, int flags_value)

static term term_copy_map(Context *ctx, term src)

static term jit_stacktrace_build(Context *ctx)

void __attribute__ ((noinline))

void jit_debug_register_code(Module *mod, const void *native_code, size_t native_size, ModuleNativeEntryPoint entry_point)

Register JIT-compiled code with debug info with GDB/LLDB.

This function registers native code and associated DWARF debug information with the debugger using the GDB JIT interface. This allows debuggers to show function names and source line information for JIT code.

Parameters:

mod – The module containing the JIT code
native_code – Pointer to the native machine code
native_size – Size of the native code in bytes
entry_point – The actual mapped entry point address

void jit_debug_unregister_code(Context *ctx, Module *mod)

Unregister JIT-compiled code from debugger.

This function unregisters previously registered JIT code from the debugger. Should be called when a module is unloaded.

Parameters:

ctx – The context
mod – The module being unloaded

Variables

const ModuleNativeInterface module_native_interface

struct jit_descriptor __jit_debug_descriptor = {1, 0, NULL, NULL}

struct Elf_Ehdr

Public Members

unsigned char e_ident[16]

uint16_t e_type

uint16_t e_machine

uint32_t e_version

uint32_t e_entry

uint32_t e_phoff

uint32_t e_shoff

uint32_t e_flags

uint16_t e_ehsize

uint16_t e_phentsize

uint16_t e_phnum

uint16_t e_shentsize

uint16_t e_shnum

uint16_t e_shstrndx

struct Elf_Shdr

Public Members

uint32_t sh_name

uint32_t sh_type

uint32_t sh_flags

uint32_t sh_addr

uint32_t sh_offset

uint32_t sh_size

uint32_t sh_link

uint32_t sh_info

uint32_t sh_addralign

uint32_t sh_entsize

struct jit_code_entry

Collaboration diagram for jit_code_entry:

Public Members

struct jit_code_entry *next_entry

struct jit_code_entry *prev_entry

const char *symfile_addr

uint64_t symfile_size

struct jit_descriptor

Collaboration diagram for jit_descriptor:

Public Members

uint32_t version

uint32_t action_flag

struct jit_code_entry *relevant_entry

struct jit_code_entry *first_entry