Is it possible to change the value type ?

[kdilayer]

I'm new to libjit ... so a question:

Is it possible to return different value types from different branches in the same function or block?

In the example below I have used internal types but in my real case I would be using custom tagged types.

See example below - and I found this example in the archives: (https://lists.gnu.org/archive/html/libjit/2021-07/msg00001.html)

top--;
jit_insn_branch_if_not(function, stack[top], &label1);

jit_value_t common = jit_value_create(function, jit_type_int);  /*** dont know which type will be return yet*/

/* true */
tmp = jit_value_create_float64_constant(function, jit_type_float64, 100); /*** this branch will return jit_type_float64*/
jit_insn_store(function, common, tmp);

/* go to end */
jit_insn_branch(function, &label2);

/* label1 */
jit_insn_label(function, &label1);

/* false */
tmp = jit_value_create_nint_constant(function, jit_type_int, 200); /**** this branch will return jit_type_int*/
jit_insn_store(function, common, tmp);

/* label2 end */
jit_insn_label(function, &label2);

/* fill the stack top */
stack[top] = jit_insn_load(function, common);
top++;

/* return */
top--;
jit_insn_return(function, stack[top]);

[ademakov]

Any function has certain return type that is specified by the function signature. This may be just one type by definition.

I believe you can try a union type to achieve what you want.

[kdilayer]

Thanks for the answer!

[kdilayer]

I'm not sure how enum's would help here.

I have implemented an array (host code). Each member in the array can be different native types (like int, long, char*).
for example array = [1, "hello", 2]

The below function is used to get one member from the array. But I'm not sure how to convert the return_value variable to the proper jit_type_xxx.

For example if the first member of the array is a long - the below function should return a value of type jit_type_long (it now returns a type of jit_type_void_ptr (because I'm using insn_alloca). The data itself is stored correctly but the type of the value is not.

So how can I convert the jit_type_void_ptr type to jit_type_long or something else ?

jit_value array_get_member(jit_value array, jit_value idx) {
        jit_value args[] = { array, idx };
        jit_value member_size = insn_call_native("_native_array_get_member_size", 
            (void*)(&_native_array_get_member_size), 
            signature_helper(jit_type_int, jit_type_void_ptr, jit_type_int, jit_function::end_params), 
            (_jit_value **)&args, sizeof(args) / sizeof(jit_value), 
            0);
        jit_value member_type = insn_call_native("_native_array_get_member_type", 
            (void*)(&_native_array_get_member_type), 
            signature_helper(jit_type_int, jit_type_void_ptr, jit_type_int, jit_function::end_params), 
            (_jit_value **)&args, sizeof(args) / sizeof(jit_value), 
            0);  
        jit_value return_value = insn_alloca(member_size);  

        jit_value vtype_long = new_constant(1); //long
        jit_value vtype_cstring = new_constant(2); //cstring

        jit_label label_islong, label_iscstring, label_done;

        insn_branch_if(member_type == vtype_long, label_islong);
        insn_branch_if(member_type == vtype_cstring, label_iscstring);
        insn_branch(label_done);

        insn_label(label_islong);
            jit_value retval_long_tmp = insn_call_native("_native_array_get_member_long", (void*)(&_native_array_get_member_long), this->signature_helper(jit_type_long, jit_type_void_ptr, jit_type_int, jit_function::end_params), (_jit_value **)&args, sizeof(args) / sizeof(jit_value), JIT_CALL_TAIL);                           
            insn_store_relative(return_value, 0, retval_long_tmp);
            insn_branch(label_done);

        insn_label(label_iscstring);
            jit_value retval_cstring_tmp = insn_call_native("_native_array_get_member_cstring", (void*)(&_native_array_get_member_cstring), this->signature_helper(jsjit_type_cstring, jit_type_void_ptr, jit_type_int, jit_function::end_params), (_jit_value **)&args, sizeof(args) / sizeof(jit_value), JIT_CALL_TAIL);                           
            insn_store_relative(return_value, 0, retval_cstring_tmp);
            insn_branch(label_done);

        insn_label(label_done);
        return return_value;
}

[M4GNV5]

It looks like you are using alloca wrong.
In C logic your generated code basically does:

void *return_value = alloca(size);
return_value = _native_array_get_member_long(array, idx);

So you are basically overwriting the pointer to the alloca'd memory region right after creation. What you probably actually want is something like this:

void *return_value = alloca(size);
memcpy(return_value, array + offset, member_size);

In libjit you can use jit_insn_memcpy for this:

jit_value return_value = insn_alloca(member_size);
jit_value offset = _somehow_get_offset(); // maybe just idx * member_size?
jit_value ptr = jit_insn_add(func, array, offset);
jit_insn_memcpy(func, return_value, ptr, member_size);
return return_value;

Anyways regarding your original question (which might or might not help you):
Converting the type of a value from e.g. void_ptr to long without doing actual conversions (e.g. float to int) can be done just like in C:

void *some_val = ...;
long long_val = *(long *)&some_val;

However in libjit in reality all integer types can just be converted using jit_insn_convert. Only for casting from float to int and back you need to get the address.
For this normally called reinterpret cast I wrote a helper in my toy language:
https://github.com/M4GNV5/PointerScript/blob/ce615458729638d8c1d4b06c54634334e4f739f5/jit/lib/util.c#L281-L298