text: /*
   * Copyright (C) 2019 Intel Corporation. All rights reserved.
   * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   */
  
  #include "aot_runtime.h"
  #include "bh_memory.h"
  #include "bh_log.h"
  #include "mem_alloc.h"
  
  static void
  set_error_buf(char *error_buf, uint32 error_buf_size, const char *string)
  {
      if (error_buf != NULL)
          snprintf(error_buf, error_buf_size, "%s", string);
  }
  
  static bool
  global_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
                     char *error_buf, uint32 error_buf_size)
  {
      uint32 i;
      InitializerExpression *init_expr;
      uint8 *p = (uint8*)module_inst->global_data.ptr;
      AOTImportGlobal *import_global = module->import_globals;;
      AOTGlobal *global = module->globals;
  
      /* Initialize import global data */
      for (i = 0; i < module->import_global_count; i++, import_global++) {
          bh_assert(import_global->data_offset ==
                    (uint32)(p - (uint8*)module_inst->global_data.ptr));
          memcpy(p, &import_global->global_data_linked, import_global->size);
          p += import_global->size;
      }
  
      /* Initialize defined global data */
      for (i = 0; i < module->global_count; i++, global++) {
          bh_assert(global->data_offset ==
                    (uint32)(p - (uint8*)module_inst->global_data.ptr));
          init_expr = &global->init_expr;
          switch (init_expr->init_expr_type) {
              case INIT_EXPR_TYPE_GET_GLOBAL:
                  bh_assert(init_expr->u.global_index < module->import_global_count);
                  memcpy(p,
                         &module->import_globals[init_expr->u.global_index].global_data_linked,
                         global->size);
                  break;
              default:
                  /* TODO: check whether global type and init_expr type are matching */
                  memcpy(p, &init_expr->u, global->size);
                  break;
          }
          p += global->size;
      }
  
      bh_assert(module_inst->global_data_size ==
                (uint32)(p - (uint8*)module_inst->global_data.ptr));
      return true;
  }
  
  static bool
  table_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
                    char *error_buf, uint32 error_buf_size)
  {
      uint32 i, global_index, global_data_offset, base_offset, length;
      AOTTableInitData *table_seg;
  
      if (module->table_init_data_count > 0) {
          for (i = 0; i < module->table_init_data_count; i++) {
              table_seg = module->table_init_data_list[i];
              bh_assert(table_seg->offset.init_expr_type ==
                              INIT_EXPR_TYPE_I32_CONST
                        || table_seg->offset.init_expr_type ==
                              INIT_EXPR_TYPE_GET_GLOBAL);
  
              /* Resolve table data base offset */
              if (table_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL) {
                  global_index = table_seg->offset.u.global_index;
                  bh_assert(global_index <
                            module->import_global_count + module->global_count);
                  /* TODO: && globals[table_seg->offset.u.global_index].type ==
                             VALUE_TYPE_I32*/
                  if (global_index < module->import_global_count)
                      global_data_offset =
                          module->import_globals[global_index].data_offset;
                  else
                      global_data_offset =
                          module->globals[global_index - module->import_global_count]
                                  .data_offset;
  
                  base_offset = *(uint32*)
                      ((uint8*)module_inst->global_data.ptr + global_data_offset);
              }
              else
                  base_offset = (uint32)table_seg->offset.u.i32;
  
              /* Copy table data */
              length = table_seg->func_index_count;
              if (base_offset < module_inst->table_size) {
                  memcpy((uint32*)module_inst->table_data.ptr + base_offset,
                         table_seg->func_indexes, length * sizeof(uint32));
              }
          }
      }
  
      return true;
  }
  
  static bool
  memory_instantiate(AOTModuleInstance *module_inst, AOTModule *module,
                     char *error_buf, uint32 error_buf_size)
  {
      uint32 i, global_index, global_data_offset, base_offset, length;
      AOTMemInitData *data_seg;
      uint64 total_size = (uint64)module->num_bytes_per_page * module->mem_init_page_count;
  
      /* Allocate memory */
      if (total_size >= UINT32_MAX
          || !(module_inst->memory_data.ptr = wasm_malloc((uint32)total_size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module instantiate failed: allocate memory failed.");
          return false;
      }
  
      memset(module_inst->memory_data.ptr, 0, (uint32)total_size);
  
      /* Init memory info */
      module_inst->memory_data_end.ptr = (uint8*)module_inst->memory_data.ptr
                                         + total_size;
      module_inst->memory_data_size = (uint32)total_size;
      module_inst->mem_cur_page_count = module->mem_init_page_count;
      module_inst->mem_max_page_count = module->mem_max_page_count;
  
      if (module->mem_init_page_count > 0) {
          for (i = 0; i < module->mem_init_data_count; i++) {
              data_seg = module->mem_init_data_list[i];
              bh_assert(data_seg->offset.init_expr_type ==
                              INIT_EXPR_TYPE_I32_CONST
                        || data_seg->offset.init_expr_type ==
                              INIT_EXPR_TYPE_GET_GLOBAL);
  
              /* Resolve memory data base offset */
              if (data_seg->offset.init_expr_type == INIT_EXPR_TYPE_GET_GLOBAL) {
                  global_index = data_seg->offset.u.global_index;
                  bh_assert(global_index <
                            module->import_global_count + module->global_count);
                  /* TODO: && globals[data_seg->offset.u.global_index].type ==
                             VALUE_TYPE_I32*/
                  if (global_index < module->import_global_count)
                      global_data_offset =
                          module->import_globals[global_index].data_offset;
                  else
                      global_data_offset =
                          module->globals[global_index - module->import_global_count]
                                  .data_offset;
  
                  base_offset = *(uint32*)
                      ((uint8*)module_inst->global_data.ptr + global_data_offset);
              }
              else
                  base_offset = (uint32)data_seg->offset.u.i32;
  
              length = data_seg->byte_count;
  
              /* Check memory data */
              if (length > 0
                  && (base_offset >= module_inst->memory_data_size
                      || base_offset + length > module_inst->memory_data_size)) {
                  wasm_free(module_inst->memory_data.ptr);
                  module_inst->memory_data.ptr = NULL;
                  set_error_buf(error_buf, error_buf_size,
                               "AOT module instantiate failed: data segment out of range.");
                  return false;
              }
  
              /* Copy memory data */
              memcpy((uint8*)module_inst->memory_data.ptr + base_offset,
                     data_seg->bytes, length);
          }
      }
  
      return true;
  }
  
  static bool
  init_func_ptrs(AOTModuleInstance *module_inst, AOTModule *module,
                 char *error_buf, uint32 error_buf_size)
  {
      uint32 i;
      void **func_ptrs;
      uint64 total_size =
          ((uint64)module->import_func_count + module->func_count) * sizeof(void*);
  
      /* Allocate memory */
      if (total_size >= UINT32_MAX
          || !(module_inst->func_ptrs.ptr = wasm_malloc((uint32)total_size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module instantiate failed: allocate memory failed.");
          return false;
      }
  
      memset(module_inst->func_ptrs.ptr, 0, (uint32)total_size);
  
      /* Set import function pointers */
      func_ptrs = (void**)module_inst->func_ptrs.ptr;
      for (i = 0; i < module->import_func_count; i++, func_ptrs++)
          *func_ptrs = (void*)module->import_funcs[i].func_ptr_linked;
  
      /* Set defined function pointers */
      memcpy(func_ptrs, module->func_ptrs, module->func_count * sizeof(void*));
      return true;
  }
  
  static bool
  init_func_type_indexes(AOTModuleInstance *module_inst, AOTModule *module,
                         char *error_buf, uint32 error_buf_size)
  {
      uint32 i;
      uint32 *func_type_index;
      uint64 total_size =
          ((uint64)module->import_func_count + module->func_count) * sizeof(uint32);
  
      /* Allocate memory */
      if (total_size >= UINT32_MAX
          || !(module_inst->func_type_indexes.ptr = wasm_malloc((uint32)total_size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module instantiate failed: allocate memory failed.");
          return false;
      }
  
      memset(module_inst->func_type_indexes.ptr, 0, (uint32)total_size);
  
      /* Set import function type indexes */
      func_type_index = (uint32*)module_inst->func_type_indexes.ptr;
      for (i = 0; i < module->import_func_count; i++, func_type_index++)
          *func_type_index = module->import_funcs[i].func_type_index;
  
      memcpy(func_type_index, module->func_type_indexes,
             module->func_count * sizeof(uint32));
  
      return true;
  }
  
  static bool
  execute_post_inst_function(AOTModuleInstance *module_inst)
  {
      AOTFunctionInstance *post_inst_func =
          aot_lookup_function(module_inst, "__post_instantiate", "()");
  
      if (!post_inst_func)
          /* Not found */
          return true;
  
      return aot_create_exec_env_and_call_function(module_inst, post_inst_func, 0, NULL);
  }
  
  static bool
  execute_start_function(AOTModuleInstance *module_inst)
  {
      AOTModule *module = (AOTModule*)module_inst->aot_module.ptr;
      WASMExecEnv *exec_env;
      typedef void (*F)(WASMExecEnv*);
      union { F f; void *v; } u;
  
      if (!module->start_function)
          return true;
  
      if (!(exec_env = wasm_exec_env_create((WASMModuleInstanceCommon*)module_inst,
                                            module_inst->default_wasm_stack_size))) {
          aot_set_exception(module_inst, "allocate memory failed.");
          return false;
      }
  
      u.v = module->start_function;
      u.f(exec_env);
  
      wasm_exec_env_destroy(exec_env);
      return !aot_get_exception(module_inst);
  }
  
  AOTModuleInstance*
  aot_instantiate(AOTModule *module,
                  uint32 stack_size, uint32 heap_size,
                  char *error_buf, uint32 error_buf_size)
  {
      AOTModuleInstance *module_inst;
      uint32 module_inst_struct_size =
          offsetof(AOTModuleInstance, global_table_heap_data.bytes);
      uint64 table_data_size = (uint64)module->table_size * sizeof(uint32);
      uint64 total_size = (uint64)module_inst_struct_size
                          + module->global_data_size
                          + table_data_size + heap_size;
      void *heap_handle;
      uint8 *p;
  
      /* Check heap size */
      heap_size = align_uint(heap_size, 8);
      if (heap_size == 0)
          heap_size = APP_HEAP_SIZE_DEFAULT;
      if (heap_size < APP_HEAP_SIZE_MIN)
          heap_size = APP_HEAP_SIZE_MIN;
      if (heap_size > APP_HEAP_SIZE_MAX)
          heap_size = APP_HEAP_SIZE_MAX;
  
      /* Allocate module instance, global data, table data and heap data */
      if (total_size >= UINT32_MAX
          || !(module_inst = wasm_malloc((uint32)total_size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module instantiate failed: allocate memory failed.");
          return NULL;
      }
  
      memset(module_inst, 0, total_size);
      module_inst->module_type = Wasm_Module_AoT;
      module_inst->aot_module.ptr = module;
  
      /* Initialize global info */
      p = (uint8*)module_inst + module_inst_struct_size;
      module_inst->global_data.ptr = p;
      module_inst->global_data_size = module->global_data_size;
      if (!global_instantiate(module_inst, module, error_buf, error_buf_size))
          goto fail;
  
      /* Initialize table info */
      p += module->global_data_size;
      module_inst->table_data.ptr = p;
      module_inst->table_size = module->table_size;
      /* Set all elements to -1 to mark them as uninitialized elements */
      memset(module_inst->table_data.ptr, -1, (uint32)table_data_size);
      if (!table_instantiate(module_inst, module, error_buf, error_buf_size))
          goto fail;
  
      /* Initialize heap info */
      p += (uint32)table_data_size;
      module_inst->heap_data.ptr = p;
      p += heap_size;
      module_inst->heap_data_end.ptr = p;
      module_inst->heap_data_size = heap_size;
  #if WASM_ENABLE_MEMORY_GROW != 0
      module_inst->heap_base_offset = DEFAULT_APP_HEAP_BASE_OFFSET;
  #else
      module_inst->heap_base_offset = module_inst->memory_data_size;
  #endif
      if (!(heap_handle = mem_allocator_create(module_inst->heap_data.ptr,
                                               heap_size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module instantiate failed: init app heap failed.");
          goto fail;
      }
      module_inst->heap_handle.ptr = heap_handle;
  
      /* Initialize memory space */
      if (!memory_instantiate(module_inst, module, error_buf, error_buf_size))
          goto fail;
  
      /* Initialize function pointers */
      if (!init_func_ptrs(module_inst, module, error_buf, error_buf_size))
          goto fail;
  
      /* Initialize function type indexes */
      if (!init_func_type_indexes(module_inst, module, error_buf, error_buf_size))
          goto fail;
  
  #if WASM_ENABLE_LIBC_WASI != 0
      if (!wasm_runtime_init_wasi((WASMModuleInstanceCommon*)module_inst,
                                  module->wasi_args.dir_list,
                                  module->wasi_args.dir_count,
                                  module->wasi_args.map_dir_list,
                                  module->wasi_args.map_dir_count,
                                  module->wasi_args.env,
                                  module->wasi_args.env_count,
                                  module->wasi_args.argv,
                                  module->wasi_args.argc,
                                  error_buf, error_buf_size))
          goto fail;
  #endif
  
      /* Initialize the thread related data */
      if (stack_size == 0)
          stack_size = DEFAULT_WASM_STACK_SIZE;
      module_inst->default_wasm_stack_size = stack_size;
  
      /* Execute __post_instantiate function and start function*/
      if (!execute_post_inst_function(module_inst)
          || !execute_start_function(module_inst)) {
          set_error_buf(error_buf, error_buf_size,
                        module_inst->cur_exception);
          goto fail;
      }
  
      return module_inst;
  
  fail:
      aot_deinstantiate(module_inst);
      return NULL;
  }
  
  void
  aot_deinstantiate(AOTModuleInstance *module_inst)
  {
  #if WASM_ENABLE_LIBC_WASI != 0
      /* Destroy wasi resource before freeing app heap, since some fields of
         wasi contex are allocated from app heap, and if app heap is freed,
         these fields will be set to NULL, we cannot free their internal data
         which may allocated from global heap. */
      wasm_runtime_destroy_wasi((WASMModuleInstanceCommon*)module_inst);
  #endif
  
      if (module_inst->memory_data.ptr)
          wasm_free(module_inst->memory_data.ptr);
  
      if (module_inst->heap_handle.ptr)
          mem_allocator_destroy(module_inst->heap_handle.ptr);
  
      if (module_inst->func_ptrs.ptr)
          wasm_free(module_inst->func_ptrs.ptr);
  
      if (module_inst->func_type_indexes.ptr)
          wasm_free(module_inst->func_type_indexes.ptr);
  
      wasm_free(module_inst);
  }
  
  AOTFunctionInstance*
  aot_lookup_function(const AOTModuleInstance *module_inst,
                      const char *name, const char *signature)
  {
      uint32 i;
      AOTModule *module = (AOTModule*)module_inst->aot_module.ptr;
  
      for (i = 0; i < module->export_func_count; i++)
          if (!strcmp(module->export_funcs[i].func_name, name))
              return &module->export_funcs[i];
      (void)signature;
      return NULL;
  }
  
  #define PUT_I64_TO_ADDR(addr, value) do {       \
      union { int64 val; uint32 parts[2]; } u;    \
      u.val = (value);                            \
      (addr)[0] = u.parts[0];                     \
      (addr)[1] = u.parts[1];                     \
    } while (0)
  
  #define PUT_F64_TO_ADDR(addr, value) do {       \
      union { float64 val; uint32 parts[2]; } u;  \
      u.val = (value);                            \
      (addr)[0] = u.parts[0];                     \
      (addr)[1] = u.parts[1];                     \
    } while (0)
  
  bool
  aot_call_function(WASMExecEnv *exec_env,
                    AOTFunctionInstance *function,
                    unsigned argc, uint32 argv[])
  {
      AOTModuleInstance *module_inst = (AOTModuleInstance*)exec_env->module_inst;
      AOTFuncType *func_type = function->func_type;
      bool ret = wasm_runtime_invoke_native(exec_env, function->func_ptr,
                                            func_type, NULL, argv, argc, argv);
      return ret && !aot_get_exception(module_inst) ? true : false;
  }
  
  bool
  aot_create_exec_env_and_call_function(AOTModuleInstance *module_inst,
                                        AOTFunctionInstance *func,
                                        unsigned argc, uint32 argv[])
  {
      WASMExecEnv *exec_env;
      bool ret;
  
      if (!(exec_env = wasm_exec_env_create((WASMModuleInstanceCommon*)module_inst,
                                            module_inst->default_wasm_stack_size))) {
          aot_set_exception(module_inst, "allocate memory failed.");
          return false;
      }
  
      ret = aot_call_function(exec_env, func, argc, argv);
      wasm_exec_env_destroy(exec_env);
      return ret;
  }
  
  void
  aot_set_exception(AOTModuleInstance *module_inst,
                    const char *exception)
  {
      if (exception)
          snprintf(module_inst->cur_exception,
                   sizeof(module_inst->cur_exception),
                   "Exception: %s", exception);
      else
          module_inst->cur_exception[0] = '\0';
  }
  
  void
  aot_set_exception_with_id(AOTModuleInstance *module_inst,
                            uint32 id)
  {
      switch (id) {
          case EXCE_UNREACHABLE:
              aot_set_exception(module_inst, "unreachable");
              break;
          case EXCE_OUT_OF_MEMORY:
              aot_set_exception(module_inst, "allocate memory failed");
              break;
          case EXCE_OUT_OF_BOUNDS_MEMORY_ACCESS:
              aot_set_exception(module_inst, "out of bounds memory access");
              break;
          case EXCE_INTEGER_OVERFLOW:
              aot_set_exception(module_inst, "integer overflow");
              break;
          case EXCE_INTEGER_DIVIDE_BY_ZERO:
              aot_set_exception(module_inst, "integer divide by zero");
              break;
          case EXCE_INVALID_CONVERSION_TO_INTEGER:
              aot_set_exception(module_inst, "invalid conversion to integer");
              break;
          case EXCE_INVALID_FUNCTION_TYPE_INDEX:
              aot_set_exception(module_inst, "indirect call type mismatch");
              break;
          case EXCE_INVALID_FUNCTION_INDEX:
              aot_set_exception(module_inst, "invalid function index");
              break;
          case EXCE_UNDEFINED_ELEMENT:
              aot_set_exception(module_inst, "undefined element");
              break;
          case EXCE_UNINITIALIZED_ELEMENT:
              aot_set_exception(module_inst, "uninitialized element");
              break;
          case EXCE_CALL_UNLINKED_IMPORT_FUNC:
              aot_set_exception(module_inst, "fail to call unlinked import function");
              break;
          default:
              break;
      }
  }
  
  const char*
  aot_get_exception(AOTModuleInstance *module_inst)
  {
      if (module_inst->cur_exception[0] == '\0')
          return NULL;
      else
          return module_inst->cur_exception;
  }
  
  void
  aot_clear_exception(AOTModuleInstance *module_inst)
  {
      module_inst->cur_exception[0] = '\0';
  }
  
  int32
  aot_module_malloc(AOTModuleInstance *module_inst, uint32 size,
                    void **p_native_addr)
  {
      uint8 *addr =
          mem_allocator_malloc(module_inst->heap_handle.ptr, size);
  
      if (p_native_addr)
          *p_native_addr = addr;
      if (!addr) {
          aot_set_exception(module_inst, "out of memory");
          return 0;
      }
      return (int32)(module_inst->heap_base_offset
                     + (addr - (uint8*)module_inst->heap_data.ptr));
  }
  
  void
  aot_module_free(AOTModuleInstance *module_inst, int32 ptr)
  {
      if (ptr) {
          uint8 *addr = (uint8*)module_inst->heap_data.ptr
                         + (ptr - module_inst->heap_base_offset);
          if ((uint8*)module_inst->heap_data.ptr < addr
              && addr < (uint8*)module_inst->heap_data_end.ptr)
              mem_allocator_free(module_inst->heap_handle.ptr, addr);
      }
  }
  
  int32
  aot_module_dup_data(AOTModuleInstance *module_inst,
                      const char *src, uint32 size)
  {
      char *buffer;
      int32 buffer_offset = aot_module_malloc(module_inst, size,
                                              (void**)&buffer);
  
      if (buffer_offset != 0) {
          buffer = aot_addr_app_to_native(module_inst, buffer_offset);
          memcpy(buffer, src, size);
      }
      return buffer_offset;
  }
  
  bool
  aot_validate_app_addr(AOTModuleInstance *module_inst,
                        int32 app_offset, uint32 size)
  {
      uint8 *addr;
  
      /* integer overflow check */
      if(app_offset + (int32)size < app_offset) {
          goto fail;
      }
  
      if (0 <= app_offset
          && app_offset < (int32)module_inst->memory_data_size) {
          addr = (uint8*)module_inst->memory_data.ptr + app_offset;
          if (!((uint8*)module_inst->memory_data.ptr <= addr
                && addr + size <= (uint8*)module_inst->memory_data_end.ptr))
              goto fail;
          return true;
      }
      /* Currently heap_size is no more than 1G, and heap_base_offset is 1G,
         heap_base_offset + heap_data_size will not be larger than INT32_MAX */
      else if (module_inst->heap_base_offset < app_offset
               && app_offset < module_inst->heap_base_offset
                               + (int32)module_inst->heap_data_size) {
          addr = (uint8*)module_inst->heap_data.ptr
                 + (app_offset - module_inst->heap_base_offset);
          if (!((uint8*)module_inst->heap_data.ptr <= addr
                 && addr + size <= (uint8*)module_inst->heap_data_end.ptr))
              goto fail;
          return true;
      }
  
  fail:
      aot_set_exception(module_inst, "out of bounds memory access");
      return false;
  }
  
  bool
  aot_validate_native_addr(AOTModuleInstance *module_inst,
                           void *native_ptr, uint32 size)
  {
      uint8 *addr = native_ptr;
  
      /* integer overflow check */
      if (addr + size < addr) {
          goto fail;
      }
  
      if (((uint8*)module_inst->memory_data.ptr <= addr
           && addr + size <= (uint8*)module_inst->memory_data_end.ptr)
          || ((uint8*)module_inst->heap_data.ptr <= addr
              && addr + size <= (uint8*)module_inst->heap_data_end.ptr)
         )
          return true;
  
  fail:
      aot_set_exception(module_inst, "out of bounds memory access");
      return false;
  }
  
  void *
  aot_addr_app_to_native(AOTModuleInstance *module_inst, int32 app_offset)
  {
      if (0 <= app_offset && app_offset < module_inst->heap_base_offset)
          return (uint8*)module_inst->memory_data.ptr + app_offset;
  
      if (module_inst->heap_base_offset < app_offset
          && app_offset < module_inst->heap_base_offset
                          + (int32)module_inst->heap_data_size)
          return (uint8*)module_inst->heap_data.ptr
                 + (app_offset - module_inst->heap_base_offset);
  
      return NULL;
  }
  
  int32
  aot_addr_native_to_app(AOTModuleInstance *module_inst, void *native_ptr)
  {
      if ((uint8*)module_inst->memory_data.ptr <= (uint8*)native_ptr
          && (uint8*)native_ptr < (uint8*)module_inst->memory_data_end.ptr)
          return (int32)((uint8*)native_ptr - (uint8*)module_inst->memory_data.ptr);
  
      if ((uint8*)module_inst->heap_data.ptr <= (uint8*)native_ptr
          && (uint8*)native_ptr < (uint8*)module_inst->heap_data_end.ptr)
          return (int32)(module_inst->heap_base_offset
                         + ((uint8*)native_ptr - (uint8*)module_inst->heap_data.ptr));
  
      return 0;
  }
  
  bool
  aot_get_app_addr_range(AOTModuleInstance *module_inst,
                         int32 app_offset,
                         int32 *p_app_start_offset,
                         int32 *p_app_end_offset)
  {
      int32 app_start_offset, app_end_offset;
  
      if (0 <= app_offset && app_offset < (int32)module_inst->memory_data_size) {
          app_start_offset = 0;
          app_end_offset = (int32)module_inst->memory_data_size;
      }
      else if (module_inst->heap_base_offset < app_offset
               && app_offset < module_inst->heap_base_offset
                               + (int32)module_inst->heap_data_size) {
          app_start_offset = module_inst->heap_base_offset;
          app_end_offset = module_inst->heap_base_offset
                           + (int32)module_inst->heap_data_size;
      }
      else
          return false;
  
      if (p_app_start_offset)
          *p_app_start_offset = app_start_offset;
      if (p_app_end_offset)
          *p_app_end_offset = app_end_offset;
      return true;
  }
  
  bool
  aot_get_native_addr_range(AOTModuleInstance *module_inst,
                            uint8 *native_ptr,
                            uint8 **p_native_start_addr,
                            uint8 **p_native_end_addr)
  {
      uint8 *native_start_addr, *native_end_addr;
  
      if ((uint8*)module_inst->memory_data.ptr <= (uint8*)native_ptr
          && (uint8*)native_ptr < (uint8*)module_inst->memory_data_end.ptr) {
          native_start_addr = (uint8*)module_inst->memory_data.ptr;
          native_end_addr = (uint8*)module_inst->memory_data_end.ptr;
      }
      else if ((uint8*)module_inst->heap_data.ptr <= (uint8*)native_ptr
               && (uint8*)native_ptr < (uint8*)module_inst->heap_data_end.ptr) {
          native_start_addr = (uint8*)module_inst->heap_data.ptr;
          native_end_addr = (uint8*)module_inst->heap_data_end.ptr;
      }
      else
          return false;
  
      if (p_native_start_addr)
          *p_native_start_addr = native_start_addr;
      if (p_native_end_addr)
          *p_native_end_addr = native_end_addr;
      return true;
  }
  
  bool
  aot_enlarge_memory(AOTModuleInstance *module_inst, uint32 inc_page_count)
  {
      uint8 *mem_data_old = module_inst->memory_data.ptr, *mem_data_new;
      uint32 num_bytes_per_page =
          ((AOTModule*)module_inst->aot_module.ptr)->num_bytes_per_page;
      uint32 cur_page_count = module_inst->mem_cur_page_count;
      uint32 max_page_count = module_inst->mem_max_page_count;
      uint32 total_page_count = cur_page_count + inc_page_count;
      uint32 old_size = num_bytes_per_page * cur_page_count;
      uint64 total_size = (uint64)num_bytes_per_page * total_page_count;
  
      if (inc_page_count <= 0)
          /* No need to enlarge memory */
          return true;
  
      if (total_page_count < cur_page_count /* integer overflow */
          || total_page_count > max_page_count) {
          aot_set_exception(module_inst, "fail to enlarge memory.");
          return false;
      }
  
      if (total_size >= UINT32_MAX
          || !(mem_data_new = wasm_malloc((uint32)total_size))) {
          aot_set_exception(module_inst, "fail to enlarge memory.");
          return false;
      }
  
      memcpy(mem_data_new, mem_data_old, old_size);
      memset(mem_data_new + old_size, 0, (uint32)total_size - old_size);
      module_inst->mem_cur_page_count = total_page_count;
      module_inst->memory_data_size = (uint32)total_size;
      module_inst->memory_data.ptr = mem_data_new;
      module_inst->memory_data_end.ptr = mem_data_new + (uint32)total_size;
  
      wasm_free(mem_data_old);
      return true;
  }
  
  bool
  aot_is_wasm_type_equal(AOTModuleInstance *module_inst,
                         uint32 type1_idx, uint32 type2_idx)
  {
      WASMType *type1, *type2;
      AOTModule *module = (AOTModule*)module_inst->aot_module.ptr;
  
      if (type1_idx >= module->func_type_count
          || type2_idx >= module->func_type_count) {
          aot_set_exception(module_inst, "type index out of bounds");
          return false;
      }
  
      if (type1_idx == type2_idx)
          return true;
  
      type1 = module->func_types[type1_idx];
      type2 = module->func_types[type2_idx];
  
      return wasm_type_equal(type1, type2);
  }
  
  void
  aot_invoke_native(WASMExecEnv *exec_env, uint32 func_idx,
                    uint32 *frame_lp, uint32 argc, uint32 *argv_ret)
  {
      AOTModuleInstance *module_inst = (AOTModuleInstance*)
                              wasm_runtime_get_module_inst(exec_env);
      AOTModule *aot_module = (AOTModule*)module_inst->aot_module.ptr;
      uint32 *func_type_indexes = (uint32*)module_inst->func_type_indexes.ptr;
      uint32 func_type_idx = func_type_indexes[func_idx];
      AOTFuncType *func_type = aot_module->func_types[func_type_idx];
      void **func_ptrs = (void**)module_inst->func_ptrs.ptr;
      void *func_ptr = func_ptrs[func_idx];
      AOTImportFunc *import_func;
      const char *signature = NULL;
      char buf[128];
  
      if (func_idx < aot_module->import_func_count) {
          import_func = aot_module->import_funcs + func_idx;
          if (!func_ptr) {
              snprintf(buf, sizeof(buf),
                      "fail to call unlinked import function (%s, %s)",
                      import_func->module_name, import_func->func_name);
              aot_set_exception(module_inst, buf);
              return;
          }
          signature = import_func->signature;
      }
      wasm_runtime_invoke_native(exec_env, func_ptr,
                                 func_type, signature, frame_lp, argc, argv_ret);
  }
  
  