/*
uint32_t convert_opcode(char* opcode)
{
if (strcmp(opcode, "mov") == 0)
return 0;
if (strcmp(opcode, "sload") == 0)
return 1;
if (strcmp(opcode, "sstore") == 0)
return 2;
if (strcmp(opcode, "add") == 0)
return 3;
if (strcmp(opcode, "mult") == 0)
return 4;
if (strcmp(opcode, "div") == 0)
return 5;
if (strcmp(opcode, "nand") == 0)
return 6;
if (strcmp(opcode, "halt") == 0)
return 7;
if (strcmp(opcode, "map") == 0)
return 8;
if (strcmp(opcode, "umap") == 0)
return 9;
if (strcmp(opcode, "out") == 0)
return 10;
if (strcmp(opcode, "in") == 0)
return 11;
if (strcmp(opcode, "loadp") == 0)
return 12;
if (strcmp(opcode, "loadv") == 0)
return 13;
return -1;
}
*/
Um_instruction make_inst(unsigned opcode, unsigned value, unsigned ra, unsigned rb, unsigned rc)
{
Um_instruction instruction = 0;
if (opcode == 13) {
return load_value(opcode, value, ra);
}
// fprintf(stderr, "%u %u %u %u %u\n", opcode, value, ra, rb, rc);
/*
instruction = Bitpack_newu(instruction, 4, 0, opcode);
instruction = Bitpack_newu(instruction, 3, 23, ra);
instruction = Bitpack_newu(instruction, 3, 25, rb);
instruction = Bitpack_newu(instruction, 3, 28, rc);
*/
instruction = Bitpack_newu(instruction, 4, 28, opcode);
instruction = Bitpack_newu(instruction, 3, 6, ra);
instruction = Bitpack_newu(instruction, 3, 3, rb);
instruction = Bitpack_newu(instruction, 3, 0, rc);
// fprintf(stderr, "normal: %u\n", instruction);
return instruction;
//return reverse(instruction);
}
int load_value_list (FILE *f, value_list *vl, string *lnames)
{ int ix, size;
value_list nvl;
if (!load_int (f, &size)) return (0);
nvl = new_value_list (size);
nvl -> size = size;
nvl -> room = size;
for (ix = 0; ix < size; ix++)
if (!load_value (f, &nvl -> array[ix], lnames)) return (0);
*vl = nvl;
return (1);
};
bool c_seq::init()
{
m_effective = time(0) + c_server::get_instance()->object_effective();
c_wlock lock(&m_lock);
if (m_init)
return true;
string value;
_zmsg_head* head = NULL;
if (c_base::get_value(m_key, value, &head) == 0)
{
if (!load_value(value, head))
{
return false;
}
}
m_init = true;
return true;
}
int luabins_load(
lua_State * L,
const unsigned char * data,
size_t len,
int * count
)
{
lbs_LoadState ls;
int result = LUABINS_ESUCCESS;
unsigned char num_items = 0;
int base = 0;
int i = 0;
base = lua_gettop(L);
lbsLS_init(&ls, data, len);
num_items = lbsLS_readbyte(&ls);
if (!lbsLS_good(&ls))
{
SPAM(("load: failed to read num_items byte\n"));
result = LUABINS_EBADDATA;
}
else if (num_items > LUABINS_MAXTUPLE)
{
SPAM(("load: tuple too large: %d\n", (int)num_items));
result = LUABINS_EBADSIZE;
}
else
{
XSPAM(("* load: tuple size %d\n", (int)num_items));
for (
i = 0;
i < num_items && result == LUABINS_ESUCCESS;
++i
)
{
XSPAM(("* load: loading tuple item %d\n", i));
result = load_value(L, &ls);
}
}
if (result == LUABINS_ESUCCESS && lbsLS_unread(&ls) > 0)
{
SPAM(("load: %lu chars left at tail\n", lbsLS_unread(&ls)));
result = LUABINS_ETAILEFT;
}
if (result == LUABINS_ESUCCESS)
{
*count = num_items;
}
else
{
lua_settop(L, base); /* Discard intermediate results */
switch (result)
{
case LUABINS_EBADDATA:
lua_pushliteral(L, "can't load: corrupt data");
break;
case LUABINS_EBADSIZE:
lua_pushliteral(L, "can't load: corrupt data, bad size");
break;
case LUABINS_ETAILEFT:
lua_pushliteral(L, "can't load: extra data at end");
break;
default: /* Should not happen */
lua_pushliteral(L, "load failed");
break;
}
}
return result;
}
static int load_table(lua_State * L, lbs_LoadState * ls)
{
int array_size = 0;
int hash_size = 0;
unsigned int total_size = 0;
int result = lbsLS_readbytes(ls, (unsigned char *)&array_size, LUABINS_LINT);
if (result == LUABINS_ESUCCESS)
{
result = lbsLS_readbytes(ls, (unsigned char *)&hash_size, LUABINS_LINT);
}
if (result == LUABINS_ESUCCESS)
{
total_size = array_size + hash_size;
/*
SPAM((
"LT SIZE CHECK\n"
"* array_size %d limit 0 .. %d\n"
"* hash_size %d limit >0\n"
"* hash_size bytes %d, limit %d\n"
"* unread %u limit >min_size %u (total_size %u)\n",
array_size, MAXASIZE,
hash_size,
ceillog2((unsigned int)hash_size), MAXBITS,
(unsigned int)lbsLS_unread(ls),
(unsigned int)luabins_min_table_data_size(total_size),
(unsigned int)total_size
));
*/
if (
array_size < 0 || array_size > MAXASIZE ||
hash_size < 0 ||
(hash_size > 0 && ceillog2((unsigned int)hash_size) > MAXBITS) ||
lbsLS_unread(ls) < luabins_min_table_data_size(total_size)
)
{
result = LUABINS_EBADSIZE;
}
}
if (result == LUABINS_ESUCCESS)
{
unsigned int i = 0;
XSPAM((
"* load: creating table a:%d + h:%d = %d\n",
array_size, hash_size, total_size
));
lua_createtable(L, array_size, hash_size);
for (i = 0; i < total_size; ++i)
{
int key_type = LUA_TNONE;
result = load_value(L, ls); /* Load key. */
if (result != LUABINS_ESUCCESS)
{
break;
}
/* Table key can't be nil or NaN */
key_type = lua_type(L, -1);
if (key_type == LUA_TNIL)
{
/* Corrupt data? */
SPAM(("load: nil as key detected\n"));
result = LUABINS_EBADDATA;
break;
}
if (key_type == LUA_TNUMBER)
{
lua_Number key = lua_tonumber(L, -1);
if (luai_numisnan(key))
{
/* Corrupt data? */
SPAM(("load: NaN as key detected\n"));
result = LUABINS_EBADDATA;
break;
}
}
result = load_value(L, ls); /* Load value. */
if (result != LUABINS_ESUCCESS)
{
break;
}
lua_rawset(L, -3);
}
}
return result;
}
// Unpack this generator from a character buffer
int LCG64::unpack_rng( char* packed )
{
std::size_t nbytes, offset = 0;
int generator_type;
std::string sub_string;
// Load the generator type
nbytes = sizeof( generator_type );
sub_string.assign( packed, nbytes );
load_value( sub_string, generator_type );
d_rng_type = intToGeneratorType( generator_type );
packed += nbytes;
// Load the generator description (not packed because always the same)
d_gentype = GENTYPE;
// Load the stream number
nbytes = sizeof( d_stream_number );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_stream_number );
packed += nbytes;
// Load the initial seed
nbytes = sizeof( d_init_seed );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_init_seed );
packed += nbytes;
// Load the parameter
nbytes = sizeof( d_parameter );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_parameter );
packed += nbytes;
// Load the spawn offset
nbytes = sizeof( d_spawn_offset );
sub_string.assign( packed, nbytes );
load_value( sub_string , d_spawn_offset );
packed += nbytes;
// Load the prime
nbytes = sizeof( d_prime );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_prime );
packed += nbytes;
// Load the state
nbytes = sizeof( d_state );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_state );
packed += nbytes;
// Load the multiplier
nbytes = sizeof( d_multiplier );
sub_string.assign( packed, nbytes );
load_value( sub_string, d_multiplier );
packed += nbytes;
// Increment the number of streams
LCG64::increment_number_of_streams();
return 1;
}
/*@
* @deftypefun void _jit_gen_insn (jit_gencode_t @var{gen}, jit_function_t @var{func}, jit_block_t @var{block}, jit_insn_t @var{insn})
* Generate native code for the specified @var{insn}. This function should
* call the appropriate register allocation routines, output the instruction,
* and then arrange for the result to be placed in an appropriate register
* or memory destination.
* @end deftypefun
@*/
void _jit_gen_insn(jit_gencode_t gen, jit_function_t func,
jit_block_t block, jit_insn_t insn)
{
jit_label_t label;
void **pc;
jit_nint offset;
jit_nint size;
switch(insn->opcode)
{
case JIT_OP_BR_IEQ:
case JIT_OP_BR_INE:
case JIT_OP_BR_ILT:
case JIT_OP_BR_ILT_UN:
case JIT_OP_BR_ILE:
case JIT_OP_BR_ILE_UN:
case JIT_OP_BR_IGT:
case JIT_OP_BR_IGT_UN:
case JIT_OP_BR_IGE:
case JIT_OP_BR_IGE_UN:
case JIT_OP_BR_LEQ:
case JIT_OP_BR_LNE:
case JIT_OP_BR_LLT:
case JIT_OP_BR_LLT_UN:
case JIT_OP_BR_LLE:
case JIT_OP_BR_LLE_UN:
case JIT_OP_BR_LGT:
case JIT_OP_BR_LGT_UN:
case JIT_OP_BR_LGE:
case JIT_OP_BR_LGE_UN:
case JIT_OP_BR_FEQ:
case JIT_OP_BR_FNE:
case JIT_OP_BR_FLT:
case JIT_OP_BR_FLE:
case JIT_OP_BR_FGT:
case JIT_OP_BR_FGE:
case JIT_OP_BR_FLT_INV:
case JIT_OP_BR_FLE_INV:
case JIT_OP_BR_FGT_INV:
case JIT_OP_BR_FGE_INV:
case JIT_OP_BR_DEQ:
case JIT_OP_BR_DNE:
case JIT_OP_BR_DLT:
case JIT_OP_BR_DLE:
case JIT_OP_BR_DGT:
case JIT_OP_BR_DGE:
case JIT_OP_BR_DLT_INV:
case JIT_OP_BR_DLE_INV:
case JIT_OP_BR_DGT_INV:
case JIT_OP_BR_DGE_INV:
case JIT_OP_BR_NFEQ:
case JIT_OP_BR_NFNE:
case JIT_OP_BR_NFLT:
case JIT_OP_BR_NFLE:
case JIT_OP_BR_NFGT:
case JIT_OP_BR_NFGE:
case JIT_OP_BR_NFLT_INV:
case JIT_OP_BR_NFLE_INV:
case JIT_OP_BR_NFGT_INV:
case JIT_OP_BR_NFGE_INV:
/* Binary branch */
load_value(gen, insn->value2, 2);
/* Fall through */
case JIT_OP_BR_IFALSE:
case JIT_OP_BR_ITRUE:
case JIT_OP_BR_LFALSE:
case JIT_OP_BR_LTRUE:
/* Unary branch */
load_value(gen, insn->value1, 1);
/* Fall through */
case JIT_OP_BR:
case JIT_OP_CALL_FINALLY:
/* Unconditional branch */
branch:
label = (jit_label_t)(insn->dest);
pc = (void **)(gen->ptr);
jit_cache_opcode(gen, insn->opcode);
block = jit_block_from_label(func, label);
if(!block)
{
break;
}
if(block->address)
{
/* We already know the address of the block */
jit_cache_native(gen, ((void **)(block->address)) - pc);
}
else
{
/* Record this position on the block's fixup list */
jit_cache_native(gen, block->fixup_list);
block->fixup_list = (void *)pc;
}
break;
case JIT_OP_CALL_FILTER:
/* Branch to a filter subroutine, load the filter
parameter to the r0 register */
load_value(gen, insn->value1, 0);
goto branch;
case JIT_OP_JUMP_TABLE:
{
jit_label_t *labels;
jit_nint num_labels;
jit_nint index;
load_value(gen, insn->dest, 0);
labels = (jit_label_t *) insn->value1->address;
num_labels = insn->value2->address;
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, num_labels);
for(index = 0; index < num_labels; index++)
{
block = jit_block_from_label(func, labels[index]);
if(!block)
{
return;
}
if(block->address)
{
/* We already know the address of the block */
jit_cache_native(gen, block->address);
}
else
{
/* Record this position on the block's fixup list */
pc = (void **)(gen->ptr);
jit_cache_native(gen, block->fixup_absolute_list);
block->fixup_absolute_list = pc;
}
}
break;
}
case JIT_OP_ADDRESS_OF_LABEL:
/* Get the address of a particular label */
label = (jit_label_t)(insn->value1);
block = jit_block_from_label(func, label);
if(!block)
{
break;
}
pc = (void **)(gen->ptr);
jit_cache_opcode(gen, insn->opcode);
if(block->address)
{
/* We already know the address of the block */
jit_cache_native(gen, ((void **)(block->address)) - pc);
}
else
{
/* Record this position on the block's fixup list */
jit_cache_native(gen, block->fixup_list);
block->fixup_list = (void *)pc;
}
store_value(gen, insn->dest);
break;
case JIT_OP_CALL:
case JIT_OP_CALL_TAIL:
/* Call a function, whose pointer is supplied explicitly */
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, (jit_nint)(insn->dest));
break;
case JIT_OP_CALL_INDIRECT:
case JIT_OP_CALL_INDIRECT_TAIL:
/* Call a function, whose pointer is supplied in the register */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, (jit_nint)(insn->value2));
jit_cache_native(gen, (jit_nint)
(jit_type_num_params((jit_type_t)(insn->value2))));
break;
case JIT_OP_CALL_VTABLE_PTR:
case JIT_OP_CALL_VTABLE_PTR_TAIL:
/* Call a function, whose vtable pointer is supplied in the register */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
break;
case JIT_OP_CALL_EXTERNAL:
case JIT_OP_CALL_EXTERNAL_TAIL:
/* Call a native function, whose pointer is supplied explicitly */
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, (jit_nint)(insn->value2));
jit_cache_native(gen, (jit_nint)(insn->dest));
jit_cache_native(gen, (jit_nint)
(jit_type_num_params((jit_type_t)(insn->value2))));
break;
case JIT_OP_RETURN:
/* Return from the current function with no result */
jit_cache_opcode(gen, JIT_OP_RETURN);
break;
case JIT_OP_RETURN_INT:
case JIT_OP_RETURN_LONG:
case JIT_OP_RETURN_FLOAT32:
case JIT_OP_RETURN_FLOAT64:
case JIT_OP_RETURN_NFLOAT:
/* Return from the current function with a specific result */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
break;
case JIT_OP_RETURN_SMALL_STRUCT:
/* Return from current function with a small structure result */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, jit_value_get_nint_constant(insn->value2));
break;
case JIT_OP_SETUP_FOR_NESTED:
/* TODO!!! */
/* Set up to call a nested child */
jit_cache_opcode(gen, insn->opcode);
adjust_working(gen, 2);
break;
case JIT_OP_SETUP_FOR_SIBLING:
/* TODO!!! */
/* Set up to call a nested sibling */
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, jit_value_get_nint_constant(insn->value1));
adjust_working(gen, 2);
break;
case JIT_OP_IMPORT:
/* Import a local variable from an outer nested scope */
_jit_gen_fix_value(insn->value1);
if(insn->value1->frame_offset >= 0)
{
jit_cache_opcode(gen, JIT_INTERP_OP_IMPORT_LOCAL);
jit_cache_native(gen, insn->value1->frame_offset);
jit_cache_native(gen, jit_value_get_nint_constant(insn->value2));
}
else
{
jit_cache_opcode(gen, JIT_INTERP_OP_IMPORT_ARG);
jit_cache_native(gen, -(insn->value1->frame_offset + 1));
jit_cache_native(gen, jit_value_get_nint_constant(insn->value2));
}
store_value(gen, insn->dest);
break;
case JIT_OP_THROW:
/* Throw an exception */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
break;
case JIT_OP_LOAD_PC:
case JIT_OP_LOAD_EXCEPTION_PC:
/* Load the current program counter onto the stack */
jit_cache_opcode(gen, insn->opcode);
store_value(gen, insn->dest);
break;
case JIT_OP_CALL_FILTER_RETURN:
/* The r0 register currently contains "dest" */
store_value(gen, insn->dest);
break;
case JIT_OP_ENTER_FINALLY:
/* Record that the finally return address is on the stack */
++(gen->extra_working_space);
break;
case JIT_OP_LEAVE_FINALLY:
/* Leave a finally clause */
jit_cache_opcode(gen, insn->opcode);
break;
case JIT_OP_ENTER_FILTER:
/* The top of the stack contains the return address,
the r0 register contains the "dest" (filter parameter). */
++(gen->extra_working_space);
store_value(gen, insn->dest);
break;
case JIT_OP_LEAVE_FILTER:
/* Leave a filter clause, returning a particular value */
load_value(gen, insn->value1, 0);
jit_cache_opcode(gen, insn->opcode);
break;
case JIT_OP_INCOMING_REG:
/* Store incoming value (in interpreter this is used to
pass an exception object to the catcher) */
store_value(gen, insn->value1);
break;
case JIT_OP_RETURN_REG:
/* Push a function return value back onto the stack */
switch(jit_type_normalize(insn->value1->type)->kind)
{
case JIT_TYPE_SBYTE:
case JIT_TYPE_UBYTE:
case JIT_TYPE_SHORT:
case JIT_TYPE_USHORT:
case JIT_TYPE_INT:
case JIT_TYPE_UINT:
jit_cache_opcode(gen, JIT_INTERP_OP_LDR_0_INT);
store_value(gen, insn->value1);
break;
case JIT_TYPE_LONG:
case JIT_TYPE_ULONG:
jit_cache_opcode(gen, JIT_INTERP_OP_LDR_0_LONG);
store_value(gen, insn->value1);
break;
case JIT_TYPE_FLOAT32:
jit_cache_opcode(gen, JIT_INTERP_OP_LDR_0_FLOAT32);
store_value(gen, insn->value1);
break;
case JIT_TYPE_FLOAT64:
jit_cache_opcode(gen, JIT_INTERP_OP_LDR_0_FLOAT64);
store_value(gen, insn->value1);
break;
case JIT_TYPE_NFLOAT:
jit_cache_opcode(gen, JIT_INTERP_OP_LDR_0_NFLOAT);
store_value(gen, insn->value1);
break;
}
break;
case JIT_OP_COPY_LOAD_SBYTE:
case JIT_OP_COPY_LOAD_UBYTE:
case JIT_OP_COPY_LOAD_SHORT:
case JIT_OP_COPY_LOAD_USHORT:
case JIT_OP_COPY_INT:
case JIT_OP_COPY_LONG:
case JIT_OP_COPY_FLOAT32:
case JIT_OP_COPY_FLOAT64:
case JIT_OP_COPY_NFLOAT:
case JIT_OP_COPY_STORE_BYTE:
case JIT_OP_COPY_STORE_SHORT:
/* Copy a value from one temporary variable to another */
load_value(gen, insn->value1, 0);
store_value(gen, insn->dest);
break;
case JIT_OP_COPY_STRUCT:
/* Copy a struct from one address to another */
load_value(gen, insn->dest, 0);
load_value(gen, insn->value1, 1);
size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->dest));
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, size);
break;
case JIT_OP_ADDRESS_OF:
/* Get the address of a local variable */
_jit_gen_fix_value(insn->value1);
if(insn->value1->frame_offset >= 0)
{
jit_cache_opcode(gen, JIT_INTERP_OP_LDLA_0);
jit_cache_native(gen, insn->value1->frame_offset);
}
else
{
jit_cache_opcode(gen, JIT_INTERP_OP_LDAA_0);
jit_cache_native(gen, -(insn->value1->frame_offset + 1));
}
store_value(gen, insn->dest);
break;
case JIT_OP_PUSH_INT:
case JIT_OP_PUSH_LONG:
case JIT_OP_PUSH_FLOAT32:
case JIT_OP_PUSH_FLOAT64:
case JIT_OP_PUSH_NFLOAT:
/* Push an item onto the stack, ready for a function call */
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
adjust_working(gen, 1);
break;
case JIT_OP_PUSH_STRUCT:
/* Load the pointer value */
load_value(gen, insn->value1, 1);
/* Push the structure at the designated pointer */
size = jit_value_get_nint_constant(insn->value2);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, size);
adjust_working(gen, JIT_NUM_ITEMS_IN_STRUCT(size));
break;
case JIT_OP_PUSH_RETURN_AREA_PTR:
/* Push the address of the interpreter's return area */
jit_cache_opcode(gen, insn->opcode);
adjust_working(gen, 1);
break;
case JIT_OP_POP_STACK:
/* Pop parameter values from the stack after a function returns */
size = jit_value_get_nint_constant(insn->value1);
if(size == 1)
{
jit_cache_opcode(gen, JIT_INTERP_OP_POP);
}
else if(size == 2)
{
jit_cache_opcode(gen, JIT_INTERP_OP_POP_2);
}
else if(size == 3)
{
jit_cache_opcode(gen, JIT_INTERP_OP_POP_3);
}
else if(size != 0)
{
jit_cache_opcode(gen, JIT_OP_POP_STACK);
jit_cache_native(gen, size);
}
break;
case JIT_OP_FLUSH_SMALL_STRUCT:
/* Flush a small structure return value back into the frame */
load_value(gen, insn->value1, 0);
size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->value1));
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, size);
break;
case JIT_OP_LOAD_RELATIVE_SBYTE:
case JIT_OP_LOAD_RELATIVE_UBYTE:
case JIT_OP_LOAD_RELATIVE_SHORT:
case JIT_OP_LOAD_RELATIVE_USHORT:
case JIT_OP_LOAD_RELATIVE_INT:
case JIT_OP_LOAD_RELATIVE_LONG:
case JIT_OP_LOAD_RELATIVE_FLOAT32:
case JIT_OP_LOAD_RELATIVE_FLOAT64:
case JIT_OP_LOAD_RELATIVE_NFLOAT:
/* Load a value from a relative pointer */
load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, offset);
store_value(gen, insn->dest);
break;
case JIT_OP_LOAD_RELATIVE_STRUCT:
/* Load a structured value from a relative pointer */
load_value(gen, insn->dest, 0);
load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->dest));
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, offset);
jit_cache_native(gen, size);
break;
case JIT_OP_STORE_RELATIVE_BYTE:
case JIT_OP_STORE_RELATIVE_SHORT:
case JIT_OP_STORE_RELATIVE_INT:
case JIT_OP_STORE_RELATIVE_LONG:
case JIT_OP_STORE_RELATIVE_FLOAT32:
case JIT_OP_STORE_RELATIVE_FLOAT64:
case JIT_OP_STORE_RELATIVE_NFLOAT:
/* Store a value to a relative pointer */
load_value(gen, insn->dest, 0);
load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, offset);
break;
case JIT_OP_STORE_RELATIVE_STRUCT:
/* Store a structured value to a relative pointer */
load_value(gen, insn->dest, 0);
load_value(gen, insn->value1, 1);
offset = jit_value_get_nint_constant(insn->value2);
size = (jit_nint)jit_type_get_size(jit_value_get_type(insn->value1));
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, offset);
jit_cache_native(gen, size);
break;
case JIT_OP_ADD_RELATIVE:
/* Add a relative offset to a pointer */
offset = jit_value_get_nint_constant(insn->value2);
if(offset != 0)
{
load_value(gen, insn->value1, 1);
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, offset);
store_value(gen, insn->dest);
}
else
{
load_value(gen, insn->value1, 0);
store_value(gen, insn->dest);
}
break;
case JIT_OP_MARK_BREAKPOINT:
/* Mark the current location as a potential breakpoint */
jit_cache_opcode(gen, insn->opcode);
jit_cache_native(gen, insn->value1->address);
jit_cache_native(gen, insn->value2->address);
break;
default:
if(insn->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE) != 0)
{
load_value(gen, insn->dest, 0);
}
if(insn->value1)
{
load_value(gen, insn->value1, 1);
}
if(insn->value2)
{
load_value(gen, insn->value2, 2);
}
jit_cache_opcode(gen, insn->opcode);
if(insn->dest && (insn->flags & JIT_INSN_DEST_IS_VALUE) == 0)
{
store_value(gen, insn->dest);
}
break;
}
}
int main(void) {
matrix_t* m = create_matrix(3, 3);
load_value(m, 0, 0, 1.0);
load_value(m, 0, 1, 2.0);
load_value(m, 0, 2, 3.0);
load_value(m, 1, 0, 4.0);
load_value(m, 1, 1, 5.0);
load_value(m, 1, 2, 6.1);
load_value(m, 2, 0, 3.0);
load_value(m, 2, 1, 2.0);
load_value(m, 2, 2, 1.0);
matrix_t* m1 = create_matrix(3, 3);
load_value(m1, 0, 0, 1.0);
load_value(m1, 0, 1, 0.0);
load_value(m1, 0, 2, 0.0);
load_value(m1, 1, 0, 0.0);
load_value(m1, 1, 1, 1.0);
load_value(m1, 1, 2, 0.0);
load_value(m1, 2, 0, 0.0);
load_value(m1, 2, 1, 0.0);
load_value(m1, 2, 2, 1.0);
print_matrix_std_o(m);
printf("\n");
print_matrix_std_o(m1);
printf("\n");
matrix_t* result = matrix_multiply(m, m1);
print_matrix_std_o(result);
destroy_matrix(m);
destroy_matrix(m1);
destroy_matrix(result);
return EXIT_SUCCESS;
}
