gnh1201/wasm-micro-runtime
1
0
Fork 0
mirror of https://github.com/bytecodealliance/wasm-micro-runtime.git synced 2025-02-06 15:05:19 +00:00
Code Issues Actions 9 Packages Projects Releases Wiki Activity
376385c608
wasm-micro-runtime/core/iwasm/compilation/aot_emit_gc.c
Benbuck Nason 1c2a8fca4e
Fix some more spelling issues (#3393)
2024-05-08 09:30:29 +08:00

2145 lines
69 KiB
C
Raw Blame History

/*
* Copyright (C) 2019 Intel Corporation. All rights reserved.
* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
*/
#include "aot_emit_gc.h"
#include "aot_compiler.h"
#include "aot_emit_exception.h"
#if WASM_ENABLE_GC != 0
#define BUILD_ISNULL(ptr, res, name) \
do { \
if (!(res = LLVMBuildIsNull(comp_ctx->builder, ptr, name))) { \
aot_set_last_error("llvm build isnull failed."); \
goto fail; \
} \
} while (0)
#define BUILD_ISNOTNULL(ptr, res, name) \
do { \
if (!(res = LLVMBuildIsNotNull(comp_ctx->builder, ptr, name))) { \
aot_set_last_error("llvm build isnotnull failed."); \
goto fail; \
} \
} while (0)
#define ADD_BASIC_BLOCK(block, name) \
do { \
if (!(block = LLVMAppendBasicBlockInContext(comp_ctx->context, \
func_ctx->func, name))) { \
aot_set_last_error("llvm add basic block failed."); \
goto fail; \
} \
} while (0)
#define CURR_BLOCK() LLVMGetInsertBlock(comp_ctx->builder)
#define MOVE_BLOCK_AFTER(llvm_block, llvm_block_after) \
LLVMMoveBasicBlockAfter(llvm_block, llvm_block_after)
#define MOVE_BLOCK_AFTER_CURR(llvm_block) \
LLVMMoveBasicBlockAfter(llvm_block, CURR_BLOCK())
#define MOVE_BLOCK_BEFORE(llvm_block, llvm_block_before) \
LLVMMoveBasicBlockBefore(llvm_block, llvm_block_before)
#define BUILD_COND_BR(value_if, block_then, block_else) \
do { \
if (!LLVMBuildCondBr(comp_ctx->builder, value_if, block_then, \
block_else)) { \
aot_set_last_error("llvm build cond br failed."); \
goto fail; \
} \
} while (0)
#define SET_BUILDER_POS(llvm_block) \
LLVMPositionBuilderAtEnd(comp_ctx->builder, llvm_block)
#define BUILD_BR(llvm_block) \
do { \
if (!LLVMBuildBr(comp_ctx->builder, llvm_block)) { \
aot_set_last_error("llvm build br failed."); \
goto fail; \
} \
} while (0)
#define BUILD_ICMP(op, left, right, res, name) \
do { \
if (!(res = \
LLVMBuildICmp(comp_ctx->builder, op, left, right, name))) { \
aot_set_last_error("llvm build icmp failed."); \
goto fail; \
} \
} while (0)
static bool
is_target_x86(AOTCompContext *comp_ctx)
{
return !strncmp(comp_ctx->target_arch, "x86_64", 6)
|| !strncmp(comp_ctx->target_arch, "i386", 4);
}
bool
aot_call_aot_create_func_obj(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef func_idx, LLVMValueRef *p_gc_obj)
{
LLVMValueRef gc_obj, cmp_gc_obj, param_values[5], func, value;
LLVMTypeRef param_types[5], ret_type, func_type, func_ptr_type;
AOTFuncType *aot_func_type = func_ctx->aot_func->func_type;
LLVMBasicBlockRef block_curr = LLVMGetInsertBlock(comp_ctx->builder);
LLVMBasicBlockRef init_gc_obj_fail, init_gc_obj_succ;
param_types[0] = INT8_PTR_TYPE;
param_types[1] = I32_TYPE;
param_types[2] = INT8_TYPE;
param_types[3] = INT8_PTR_TYPE;
param_types[4] = I32_TYPE;
ret_type = GC_REF_TYPE;
if (comp_ctx->is_jit_mode)
GET_AOT_FUNCTION(llvm_jit_create_func_obj, 5);
else
GET_AOT_FUNCTION(aot_create_func_obj, 5);
/* Call function llvm_jit/aot_create_func_obj() */
param_values[0] = func_ctx->aot_inst;
param_values[1] = func_idx;
param_values[2] = I8_CONST(1);
param_values[3] = I8_PTR_NULL;
param_values[4] = I32_ZERO;
if (!(gc_obj = LLVMBuildCall2(comp_ctx->builder, func_type, func,
param_values, 5, "call"))) {
aot_set_last_error("llvm build call failed.");
return false;
}
BUILD_ISNOTNULL(gc_obj, cmp_gc_obj, "gc_obj_not_null");
ADD_BASIC_BLOCK(init_gc_obj_fail, "init_gc_obj_fail");
ADD_BASIC_BLOCK(init_gc_obj_succ, "init_gc_obj_success");
LLVMMoveBasicBlockAfter(init_gc_obj_fail, block_curr);
LLVMMoveBasicBlockAfter(init_gc_obj_succ, block_curr);
if (!LLVMBuildCondBr(comp_ctx->builder, cmp_gc_obj, init_gc_obj_succ,
init_gc_obj_fail)) {
aot_set_last_error("llvm build cond br failed.");
goto fail;
}
/* If init gc_obj failed, return this function
so the runtime can catch the exception */
LLVMPositionBuilderAtEnd(comp_ctx->builder, init_gc_obj_fail);
if (!aot_build_zero_function_ret(comp_ctx, func_ctx, aot_func_type)) {
goto fail;
}
LLVMPositionBuilderAtEnd(comp_ctx->builder, init_gc_obj_succ);
*p_gc_obj = gc_obj;
return true;
fail:
return false;
}
bool
aot_call_aot_obj_is_instance_of(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx, LLVMValueRef gc_obj,
LLVMValueRef heap_type, LLVMValueRef *castable)
{
LLVMValueRef param_values[3], func, value, res;
LLVMTypeRef param_types[3], ret_type, func_type, func_ptr_type;
param_types[0] = INT8_PTR_TYPE;
param_types[1] = GC_REF_TYPE;
param_types[2] = I32_TYPE;
ret_type = INT8_TYPE;
if (comp_ctx->is_jit_mode)
GET_AOT_FUNCTION(llvm_jit_obj_is_instance_of, 3);
else
GET_AOT_FUNCTION(aot_obj_is_instance_of, 3);
/* Call function aot_obj_is_instance_of() or llvm_jit_obj_is_instance_of()
*/
param_values[0] = func_ctx->aot_inst;
param_values[1] = gc_obj;
param_values[2] = heap_type;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
3, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*castable = res;
return true;
fail:
return false;
}
bool
aot_call_wasm_obj_is_type_of(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef gc_obj, LLVMValueRef heap_type,
LLVMValueRef *castable)
{
LLVMValueRef param_values[2], func, value, res;
LLVMTypeRef param_types[2], ret_type, func_type, func_ptr_type;
param_types[0] = GC_REF_TYPE;
param_types[1] = I32_TYPE;
ret_type = INT8_TYPE;
GET_AOT_FUNCTION(wasm_obj_is_type_of, 2);
/* Call function wasm_obj_is_type_of() */
param_values[0] = gc_obj;
param_values[1] = heap_type;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
2, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*castable = res;
return true;
fail:
return false;
}
bool
aot_call_aot_rtt_type_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef type_index, LLVMValueRef *rtt_type)
{
LLVMValueRef param_values[2], func, value, res;
LLVMTypeRef param_types[2], ret_type, func_type, func_ptr_type;
param_types[0] = INT8_PTR_TYPE;
param_types[1] = I32_TYPE;
ret_type = GC_REF_TYPE;
if (comp_ctx->is_jit_mode)
GET_AOT_FUNCTION(llvm_jit_rtt_type_new, 2);
else
GET_AOT_FUNCTION(aot_rtt_type_new, 2);
/* Call function llvm_jit/aot_rtt_type_new() */
param_values[0] = func_ctx->aot_inst;
param_values[1] = type_index;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
2, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*rtt_type = res;
return true;
fail:
return false;
}
bool
aot_compile_op_ref_as_non_null(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx)
{
LLVMValueRef gc_obj, cmp_gc_obj;
LLVMBasicBlockRef check_gc_obj_succ;
GET_GC_REF_FROM_STACK(gc_obj);
/* Check if gc object is NULL */
BUILD_ISNULL(gc_obj, cmp_gc_obj, "cmp_gc_obj");
ADD_BASIC_BLOCK(check_gc_obj_succ, "check_gc_obj_succ");
MOVE_BLOCK_AFTER_CURR(check_gc_obj_succ);
/* Throw exception if it is NULL */
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_REFERENCE, true,
cmp_gc_obj, check_gc_obj_succ))
goto fail;
return true;
fail:
return false;
}
static bool
aot_call_wasm_struct_obj_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef rtt_type, LLVMValueRef *struct_obj)
{
LLVMValueRef param_values[2], func, value, res;
LLVMTypeRef param_types[2], ret_type, func_type, func_ptr_type;
param_types[0] = INT8_PTR_TYPE;
param_types[1] = INT8_PTR_TYPE;
ret_type = GC_REF_TYPE;
GET_AOT_FUNCTION(wasm_struct_obj_new, 2);
/* Call function wasm_struct_obj_new() */
param_values[0] = func_ctx->exec_env;
param_values[1] = rtt_type;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
2, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*struct_obj = res;
return true;
fail:
return false;
}
static void
get_struct_field_data_types(const AOTCompContext *comp_ctx, uint8 field_type,
LLVMTypeRef *p_field_data_type,
LLVMTypeRef *p_field_data_ptr_type,
bool *p_trunc_or_extend)
{
LLVMTypeRef field_data_type = NULL, field_data_ptr_type = NULL;
bool trunc_or_extend = false;
if (wasm_is_type_reftype(field_type)) {
field_data_type = GC_REF_TYPE;
field_data_ptr_type = GC_REF_PTR_TYPE;
}
else {
switch (field_type) {
case VALUE_TYPE_I32:
field_data_type = I32_TYPE;
field_data_ptr_type = INT32_PTR_TYPE;
break;
case VALUE_TYPE_I64:
field_data_type = I64_TYPE;
field_data_ptr_type = INT64_PTR_TYPE;
break;
case VALUE_TYPE_F32:
field_data_type = F32_TYPE;
field_data_ptr_type = F32_PTR_TYPE;
break;
case VALUE_TYPE_F64:
field_data_type = F64_TYPE;
field_data_ptr_type = F64_PTR_TYPE;
break;
case PACKED_TYPE_I8:
field_data_type = INT8_TYPE;
field_data_ptr_type = INT8_PTR_TYPE;
trunc_or_extend = true;
break;
case PACKED_TYPE_I16:
field_data_type = INT16_TYPE;
field_data_ptr_type = INT16_PTR_TYPE;
trunc_or_extend = true;
break;
default:
bh_assert(0);
break;
}
}
*p_field_data_type = field_data_type;
*p_field_data_ptr_type = field_data_ptr_type;
*p_trunc_or_extend = trunc_or_extend;
}
static bool
aot_struct_obj_set_field(AOTCompContext *comp_ctx, LLVMValueRef struct_obj,
LLVMValueRef field_offset, LLVMValueRef field_value,
uint8 field_type)
{
bool trunc = false;
LLVMValueRef field_data_ptr, res;
LLVMTypeRef field_data_type = NULL, field_data_ptr_type = NULL;
get_struct_field_data_types(comp_ctx, field_type, &field_data_type,
&field_data_ptr_type, &trunc);
/* Truncate field_value if necessary */
if (trunc) {
if (!(field_value =
LLVMBuildTrunc(comp_ctx->builder, field_value,
field_data_type, "field_value_trunc"))) {
aot_set_last_error("llvm build trunc failed.");
goto fail;
}
}
if (!(struct_obj = LLVMBuildBitCast(comp_ctx->builder, struct_obj,
INT8_PTR_TYPE, "struct_obj_i8p"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
/* Build field data ptr and store the value */
if (!(field_data_ptr =
LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE, struct_obj,
&field_offset, 1, "field_data_i8p"))) {
aot_set_last_error("llvm build gep failed.");
goto fail;
}
/* Cast to the field data type ptr */
if (!(field_data_ptr =
LLVMBuildBitCast(comp_ctx->builder, field_data_ptr,
field_data_ptr_type, "field_value_ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(res =
LLVMBuildStore(comp_ctx->builder, field_value, field_data_ptr))) {
aot_set_last_error("llvm build store failed.");
goto fail;
}
if (!is_target_x86(comp_ctx)
&& (field_data_type == I64_TYPE || field_data_type == F64_TYPE
|| field_data_type == GC_REF_TYPE)) {
LLVMSetAlignment(res, 4);
}
return true;
fail:
return false;
}
static bool
aot_struct_obj_get_field(AOTCompContext *comp_ctx, LLVMValueRef struct_obj,
LLVMValueRef field_offset, LLVMValueRef *p_field_value,
uint8 field_type, bool sign_extend)
{
bool extend = false;
LLVMValueRef field_value, field_data_ptr;
LLVMTypeRef field_data_type = NULL, field_data_ptr_type = NULL;
get_struct_field_data_types(comp_ctx, field_type, &field_data_type,
&field_data_ptr_type, &extend);
if (!(struct_obj = LLVMBuildBitCast(comp_ctx->builder, struct_obj,
INT8_PTR_TYPE, "struct_obj_i8p"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(field_data_ptr =
LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE, struct_obj,
&field_offset, 1, "field_data_i8p"))) {
aot_set_last_error("llvm build gep failed.");
goto fail;
}
if (!(field_data_ptr =
LLVMBuildBitCast(comp_ctx->builder, field_data_ptr,
field_data_ptr_type, "field_value_ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(field_value = LLVMBuildLoad2(comp_ctx->builder, field_data_type,
field_data_ptr, "field_value"))) {
aot_set_last_error("llvm build load failed.");
goto fail;
}
if (!is_target_x86(comp_ctx)
&& (field_data_type == I64_TYPE || field_data_type == F64_TYPE
|| field_data_type == GC_REF_TYPE)) {
LLVMSetAlignment(field_value, 4);
}
if (extend) {
if (sign_extend) {
if (!(field_value = LLVMBuildSExt(comp_ctx->builder, field_value,
I32_TYPE, "field_value_sext"))) {
aot_set_last_error("llvm build signed ext failed.");
goto fail;
}
}
else {
if (!(field_value = LLVMBuildZExt(comp_ctx->builder, field_value,
I32_TYPE, "field_value_zext"))) {
aot_set_last_error("llvm build unsigned ext failed.");
goto fail;
}
}
}
*p_field_value = field_value;
return true;
fail:
return false;
}
static bool
struct_new_canon_init_fields(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, LLVMValueRef struct_obj)
{
LLVMValueRef field_value = NULL;
/* Used in compile time, to distinguish what type of AOTValue POP,
* field_data offset, size */
WASMStructType *compile_time_struct_type =
(WASMStructType *)comp_ctx->comp_data->types[type_index];
WASMStructFieldType *fields = compile_time_struct_type->fields;
int32 field_count = (int32)compile_time_struct_type->field_count;
int32 field_idx;
uint32 field_offset;
uint8 field_type;
for (field_idx = field_count - 1; field_idx >= 0; field_idx--) {
field_type = fields[field_idx].field_type;
field_offset = comp_ctx->pointer_size == sizeof(uint64)
? fields[field_idx].field_offset_64bit
: fields[field_idx].field_offset_32bit;
if (wasm_is_type_reftype(field_type)) {
POP_GC_REF(field_value);
}
else if (field_type == VALUE_TYPE_I32 || field_type == PACKED_TYPE_I8
|| field_type == PACKED_TYPE_I16) {
POP_I32(field_value);
}
else if (field_type == VALUE_TYPE_I64) {
POP_I64(field_value);
}
else if (field_type == VALUE_TYPE_F32) {
POP_F32(field_value);
}
else if (field_type == VALUE_TYPE_F64) {
POP_F64(field_value);
}
else {
bh_assert(0);
}
if (!aot_struct_obj_set_field(comp_ctx, struct_obj,
I32_CONST(field_offset), field_value,
field_type))
goto fail;
}
return true;
fail:
return false;
}
bool
aot_compile_op_struct_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, bool init_with_default)
{
LLVMValueRef rtt_type, struct_obj, cmp;
LLVMBasicBlockRef check_rtt_type_succ, check_struct_obj_succ;
if (!aot_gen_commit_values(comp_ctx->aot_frame))
return false;
if (!aot_gen_commit_sp_ip(comp_ctx->aot_frame, true, true))
return false;
/* Generate call wasm_rtt_type_new and check for exception */
if (!aot_call_aot_rtt_type_new(comp_ctx, func_ctx, I32_CONST(type_index),
&rtt_type))
goto fail;
ADD_BASIC_BLOCK(check_rtt_type_succ, "check rtt type succ");
MOVE_BLOCK_AFTER_CURR(check_rtt_type_succ);
BUILD_ISNULL(rtt_type, cmp, "cmp_rtt_type");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_FAILED_TO_CREATE_RTT_TYPE,
true, cmp, check_rtt_type_succ))
goto fail;
/* Generate call wasm_struct_obj_new and check for exception */
if (!aot_call_wasm_struct_obj_new(comp_ctx, func_ctx, rtt_type,
&struct_obj))
goto fail;
ADD_BASIC_BLOCK(check_struct_obj_succ, "check struct obj succ");
MOVE_BLOCK_AFTER(check_struct_obj_succ, check_rtt_type_succ);
BUILD_ISNULL(struct_obj, cmp, "cmp_struct_obj");
if (!aot_emit_exception(comp_ctx, func_ctx,
EXCE_FAILED_TO_CREATE_STRUCT_OBJ, true, cmp,
check_struct_obj_succ))
goto fail;
SET_BUILDER_POS(check_struct_obj_succ);
/* For WASM_OP_STRUCT_NEW, init field with poped value */
if (!init_with_default
&& !struct_new_canon_init_fields(comp_ctx, func_ctx, type_index,
struct_obj)) {
goto fail;
}
PUSH_GC_REF(struct_obj);
return true;
fail:
return false;
}
bool
aot_compile_op_struct_get(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, uint32 field_idx, bool sign)
{
LLVMValueRef struct_obj, cmp, field_value;
LLVMBasicBlockRef check_struct_obj_succ;
/* Used in compile time, to distinguish what type of AOTValue PUSH,
* field_data offset, size */
WASMStructType *compile_time_struct_type =
(WASMStructType *)comp_ctx->comp_data->types[type_index];
WASMStructFieldType *field;
uint32 field_offset;
uint8 field_type;
field = compile_time_struct_type->fields + field_idx;
field_type = field->field_type;
field_offset = comp_ctx->pointer_size == sizeof(uint64)
? field->field_offset_64bit
: field->field_offset_32bit;
if (field_idx >= compile_time_struct_type->field_count) {
aot_set_last_error("struct field index out of bounds");
goto fail;
}
POP_GC_REF(struct_obj);
ADD_BASIC_BLOCK(check_struct_obj_succ, "check struct obj succ");
MOVE_BLOCK_AFTER_CURR(check_struct_obj_succ);
BUILD_ISNULL(struct_obj, cmp, "cmp_struct_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_STRUCT_OBJ, true, cmp,
check_struct_obj_succ))
goto fail;
if (!aot_struct_obj_get_field(comp_ctx, struct_obj, I32_CONST(field_offset),
&field_value, field_type, sign))
goto fail;
if (wasm_is_type_reftype(field_type)) {
PUSH_GC_REF(field_value);
}
else if (field_type == VALUE_TYPE_I32 || field_type == PACKED_TYPE_I8
|| field_type == PACKED_TYPE_I16) {
PUSH_I32(field_value);
}
else if (field_type == VALUE_TYPE_I64) {
PUSH_I64(field_value);
}
else if (field_type == VALUE_TYPE_F32) {
PUSH_F32(field_value);
}
else if (field_type == VALUE_TYPE_F64) {
PUSH_F64(field_value);
}
else {
bh_assert(0);
}
return true;
fail:
return false;
}
bool
aot_compile_op_struct_set(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, uint32 field_idx)
{
LLVMValueRef struct_obj, cmp, field_value = NULL;
LLVMBasicBlockRef check_struct_obj_succ;
/* Used in compile time, to distinguish what type of AOTValue POP,
* field_data offset, size */
WASMStructType *compile_time_struct_type =
(WASMStructType *)comp_ctx->comp_data->types[type_index];
WASMStructFieldType *field;
uint32 field_offset;
uint8 field_type;
field = compile_time_struct_type->fields + field_idx;
field_type = field->field_type;
field_offset = comp_ctx->pointer_size == sizeof(uint64)
? field->field_offset_64bit
: field->field_offset_32bit;
if (field_idx >= compile_time_struct_type->field_count) {
aot_set_last_error("struct field index out of bounds");
goto fail;
}
if (wasm_is_type_reftype(field_type)) {
POP_GC_REF(field_value);
}
else if (field_type == VALUE_TYPE_I32 || field_type == PACKED_TYPE_I8
|| field_type == PACKED_TYPE_I16) {
POP_I32(field_value);
}
else if (field_type == VALUE_TYPE_I64) {
POP_I64(field_value);
}
else if (field_type == VALUE_TYPE_F32) {
POP_F32(field_value);
}
else if (field_type == VALUE_TYPE_F64) {
POP_F64(field_value);
}
else {
bh_assert(0);
}
POP_GC_REF(struct_obj);
ADD_BASIC_BLOCK(check_struct_obj_succ, "check struct obj succ");
MOVE_BLOCK_AFTER_CURR(check_struct_obj_succ);
BUILD_ISNULL(struct_obj, cmp, "cmp_struct_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_STRUCT_OBJ, true, cmp,
check_struct_obj_succ))
goto fail;
if (!aot_struct_obj_set_field(comp_ctx, struct_obj, I32_CONST(field_offset),
field_value, field_type))
goto fail;
return true;
fail:
return false;
}
static bool
aot_call_wasm_array_obj_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef rtt_type, LLVMValueRef array_len,
LLVMValueRef array_elem, LLVMValueRef *array_obj)
{
LLVMValueRef param_values[4], func, value, res, array_elem_ptr;
LLVMTypeRef param_types[4], ret_type, func_type, func_ptr_type;
if (!(array_elem_ptr = LLVMBuildAlloca(
comp_ctx->builder, LLVMTypeOf(array_elem), "array_elem_ptr"))) {
aot_set_last_error("llvm build alloca failed.");
goto fail;
}
if (!LLVMBuildStore(comp_ctx->builder, array_elem, array_elem_ptr)) {
aot_set_last_error("llvm build store failed.");
goto fail;
}
if (!(array_elem_ptr = LLVMBuildBitCast(comp_ctx->builder, array_elem_ptr,
INT8_PTR_TYPE, "array_elem_ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
param_types[0] = INT8_PTR_TYPE;
param_types[1] = INT8_PTR_TYPE;
param_types[2] = I32_TYPE;
param_types[3] = INT8_PTR_TYPE;
ret_type = GC_REF_TYPE;
GET_AOT_FUNCTION(wasm_array_obj_new, 4);
/* Call function wasm_array_obj_new() */
param_values[0] = func_ctx->exec_env;
param_values[1] = rtt_type;
param_values[2] = array_len;
param_values[3] = array_elem_ptr;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
4, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*array_obj = res;
return true;
fail:
return false;
}
static uint32
aot_array_obj_elem_size_log(AOTCompContext *comp_ctx, uint8 array_elem_type)
{
uint32 elem_size_log = 0;
if (wasm_is_type_reftype(array_elem_type)) {
elem_size_log = comp_ctx->pointer_size == sizeof(uint32) ? 2 : 3;
}
else if (array_elem_type == PACKED_TYPE_I8) {
elem_size_log = 0;
}
else if (array_elem_type == PACKED_TYPE_I16) {
elem_size_log = 1;
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == VALUE_TYPE_F32) {
elem_size_log = 2;
}
else if (array_elem_type == VALUE_TYPE_I64
|| array_elem_type == VALUE_TYPE_F64) {
elem_size_log = 3;
}
else {
bh_assert(0);
}
return elem_size_log;
}
/* array_obj->elem_data + (elem_idx << elem_size_log) */
bool
aot_array_obj_elem_addr(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef array_obj, LLVMValueRef elem_idx,
LLVMValueRef *p_elem_data, uint8 array_elem_type)
{
uint32 elem_size_log = 0;
LLVMValueRef start_offset, elem_offset, elem_data;
elem_size_log = aot_array_obj_elem_size_log(comp_ctx, array_elem_type);
/* Get the elem data start offset of the WASMArrayObject, the offset may be
* different in 32-bit runtime and 64-bit runtime since WASMObjectHeader
* is uintptr_t. Use comp_ctx->pointer_size + 4(uint32 for length) as the
* offsetof(WASMArrayObject, length)*/
if (!(start_offset = I32_CONST(comp_ctx->pointer_size + sizeof(uint32)))) {
aot_set_last_error("llvm build const failed.");
goto fail;
}
if (!(elem_offset =
LLVMBuildShl(comp_ctx->builder, elem_idx,
I32_CONST(elem_size_log), "elem_offset"))) {
aot_set_last_error("llvm build shl failed.");
goto fail;
}
if (!(elem_offset = LLVMBuildAdd(comp_ctx->builder, start_offset,
elem_offset, "total_offset"))) {
aot_set_last_error("llvm build add failed.");
goto fail;
}
if (!(elem_data = LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE,
array_obj, &elem_offset, 1,
"array_obj_elem_data_i8p"))) {
aot_set_last_error("llvm build gep failed.");
goto fail;
}
*p_elem_data = elem_data;
return true;
fail:
return false;
}
static bool
aot_array_obj_set_elem(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef array_obj, LLVMValueRef elem_idx,
LLVMValueRef array_elem, uint8 array_elem_type)
{
bool trunc = false;
LLVMValueRef elem_data_ptr, res;
LLVMTypeRef elem_data_type = NULL, elem_data_ptr_type = NULL;
if (!aot_array_obj_elem_addr(comp_ctx, func_ctx, array_obj, elem_idx,
&elem_data_ptr, array_elem_type))
goto fail;
if (wasm_is_type_reftype(array_elem_type)) {
elem_data_type = GC_REF_TYPE;
elem_data_ptr_type = GC_REF_PTR_TYPE;
}
else
switch (array_elem_type) {
case PACKED_TYPE_I8:
elem_data_type = INT8_TYPE;
elem_data_ptr_type = INT8_PTR_TYPE;
trunc = true;
break;
case PACKED_TYPE_I16:
elem_data_type = INT16_TYPE;
elem_data_ptr_type = INT16_PTR_TYPE;
trunc = true;
break;
case VALUE_TYPE_I32:
elem_data_type = I32_TYPE;
elem_data_ptr_type = INT32_PTR_TYPE;
break;
case VALUE_TYPE_I64:
elem_data_type = I64_TYPE;
elem_data_ptr_type = INT64_PTR_TYPE;
break;
case VALUE_TYPE_F32:
elem_data_type = F32_TYPE;
elem_data_ptr_type = F32_PTR_TYPE;
break;
case VALUE_TYPE_F64:
elem_data_type = F64_TYPE;
elem_data_ptr_type = F64_PTR_TYPE;
break;
default:
bh_assert(0);
break;
}
/* Based on elem_size, trunc array_elem if necessary */
if (trunc) {
if (!(array_elem =
LLVMBuildTrunc(comp_ctx->builder, array_elem, elem_data_type,
"array_elem_trunc"))) {
aot_set_last_error("llvm build trunc failed.");
goto fail;
}
}
/* Cast to the field data type ptr */
if (!(elem_data_ptr =
LLVMBuildBitCast(comp_ctx->builder, elem_data_ptr,
elem_data_ptr_type, "elem_data_ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(res = LLVMBuildStore(comp_ctx->builder, array_elem, elem_data_ptr))) {
aot_set_last_error("llvm build store failed.");
goto fail;
}
if (!is_target_x86(comp_ctx)
&& (elem_data_type == I64_TYPE || elem_data_type == F64_TYPE
|| elem_data_type == GC_REF_TYPE)) {
LLVMSetAlignment(res, 4);
}
return true;
fail:
return false;
}
static bool
aot_call_aot_array_init_with_data(
AOTCompContext *comp_ctx, AOTFuncContext *func_ctx, LLVMValueRef seg_index,
LLVMValueRef data_seg_offset, LLVMValueRef array_obj,
LLVMValueRef elem_size, LLVMValueRef array_len)
{
LLVMValueRef param_values[6], func, value, res, cmp;
LLVMTypeRef param_types[6], ret_type, func_type, func_ptr_type;
LLVMBasicBlockRef init_success;
ADD_BASIC_BLOCK(init_success, "init success");
MOVE_BLOCK_AFTER_CURR(init_success);
param_types[0] = INT8_PTR_TYPE;
param_types[1] = I32_TYPE;
param_types[2] = I32_TYPE;
param_types[3] = INT8_PTR_TYPE;
param_types[4] = I32_TYPE;
param_types[5] = I32_TYPE;
ret_type = INT8_TYPE;
if (comp_ctx->is_jit_mode)
GET_AOT_FUNCTION(llvm_array_init_with_data, 6);
else
GET_AOT_FUNCTION(aot_array_init_with_data, 6);
/* Call function aot_array_init_with_data() */
param_values[0] = func_ctx->aot_inst;
param_values[1] = seg_index;
param_values[2] = data_seg_offset;
param_values[3] = array_obj;
param_values[4] = elem_size;
param_values[5] = array_len;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
6, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
BUILD_ICMP(LLVMIntEQ, res, I8_ZERO, cmp, "array_init_ret");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_ARRAY_IDX_OOB, true, cmp,
init_success))
goto fail;
return true;
fail:
return false;
}
static bool
aot_call_wasm_array_get_elem(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef array_obj, LLVMValueRef elem_idx,
LLVMValueRef *p_array_elem, uint8 array_elem_type,
bool sign)
{
bool extend = false;
LLVMValueRef elem_data_ptr, array_elem;
LLVMTypeRef elem_data_type = NULL, elem_data_ptr_type = NULL;
if (!aot_array_obj_elem_addr(comp_ctx, func_ctx, array_obj, elem_idx,
&elem_data_ptr, array_elem_type))
goto fail;
if (wasm_is_type_reftype(array_elem_type)) {
elem_data_type = GC_REF_TYPE;
elem_data_ptr_type = GC_REF_PTR_TYPE;
}
else
switch (array_elem_type) {
case PACKED_TYPE_I8:
elem_data_type = INT8_TYPE;
elem_data_ptr_type = INT8_PTR_TYPE;
extend = true;
break;
case PACKED_TYPE_I16:
elem_data_type = INT16_TYPE;
elem_data_ptr_type = INT16_PTR_TYPE;
extend = true;
break;
case VALUE_TYPE_I32:
elem_data_type = I32_TYPE;
elem_data_ptr_type = INT32_PTR_TYPE;
break;
case VALUE_TYPE_I64:
elem_data_type = I64_TYPE;
elem_data_ptr_type = INT64_PTR_TYPE;
break;
case VALUE_TYPE_F32:
elem_data_type = F32_TYPE;
elem_data_ptr_type = F32_PTR_TYPE;
break;
case VALUE_TYPE_F64:
elem_data_type = F64_TYPE;
elem_data_ptr_type = F64_PTR_TYPE;
break;
default:
bh_assert(0);
break;
}
/* Based on elem_size, trunc array_elem if necessary */
if (!(elem_data_ptr =
LLVMBuildBitCast(comp_ctx->builder, elem_data_ptr,
elem_data_ptr_type, "elem_data_ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(array_elem = LLVMBuildLoad2(comp_ctx->builder, elem_data_type,
elem_data_ptr, "array_elem"))) {
aot_set_last_error("llvm build load failed.");
goto fail;
}
if (!is_target_x86(comp_ctx)
&& (elem_data_type == I64_TYPE || elem_data_type == F64_TYPE
|| elem_data_type == GC_REF_TYPE)) {
LLVMSetAlignment(array_elem, 4);
}
if (extend) {
if (sign) {
if (!(array_elem = LLVMBuildSExt(comp_ctx->builder, array_elem,
I32_TYPE, "array_elem_sext"))) {
aot_set_last_error("llvm build signed ext failed.");
goto fail;
}
}
else {
if (!(array_elem = LLVMBuildZExt(comp_ctx->builder, array_elem,
I32_TYPE, "array_elem_zext"))) {
aot_set_last_error("llvm build unsigned ext failed.");
goto fail;
}
}
}
*p_array_elem = array_elem;
return true;
fail:
return false;
}
/* array_obj->length >> WASM_ARRAY_LENGTH_SHIFT */
bool
aot_array_obj_length(AOTCompContext *comp_ctx, LLVMValueRef array_obj,
LLVMValueRef *p_array_len)
{
LLVMValueRef offset, array_len;
/* Get the length of the WASMArrayObject, the offset may be
* different in 32-bit runtime and 64-bit runtime since WASMObjectHeader
* is uintptr_t. Use comp_ctx->pointer_size as the
* offsetof(WASMArrayObject, length)*/
if (!(offset = I32_CONST(comp_ctx->pointer_size))) {
aot_set_last_error("llvm build const failed.");
goto fail;
}
if (!(array_len =
LLVMBuildInBoundsGEP2(comp_ctx->builder, INT8_TYPE, array_obj,
&offset, 1, "array_obj_length_i8p"))) {
aot_set_last_error("llvm build gep failed.");
goto fail;
}
if (!(array_len =
LLVMBuildBitCast(comp_ctx->builder, array_len, INT32_PTR_TYPE,
"array_obj_length_i32ptr"))) {
aot_set_last_error("llvm build bitcast failed.");
goto fail;
}
if (!(array_len = LLVMBuildLoad2(comp_ctx->builder, I32_TYPE, array_len,
"array_obj_length"))) {
aot_set_last_error("llvm build load failed.");
goto fail;
}
if (!(array_len = LLVMBuildLShr(comp_ctx->builder, array_len,
I32_CONST(WASM_ARRAY_LENGTH_SHIFT),
"array_obj_length_shr"))) {
aot_set_last_error("llvm build lshr failed.");
goto fail;
}
*p_array_len = array_len;
return true;
fail:
return false;
}
bool
aot_compile_op_array_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, bool init_with_default,
bool fixed_size, uint32 array_len)
{
LLVMValueRef array_length, array_elem = NULL, array_obj;
LLVMValueRef rtt_type, cmp, elem_idx;
LLVMBasicBlockRef check_rtt_type_succ, check_array_obj_succ;
/* Use for distinguish what type of AOTValue POP */
WASMArrayType *compile_time_array_type =
(WASMArrayType *)comp_ctx->comp_data->types[type_index];
uint8 array_elem_type = compile_time_array_type->elem_type;
uint32 i;
if (!aot_gen_commit_values(comp_ctx->aot_frame))
return false;
if (!aot_gen_commit_sp_ip(comp_ctx->aot_frame, true, true))
return false;
/* Generate call aot_rtt_type_new and check for exception */
if (!aot_call_aot_rtt_type_new(comp_ctx, func_ctx, I32_CONST(type_index),
&rtt_type))
goto fail;
ADD_BASIC_BLOCK(check_rtt_type_succ, "check rtt type succ");
MOVE_BLOCK_AFTER_CURR(check_rtt_type_succ);
BUILD_ISNULL(rtt_type, cmp, "cmp_rtt_type");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_FAILED_TO_CREATE_RTT_TYPE,
true, cmp, check_rtt_type_succ))
goto fail;
if (!fixed_size)
POP_I32(array_length);
else
array_length = I32_CONST(array_len);
/* For WASM_OP_ARRAY_NEW */
if (!fixed_size && !init_with_default) {
if (wasm_is_type_reftype(array_elem_type)) {
POP_GC_REF(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == PACKED_TYPE_I8
|| array_elem_type == PACKED_TYPE_I16) {
POP_I32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I64) {
POP_I64(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F32) {
POP_F32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F64) {
POP_F64(array_elem);
}
else {
bh_assert(0);
}
}
else {
/* I64 will alloca large enough space for all union access includes
* array_elem.gc_ob, i32, i64 to be interpreted as 0*/
array_elem = I64_ZERO;
}
/* Generate call wasm_array_obj_new and check for exception */
if (!aot_call_wasm_array_obj_new(comp_ctx, func_ctx, rtt_type, array_length,
array_elem, &array_obj))
goto fail;
ADD_BASIC_BLOCK(check_array_obj_succ, "check array obj succ");
MOVE_BLOCK_AFTER(check_array_obj_succ, check_rtt_type_succ);
BUILD_ISNULL(array_obj, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_FAILED_TO_CREATE_ARRAY_OBJ,
true, cmp, check_array_obj_succ))
goto fail;
if (fixed_size) {
for (i = 0; i < array_len; i++) {
if (wasm_is_type_reftype(array_elem_type)) {
POP_GC_REF(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == PACKED_TYPE_I8
|| array_elem_type == PACKED_TYPE_I16) {
POP_I32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I64) {
POP_I64(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F32) {
POP_F32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F64) {
POP_F64(array_elem);
}
else {
bh_assert(0);
}
/* array_len - 1 - i */
if (!(elem_idx = LLVMBuildSub(comp_ctx->builder, array_length,
I32_CONST(i + 1), "elem_idx"))) {
aot_set_last_error("llvm build sub failed.");
goto fail;
}
if (!aot_array_obj_set_elem(comp_ctx, func_ctx, array_obj, elem_idx,
array_elem, array_elem_type))
goto fail;
}
}
PUSH_GC_REF(array_obj);
return true;
fail:
return false;
}
bool
aot_compile_op_array_new_data(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx, uint32 type_index,
uint32 data_seg_index)
{
LLVMValueRef array_length, data_seg_offset, rtt_type,
elem_size = NULL, array_elem, array_obj, cmp;
LLVMBasicBlockRef check_rtt_type_succ, check_array_obj_succ;
/* Use for distinguish what type of element in array */
WASMArrayType *compile_time_array_type =
(WASMArrayType *)comp_ctx->comp_data->types[type_index];
uint8 array_elem_type = compile_time_array_type->elem_type;
if (!aot_gen_commit_values(comp_ctx->aot_frame))
return false;
if (!aot_gen_commit_sp_ip(comp_ctx->aot_frame, true, true))
return false;
/* Generate call aot_rtt_type_new and check for exception */
if (!aot_call_aot_rtt_type_new(comp_ctx, func_ctx, I32_CONST(type_index),
&rtt_type))
goto fail;
ADD_BASIC_BLOCK(check_rtt_type_succ, "check rtt type succ");
MOVE_BLOCK_AFTER_CURR(check_rtt_type_succ);
BUILD_ISNULL(rtt_type, cmp, "cmp_rtt_type");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_FAILED_TO_CREATE_RTT_TYPE,
true, cmp, check_rtt_type_succ))
goto fail;
POP_I32(array_length);
POP_I32(data_seg_offset);
switch (array_elem_type) {
case PACKED_TYPE_I8:
elem_size = I32_ONE;
break;
case PACKED_TYPE_I16:
elem_size = I32_TWO;
break;
case VALUE_TYPE_I32:
case VALUE_TYPE_F32:
elem_size = I32_FOUR;
break;
case VALUE_TYPE_I64:
case VALUE_TYPE_F64:
elem_size = I32_EIGHT;
break;
default:
bh_assert(0);
}
if (elem_size == I32_EIGHT)
array_elem = I64_ZERO;
else
array_elem = I32_ZERO;
/* Generate call wasm_array_obj_new and check for exception */
if (!aot_call_wasm_array_obj_new(comp_ctx, func_ctx, rtt_type, array_length,
array_elem, &array_obj))
goto fail;
ADD_BASIC_BLOCK(check_array_obj_succ, "check array obj succ");
MOVE_BLOCK_AFTER(check_array_obj_succ, check_rtt_type_succ);
BUILD_ISNULL(array_obj, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_FAILED_TO_CREATE_ARRAY_OBJ,
true, cmp, check_array_obj_succ))
goto fail;
if (!aot_call_aot_array_init_with_data(
comp_ctx, func_ctx, I32_CONST(data_seg_index), data_seg_offset,
array_obj, elem_size, array_length))
goto fail;
PUSH_GC_REF(array_obj);
return true;
fail:
return false;
}
bool
aot_compile_op_array_get(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, bool sign)
{
LLVMValueRef elem_idx, array_obj, cmp, array_len, array_elem;
LLVMBasicBlockRef check_array_obj_succ, check_boundary_succ;
/* Use for distinguish what type of AOTValue PUSH */
WASMArrayType *compile_time_array_type =
(WASMArrayType *)comp_ctx->comp_data->types[type_index];
uint8 array_elem_type = compile_time_array_type->elem_type;
POP_I32(elem_idx);
POP_GC_REF(array_obj);
ADD_BASIC_BLOCK(check_array_obj_succ, "check array obj succ");
MOVE_BLOCK_AFTER_CURR(check_array_obj_succ);
BUILD_ISNULL(array_obj, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_ARRAY_OBJ, true, cmp,
check_array_obj_succ))
goto fail;
SET_BUILDER_POS(check_array_obj_succ);
if (!aot_array_obj_length(comp_ctx, array_obj, &array_len))
goto fail;
ADD_BASIC_BLOCK(check_boundary_succ, "check boundary succ");
MOVE_BLOCK_AFTER(check_boundary_succ, check_array_obj_succ);
BUILD_ICMP(LLVMIntUGE, elem_idx, array_len, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_ARRAY_IDX_OOB, true, cmp,
check_boundary_succ))
goto fail;
SET_BUILDER_POS(check_boundary_succ);
if (!aot_call_wasm_array_get_elem(comp_ctx, func_ctx, array_obj, elem_idx,
&array_elem, array_elem_type, sign))
goto fail;
if (wasm_is_type_reftype(array_elem_type)) {
PUSH_GC_REF(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == PACKED_TYPE_I8
|| array_elem_type == PACKED_TYPE_I16) {
PUSH_I32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I64) {
PUSH_I64(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F32) {
PUSH_F32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F64) {
PUSH_F64(array_elem);
}
else {
bh_assert(0);
}
return true;
fail:
return false;
}
bool
aot_compile_op_array_set(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index)
{
LLVMValueRef elem_idx, array_obj, cmp, array_len, array_elem = NULL;
LLVMBasicBlockRef check_array_obj_succ, check_boundary_succ;
/* Use for distinguish what type of AOTValue POP */
WASMArrayType *compile_time_array_type =
(WASMArrayType *)comp_ctx->comp_data->types[type_index];
uint8 array_elem_type = compile_time_array_type->elem_type;
/* Get LLVM type based on array_elem_type */
if (wasm_is_type_reftype(array_elem_type)) {
POP_GC_REF(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == PACKED_TYPE_I8
|| array_elem_type == PACKED_TYPE_I16) {
POP_I32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_I64) {
POP_I64(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F32) {
POP_F32(array_elem);
}
else if (array_elem_type == VALUE_TYPE_F64) {
POP_F64(array_elem);
}
else {
bh_assert(0);
}
POP_I32(elem_idx);
POP_GC_REF(array_obj);
ADD_BASIC_BLOCK(check_array_obj_succ, "check array obj succ");
MOVE_BLOCK_AFTER_CURR(check_array_obj_succ);
BUILD_ISNULL(array_obj, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_ARRAY_OBJ, true, cmp,
check_array_obj_succ))
goto fail;
SET_BUILDER_POS(check_array_obj_succ);
if (!aot_array_obj_length(comp_ctx, array_obj, &array_len))
goto fail;
ADD_BASIC_BLOCK(check_boundary_succ, "check boundary succ");
MOVE_BLOCK_AFTER(check_boundary_succ, check_array_obj_succ);
BUILD_ICMP(LLVMIntUGE, elem_idx, array_len, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_ARRAY_IDX_OOB, true, cmp,
check_boundary_succ))
goto fail;
SET_BUILDER_POS(check_boundary_succ);
if (!aot_array_obj_set_elem(comp_ctx, func_ctx, array_obj, elem_idx,
array_elem, array_elem_type)) {
aot_set_last_error("llvm build alloca failed.");
goto fail;
}
return true;
fail:
return false;
}
bool
aot_compile_op_array_fill(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index)
{
LLVMValueRef len, array_obj, fill_value = NULL, offset, array_len, cmp[2],
boundary, loop_counter_addr, loop_counter_val;
LLVMBasicBlockRef check_obj_succ, len_gt_zero, len_le_zero, inner_else;
LLVMBasicBlockRef fill_loop_header, fill_loop_body;
WASMArrayType *compile_time_array_type =
(WASMArrayType *)comp_ctx->comp_data->types[type_index];
uint8 array_elem_type = compile_time_array_type->elem_type;
POP_I32(len);
/* Get LLVM type based on array_elem_type */
if (wasm_is_type_reftype(array_elem_type)) {
POP_GC_REF(fill_value);
}
else if (array_elem_type == VALUE_TYPE_I32
|| array_elem_type == PACKED_TYPE_I8
|| array_elem_type == PACKED_TYPE_I16) {
POP_I32(fill_value);
}
else if (array_elem_type == VALUE_TYPE_I64) {
POP_I64(fill_value);
}
else if (array_elem_type == VALUE_TYPE_F32) {
POP_F32(fill_value);
}
else if (array_elem_type == VALUE_TYPE_F64) {
POP_F64(fill_value);
}
else {
bh_assert(0);
}
POP_I32(offset);
POP_GC_REF(array_obj);
ADD_BASIC_BLOCK(check_obj_succ, "check array objs succ");
MOVE_BLOCK_AFTER_CURR(check_obj_succ);
BUILD_ISNULL(array_obj, cmp[0], "cmp_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_ARRAY_OBJ, true,
cmp[0], check_obj_succ))
goto fail;
/* Create if block */
ADD_BASIC_BLOCK(len_gt_zero, "len_gt_zero");
MOVE_BLOCK_AFTER_CURR(len_gt_zero);
/* Create inner else block */
ADD_BASIC_BLOCK(inner_else, "inner_else");
MOVE_BLOCK_AFTER(inner_else, len_gt_zero);
/* Create fill_loop_header block */
ADD_BASIC_BLOCK(fill_loop_header, "fill_loop_header");
MOVE_BLOCK_AFTER(fill_loop_header, len_gt_zero);
/* Create fill_loop_body block */
ADD_BASIC_BLOCK(fill_loop_body, "fill_loop_body");
MOVE_BLOCK_AFTER(fill_loop_body, len_gt_zero);
/* Create else(end) block */
ADD_BASIC_BLOCK(len_le_zero, "len_le_zero");
MOVE_BLOCK_AFTER(len_le_zero, len_gt_zero);
BUILD_ICMP(LLVMIntSGT, len, I32_ZERO, cmp[0], "cmp_len");
BUILD_COND_BR(cmp[0], len_gt_zero, len_le_zero);
/* Move builder to len > 0 block */
SET_BUILDER_POS(len_gt_zero);
/* dst_offset > UINT32_MAX - len */
if (!(boundary = LLVMBuildAdd(comp_ctx->builder, offset, len, ""))) {
aot_set_last_error("llvm build failed.");
goto fail;
}
BUILD_ICMP(LLVMIntUGT, boundary, I32_CONST(UINT32_MAX), cmp[0],
"boundary_check1");
/* dst_offset + len > wasm_array_obj_length(dst_obj) */
if (!aot_array_obj_length(comp_ctx, array_obj, &array_len))
goto fail;
BUILD_ICMP(LLVMIntUGT, boundary, array_len, cmp[1], "boundary_check2");
if (!(cmp[0] = LLVMBuildOr(comp_ctx->builder, cmp[0], cmp[1], ""))) {
aot_set_last_error("llvm build failed.");
goto fail;
}
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_ARRAY_IDX_OOB, true,
cmp[0], inner_else))
goto fail;
if (!(loop_counter_addr = LLVMBuildAlloca(comp_ctx->builder, I32_TYPE,
"fill_loop_counter"))) {
aot_set_last_error("llvm build alloc failed.");
goto fail;
}
if (!is_target_x86(comp_ctx)) {
LLVMSetAlignment(loop_counter_addr, 4);
}
if (!LLVMBuildStore(comp_ctx->builder, offset, loop_counter_addr)) {
aot_set_last_error("llvm build store failed.");
goto fail;
}
BUILD_BR(fill_loop_header);
SET_BUILDER_POS(fill_loop_header);
if (!(loop_counter_val =
LLVMBuildLoad2(comp_ctx->builder, I32_TYPE, loop_counter_addr,
"fill_loop_counter"))) {
aot_set_last_error("llvm build load failed.");
goto fail;
}
BUILD_ICMP(LLVMIntULT, loop_counter_val, boundary, cmp[0],
"cmp_loop_counter");
BUILD_COND_BR(cmp[0], fill_loop_body, len_le_zero);
SET_BUILDER_POS(fill_loop_body);
if (!aot_array_obj_set_elem(comp_ctx, func_ctx, array_obj, loop_counter_val,
fill_value, array_elem_type))
goto fail;
if (!(loop_counter_val = LLVMBuildAdd(comp_ctx->builder, loop_counter_val,
I32_ONE, "fill_loop_counter"))) {
aot_set_last_error("llvm build add failed.");
goto fail;
}
if (!LLVMBuildStore(comp_ctx->builder, loop_counter_val,
loop_counter_addr)) {
aot_set_last_error("llvm build store failed.");
goto fail;
}
BUILD_BR(fill_loop_header);
SET_BUILDER_POS(len_le_zero);
return true;
fail:
return false;
}
static bool
aot_call_wasm_array_obj_copy(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
LLVMValueRef dst_obj, LLVMValueRef dst_offset,
LLVMValueRef src_obj, LLVMValueRef src_offset,
LLVMValueRef len)
{
LLVMValueRef param_values[5], func, value;
LLVMTypeRef param_types[5], ret_type, func_type, func_ptr_type;
param_types[0] = GC_REF_TYPE;
param_types[1] = I32_TYPE;
param_types[2] = GC_REF_TYPE;
param_types[3] = I32_TYPE;
param_types[4] = I32_TYPE;
ret_type = VOID_TYPE;
GET_AOT_FUNCTION(wasm_array_obj_copy, 5);
/* Call function wasm_array_obj_copy() */
param_values[0] = dst_obj;
param_values[1] = dst_offset;
param_values[2] = src_obj;
param_values[3] = src_offset;
param_values[4] = len;
if (!LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values, 5,
"")) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
return true;
fail:
return false;
}
bool
aot_compile_op_array_copy(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
uint32 type_index, uint32 src_type_index)
{
LLVMValueRef len, src_offset, src_obj, dst_offset, dst_obj, array_len,
cmp[4], boundary;
LLVMBasicBlockRef check_objs_succ, len_gt_zero, len_le_zero, inner_else;
int i;
POP_I32(len);
POP_I32(src_offset);
POP_GC_REF(src_obj);
POP_I32(dst_offset);
POP_GC_REF(dst_obj);
ADD_BASIC_BLOCK(check_objs_succ, "check array objs succ");
MOVE_BLOCK_AFTER_CURR(check_objs_succ);
BUILD_ISNULL(src_obj, cmp[0], "cmp_src_obj");
BUILD_ISNULL(dst_obj, cmp[1], "cmp_dst_obj");
/* src_obj is null or dst_obj is null, throw exception */
if (!(cmp[0] = LLVMBuildOr(comp_ctx->builder, cmp[0], cmp[1], ""))) {
aot_set_last_error("llvm build or failed.");
goto fail;
}
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_ARRAY_OBJ, true,
cmp[0], check_objs_succ))
goto fail;
/* Create if block */
ADD_BASIC_BLOCK(len_gt_zero, "len_gt_zero");
MOVE_BLOCK_AFTER_CURR(len_gt_zero);
/* Create else(end) block */
ADD_BASIC_BLOCK(len_le_zero, "len_le_zero");
MOVE_BLOCK_AFTER(len_le_zero, len_gt_zero);
/* Create inner else block */
ADD_BASIC_BLOCK(inner_else, "inner_else");
MOVE_BLOCK_AFTER(inner_else, len_gt_zero);
BUILD_ICMP(LLVMIntSGT, len, I32_ZERO, cmp[0], "cmp_len");
BUILD_COND_BR(cmp[0], len_gt_zero, len_le_zero);
/* Move builder to len > 0 block */
SET_BUILDER_POS(len_gt_zero);
/* dst_offset > UINT32_MAX - len */
if (!(boundary = LLVMBuildAdd(comp_ctx->builder, dst_offset, len, ""))) {
aot_set_last_error("llvm build failed.");
goto fail;
}
BUILD_ICMP(LLVMIntUGT, boundary, I32_CONST(UINT32_MAX), cmp[0],
"boundary_check1");
/* dst_offset + len > wasm_array_obj_length(dst_obj) */
if (!aot_array_obj_length(comp_ctx, dst_obj, &array_len))
goto fail;
BUILD_ICMP(LLVMIntUGT, boundary, array_len, cmp[1], "boundary_check2");
/* src_offset > UINT32_MAX - len */
if (!(boundary = LLVMBuildAdd(comp_ctx->builder, src_offset, len, ""))) {
aot_set_last_error("llvm build failed.");
goto fail;
}
BUILD_ICMP(LLVMIntUGT, boundary, I32_CONST(UINT32_MAX), cmp[2],
"boundary_check3");
/* src_offset + len > wasm_array_obj_length(src_obj) */
if (!aot_array_obj_length(comp_ctx, src_obj, &array_len))
goto fail;
BUILD_ICMP(LLVMIntUGT, boundary, array_len, cmp[3], "boundary_check4");
/* logical or above 4 boundary checks */
for (i = 1; i < 4; ++i) {
if (!(cmp[0] = LLVMBuildOr(comp_ctx->builder, cmp[0], cmp[i], ""))) {
aot_set_last_error("llvm build failed.");
goto fail;
}
}
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_ARRAY_IDX_OOB, true,
cmp[0], inner_else))
goto fail;
if (!aot_call_wasm_array_obj_copy(comp_ctx, func_ctx, dst_obj, dst_offset,
src_obj, src_offset, len))
goto fail;
BUILD_BR(len_le_zero);
SET_BUILDER_POS(len_le_zero);
return true;
fail:
return false;
}
bool
aot_compile_op_array_len(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
{
LLVMValueRef array_obj, cmp, array_len;
LLVMBasicBlockRef check_array_obj_succ;
POP_GC_REF(array_obj);
ADD_BASIC_BLOCK(check_array_obj_succ, "check array obj succ");
MOVE_BLOCK_AFTER_CURR(check_array_obj_succ);
BUILD_ISNULL(array_obj, cmp, "cmp_array_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_ARRAY_OBJ, true, cmp,
check_array_obj_succ))
goto fail;
if (!aot_array_obj_length(comp_ctx, array_obj, &array_len))
goto fail;
PUSH_I32(array_len);
return true;
fail:
return false;
}
bool
aot_compile_op_i31_new(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx)
{
LLVMValueRef i31_val, i31_obj;
POP_I32(i31_val);
/* i31_val <<= 1 */
if (!(i31_val = LLVMBuildShl(comp_ctx->builder, i31_val, I32_ONE,
"i31_val_shl"))) {
aot_set_last_error("llvm build shl failed.");
goto fail;
}
/* i31_val |= 1 */
if (!(i31_val =
LLVMBuildOr(comp_ctx->builder, i31_val, I32_ONE, "i31_val_or"))) {
aot_set_last_error("llvm build or failed.");
goto fail;
}
if (!(i31_obj = LLVMBuildIntToPtr(comp_ctx->builder, i31_val, GC_REF_TYPE,
"i31_obj"))) {
aot_set_last_error("llvm build bit cast failed.");
goto fail;
}
PUSH_GC_REF(i31_obj);
return true;
fail:
return false;
}
bool
aot_compile_op_i31_get(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
bool sign)
{
LLVMValueRef i31_obj, i31_val, cmp_i31_obj;
LLVMBasicBlockRef check_i31_obj_succ;
POP_GC_REF(i31_obj);
ADD_BASIC_BLOCK(check_i31_obj_succ, "check_i31_obj_succ");
MOVE_BLOCK_AFTER_CURR(check_i31_obj_succ);
/* Check if i31 object is NULL, throw exception if it is */
BUILD_ISNULL(i31_obj, cmp_i31_obj, "cmp_i31_obj");
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_NULL_I31_OBJ, true,
cmp_i31_obj, check_i31_obj_succ)) {
goto fail;
}
if (!(i31_val = LLVMBuildPtrToInt(comp_ctx->builder, i31_obj, I32_TYPE,
"i31_val"))) {
aot_set_last_error("llvm build ptr to init failed.");
goto fail;
}
if (!sign) {
if (!(i31_val = LLVMBuildLShr(comp_ctx->builder, i31_val, I32_ONE,
"i31_value"))) {
aot_set_last_error("llvm build lshr failed.");
goto fail;
}
}
else {
if (!(i31_val = LLVMBuildAShr(comp_ctx->builder, i31_val, I32_ONE,
"i31_value"))) {
aot_set_last_error("llvm build ashr failed.");
goto fail;
}
}
PUSH_I32(i31_val);
return true;
fail:
return false;
}
bool
aot_compile_op_ref_test(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
int32 heap_type, bool nullable)
{
LLVMValueRef gc_obj, ref_test_phi, cmp, castable;
LLVMBasicBlockRef block_curr, block_obj_non_null, block_end;
POP_GC_REF(gc_obj);
block_curr = CURR_BLOCK();
/* Create non-null object block */
ADD_BASIC_BLOCK(block_obj_non_null, "non_null_obj");
MOVE_BLOCK_AFTER_CURR(block_obj_non_null);
/* Create end block */
ADD_BASIC_BLOCK(block_end, "ref_test_end");
MOVE_BLOCK_AFTER(block_end, block_obj_non_null);
/* Create ref test result phi */
SET_BUILDER_POS(block_end);
if (!(ref_test_phi =
LLVMBuildPhi(comp_ctx->builder, INT1_TYPE, "ref_test_res"))) {
aot_set_last_error("llvm build phi failed");
return false;
}
/* Check if gc object is NULL */
SET_BUILDER_POS(block_curr);
BUILD_ISNULL(gc_obj, cmp, "cmp_gc_obj");
BUILD_COND_BR(cmp, block_end, block_obj_non_null);
if (nullable)
LLVMAddIncoming(ref_test_phi, &I1_ONE, &block_curr, 1);
else
LLVMAddIncoming(ref_test_phi, &I1_ZERO, &block_curr, 1);
/* Move builder to non-null object block */
SET_BUILDER_POS(block_obj_non_null);
if (heap_type >= 0) {
if (!aot_call_aot_obj_is_instance_of(comp_ctx, func_ctx, gc_obj,
I32_CONST(heap_type), &castable))
return false;
}
else {
if (!aot_call_wasm_obj_is_type_of(comp_ctx, func_ctx, gc_obj,
I32_CONST(heap_type), &castable))
return false;
}
if (!(castable = LLVMBuildICmp(comp_ctx->builder, LLVMIntNE, castable,
I8_ZERO, "castable"))) {
aot_set_last_error("llvm build icmp failed.");
return false;
}
BUILD_BR(block_end);
LLVMAddIncoming(ref_test_phi, &castable, &block_obj_non_null, 1);
SET_BUILDER_POS(block_end);
PUSH_COND(ref_test_phi);
return true;
fail:
return false;
}
bool
aot_compile_op_ref_cast(AOTCompContext *comp_ctx, AOTFuncContext *func_ctx,
int32 heap_type, bool nullable)
{
LLVMValueRef gc_obj, cmp, castable;
LLVMBasicBlockRef block_obj_non_null, block_end;
GET_GC_REF_FROM_STACK(gc_obj);
/* Create non null block */
ADD_BASIC_BLOCK(block_obj_non_null, "non_null_obj");
MOVE_BLOCK_AFTER_CURR(block_obj_non_null);
/* Create end block */
ADD_BASIC_BLOCK(block_end, "ref_cast_end");
MOVE_BLOCK_AFTER(block_end, block_obj_non_null);
BUILD_ISNULL(gc_obj, cmp, "obj_is_null");
if (nullable) {
BUILD_COND_BR(cmp, block_end, block_obj_non_null);
}
else {
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_CAST_FAILURE, true,
cmp, block_obj_non_null)) {
return false;
}
}
SET_BUILDER_POS(block_obj_non_null);
if (heap_type >= 0) {
if (!aot_call_aot_obj_is_instance_of(comp_ctx, func_ctx, gc_obj,
I32_CONST(heap_type), &castable))
return false;
}
else {
if (!aot_call_wasm_obj_is_type_of(comp_ctx, func_ctx, gc_obj,
I32_CONST(heap_type), &castable))
return false;
}
if (!(cmp = LLVMBuildICmp(comp_ctx->builder, LLVMIntEQ, castable, I8_ZERO,
"is_uncastable"))) {
aot_set_last_error("llvm build not failed");
return false;
}
if (!aot_emit_exception(comp_ctx, func_ctx, EXCE_CAST_FAILURE, true, cmp,
block_end)) {
return false;
}
SET_BUILDER_POS(block_end);
return true;
fail:
return false;
}
static bool
aot_call_wasm_externref_obj_to_internal_obj(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx,
LLVMValueRef externref_obj,
LLVMValueRef *gc_obj)
{
LLVMValueRef param_values[1], func, value, res;
LLVMTypeRef param_types[1], ret_type, func_type, func_ptr_type;
param_types[0] = GC_REF_TYPE;
ret_type = GC_REF_TYPE;
GET_AOT_FUNCTION(wasm_externref_obj_to_internal_obj, 1);
/* Call function wasm_externref_obj_to_internal_obj */
param_values[0] = externref_obj;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
1, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*gc_obj = res;
return true;
fail:
return false;
}
bool
aot_compile_op_extern_internalize(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx)
{
LLVMValueRef externref_obj, gc_obj, cmp, internal_obj_phi;
LLVMBasicBlockRef block_curr, block_obj_non_null, block_end;
POP_GC_REF(externref_obj);
block_curr = CURR_BLOCK();
/* Create non-null object block */
ADD_BASIC_BLOCK(block_obj_non_null, "non_null_obj");
MOVE_BLOCK_AFTER_CURR(block_obj_non_null);
/* Create end block */
ADD_BASIC_BLOCK(block_end, "internalize_end");
MOVE_BLOCK_AFTER(block_end, block_obj_non_null);
/* Create internalized object phi */
SET_BUILDER_POS(block_end);
if (!(internal_obj_phi =
LLVMBuildPhi(comp_ctx->builder, GC_REF_TYPE, "internal_obj"))) {
aot_set_last_error("llvm build phi failed");
return false;
}
/* Check if externref object is NULL */
SET_BUILDER_POS(block_curr);
BUILD_ISNULL(externref_obj, cmp, "cmp_externref_obj");
BUILD_COND_BR(cmp, block_end, block_obj_non_null);
LLVMAddIncoming(internal_obj_phi, &GC_REF_NULL, &block_curr, 1);
/* Move builder to non-null object block */
SET_BUILDER_POS(block_obj_non_null);
if (!aot_call_wasm_externref_obj_to_internal_obj(comp_ctx, func_ctx,
externref_obj, &gc_obj)) {
return false;
}
BUILD_BR(block_end);
LLVMAddIncoming(internal_obj_phi, &gc_obj, &block_obj_non_null, 1);
/* Move builder to end block */
SET_BUILDER_POS(block_end);
PUSH_GC_REF(internal_obj_phi);
return true;
fail:
return false;
}
static bool
aot_call_wasm_internal_obj_to_external_obj(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx,
LLVMValueRef gc_obj,
LLVMValueRef *externref_obj)
{
LLVMValueRef param_values[2], func, value, res;
LLVMTypeRef param_types[2], ret_type, func_type, func_ptr_type;
param_types[0] = INT8_PTR_TYPE;
param_types[1] = GC_REF_TYPE;
ret_type = GC_REF_TYPE;
GET_AOT_FUNCTION(wasm_internal_obj_to_externref_obj, 2);
/* Call function wasm_internal_obj_to_externref_obj() */
param_values[0] = func_ctx->exec_env;
param_values[1] = gc_obj;
if (!(res = LLVMBuildCall2(comp_ctx->builder, func_type, func, param_values,
2, "call"))) {
aot_set_last_error("llvm build call failed.");
goto fail;
}
*externref_obj = res;
return true;
fail:
return false;
}
bool
aot_compile_op_extern_externalize(AOTCompContext *comp_ctx,
AOTFuncContext *func_ctx)
{
LLVMValueRef gc_obj, cmp, external_obj_phi, externref_obj;
LLVMBasicBlockRef block_curr, block_obj_non_null, block_end;
if (!aot_gen_commit_values(comp_ctx->aot_frame))
return false;
if (!aot_gen_commit_sp_ip(comp_ctx->aot_frame, true, true))
return false;
POP_GC_REF(gc_obj);
block_curr = CURR_BLOCK();
/* Create non-null object block */
ADD_BASIC_BLOCK(block_obj_non_null, "non_null_obj");
MOVE_BLOCK_AFTER_CURR(block_obj_non_null);
/* Create end block */
ADD_BASIC_BLOCK(block_end, "externalize_end");
MOVE_BLOCK_AFTER(block_end, block_obj_non_null);
/* Create externalized object phi */
SET_BUILDER_POS(block_end);
if (!(external_obj_phi =
LLVMBuildPhi(comp_ctx->builder, GC_REF_TYPE, "external_obj"))) {
aot_set_last_error("llvm build phi failed");
return false;
}
/* Check if gc object is NULL */
SET_BUILDER_POS(block_curr);
BUILD_ISNULL(gc_obj, cmp, "cmp_gc_obj");
BUILD_COND_BR(cmp, block_end, block_obj_non_null);
LLVMAddIncoming(external_obj_phi, &GC_REF_NULL, &block_curr, 1);
/* Move builder to non-null object block */
SET_BUILDER_POS(block_obj_non_null);
if (!aot_call_wasm_internal_obj_to_external_obj(comp_ctx, func_ctx, gc_obj,
&externref_obj)) {
return false;
}
/* Check whether failed to externalize */
BUILD_ISNULL(externref_obj, cmp, "cmp_externref_obj");
if (!aot_emit_exception(comp_ctx, func_ctx,
EXCE_FAILED_TO_CREATE_EXTERNREF_OBJ, true, cmp,
block_end)) {
return false;
}
LLVMAddIncoming(external_obj_phi, &externref_obj, &block_obj_non_null, 1);
/* Move builder to end block */
SET_BUILDER_POS(block_end);
PUSH_GC_REF(external_obj_phi);
return true;
fail:
return false;
}
#endif /* end of WASM_ENABLE_GC != 0 */
Reference in New Issue View Git Blame Copy Permalink