text: /*
   * Copyright (C) 2019 Intel Corporation. All rights reserved.
   * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   */
  
  #include "aot_runtime.h"
  #include "bh_common.h"
  #include "bh_memory.h"
  #include "bh_log.h"
  #include "../common/wasm_runtime_common.h"
  #include "../common/wasm_native.h"
  #include "../compilation/aot.h"
  #if WASM_ENABLE_JIT != 0
  #include "../compilation/aot_llvm.h"
  #include "../interpreter/wasm_loader.h"
  #endif
  
  
  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);
  }
  
  #define exchange_uint8(p_data) (void)0
  
  static void
  exchange_uint16(uint8 *p_data)
  {
      uint8 value = *p_data;
      *p_data = *(p_data + 1);
      *(p_data + 1) = value;
  }
  
  static void
  exchange_uint32(uint8 *p_data)
  {
      uint8 value = *p_data;
      *p_data = *(p_data + 3);
      *(p_data + 3) = value;
  
      value = *(p_data + 1);
      *(p_data + 1) = *(p_data + 2);
      *(p_data + 2) = value;
  }
  
  static void
  exchange_uint64(uint8 *pData)
  {
      exchange_uint32(pData);
      exchange_uint32(pData + 4);
  }
  
  static union {
      int a;
      char b;
  } __ue = { .a = 1 };
  
  #define is_little_endian() (__ue.b == 1)
  
  #define CHECK_BUF(buf, buf_end, length) do {                \
      if (buf + length > buf_end) {                           \
        set_error_buf(error_buf, error_buf_size,              \
                      "Read data failed: unexpected end.");   \
        goto fail;                                            \
      }                                                       \
    } while (0)
  
  static uint8*
  align_ptr(const uint8 *p, uint32 b)
  {
      uintptr_t v = (uintptr_t)p;
      uintptr_t m = b - 1;
      return (uint8*)((v + m) & ~m);
  }
  
  static inline uint64
  GET_U64_FROM_ADDR(uint32 *addr)
  {
      union { uint64 val; uint32 parts[2]; } u;
      u.parts[0] = addr[0];
      u.parts[1] = addr[1];
      return u.val;
  }
  
  #define TEMPLATE_READ(p, p_end, res, type) do {    \
      if (sizeof(type) != sizeof(uint64))            \
        p = (uint8*)align_ptr(p, sizeof(type));      \
      else                                           \
        /* align 4 bytes if type is uint64 */        \
        p = (uint8*)align_ptr(p, sizeof(uint32));    \
      CHECK_BUF(p, p_end, sizeof(type));             \
      if (sizeof(type) != sizeof(uint64))            \
        res = *(type*)p;                             \
      else                                           \
        res = (type)GET_U64_FROM_ADDR((uint32*)p);   \
      if (!is_little_endian())                       \
        exchange_##type((uint8*)&res);               \
      p += sizeof(type);                             \
    } while (0)
  
  #define read_uint8(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint8)
  #define read_uint16(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint16)
  #define read_uint32(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint32)
  #define read_uint64(p, p_end, res) TEMPLATE_READ(p, p_end, res, uint64)
  
  #define read_byte_array(p, p_end, addr, len) do { \
      CHECK_BUF(p, p_end, len);                     \
      memcpy(addr, p, len);                         \
      p += len;                                     \
    } while (0)
  
  #define read_string(p, p_end, str) do {           \
      uint16 str_len;                               \
      read_uint16(p, p_end, str_len);               \
      CHECK_BUF(p, p_end, str_len);                 \
      if (!(str = const_str_set_insert              \
                    (p, str_len, module,            \
                     error_buf, error_buf_size))) { \
          goto fail;                                \
      }                                             \
      p += str_len;                                 \
    } while (0)
  
  /* Legal values for bin_type */
  #define BIN_TYPE_ELF32L 0           /* 32-bit little endian */
  #define BIN_TYPE_ELF32B 1           /* 32-bit big endian */
  #define BIN_TYPE_ELF64L 2           /* 64-bit little endian */
  #define BIN_TYPE_ELF64B 3           /* 64-bit big endian */
  
  /* Legal values for e_type (object file type). */
  #define E_TYPE_NONE     0           /* No file type */
  #define E_TYPE_REL      1           /* Relocatable file */
  #define E_TYPE_EXEC     2           /* Executable file */
  #define E_TYPE_DYN      3           /* Shared object file */
  
  /* Legal values for e_machine (architecture).  */
  #define E_MACHINE_386       3       /* Intel 80386 */
  #define E_MACHINE_MIPS      8       /* MIPS R3000 big-endian */
  #define E_MACHINE_MIPS_RS3_LE  10   /* MIPS R3000 little-endian */
  #define E_MACHINE_ARM      40       /* ARM/Thumb */
  #define E_MACHINE_ARC      45       /* Argonaut RISC Core */
  #define E_MACHINE_IA_64    50       /* Intel Merced */
  #define E_MACHINE_MIPS_X   51       /* Stanford MIPS-X */
  #define E_MACHINE_X86_64   62       /* AMD x86-64 architecture */
  #define E_MACHINE_XTENSA   94       /* Tensilica Xtensa Architecture */
  
  /* Legal values for e_version */
  #define E_VERSION_CURRENT  1        /* Current version */
  
  static char*
  const_str_set_insert(const uint8 *str, int32 len, AOTModule *module,
                       char* error_buf, uint32 error_buf_size)
  {
      HashMap *set = module->const_str_set;
      char *c_str = wasm_malloc((uint32)len + 1), *value;
  
      if (!c_str) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return NULL;
      }
  
      bh_memcpy_s(c_str, (uint32)(len + 1), str, (uint32)len);
      c_str[len] = '\0';
  
      if ((value = bh_hash_map_find(set, c_str))) {
          wasm_free(c_str);
          return value;
      }
  
      if (!bh_hash_map_insert(set, c_str, c_str)) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "insert string to hash map failed.");
          wasm_free(c_str);
          return NULL;
      }
  
      return c_str;
  }
  
  static void
  get_current_target(char *target_buf, uint32 target_buf_size)
  {
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
      snprintf(target_buf, target_buf_size, "x86_64");
  #elif defined(BUILD_TARGET_X86_32)
      snprintf(target_buf, target_buf_size, "i386");
  #elif defined(BUILD_TARGET_ARM) \
        || defined(BUILD_TARGET_ARM_VFP) \
        || defined(BUILD_TARGET_THUMB) \
        || defined(BUILD_TARGET_THUMB_VFP)
      char *build_target = BUILD_TARGET;
      char *p = target_buf, *p_end;
      snprintf(target_buf, target_buf_size, "%s", build_target);
      p_end = p + strlen(target_buf);
      while (p < p_end) {
          if (*p >= 'A' && *p <= 'Z')
              *p++ += 'a' - 'A';
          else
              p++;
      }
      if (!strcmp(target_buf, "arm"))
          snprintf(target_buf, target_buf_size, "armv4");
      else if (!strcmp(target_buf, "thumb"))
          snprintf(target_buf, target_buf_size, "thumbv4t");
  #elif defined(BUILD_TARGET_MIPS)
      snprintf(target_buf, target_buf_size, "mips");
  #elif defined(BUILD_TARGET_XTENSA)
      snprintf(target_buf, target_buf_size, "xtensa");
  #endif
  }
  
  static bool
  get_aot_file_target(AOTTargetInfo *target_info,
                      char *target_buf, uint32 target_buf_size,
                      char *error_buf, uint32 error_buf_size)
  {
      char *machine_type = NULL;
      switch (target_info->e_machine) {
          case E_MACHINE_X86_64:
              machine_type = "x86_64";
              break;
          case E_MACHINE_386:
              machine_type = "i386";
              break;
          case E_MACHINE_ARM:
              machine_type = target_info->arch;
              break;
          case E_MACHINE_MIPS:
              machine_type = "mips";
              break;
          case E_MACHINE_XTENSA:
              machine_type = "xtensa";
              break;
          default:
              if (error_buf)
                  snprintf(error_buf, error_buf_size,
                           "AOT module load failed: unknown machine type %d.",
                           target_info->e_machine);
              return false;
      }
      if (strncmp(target_info->arch, machine_type, strlen(machine_type))) {
          if (error_buf)
              snprintf(error_buf, error_buf_size,
                       "AOT module load failed: "
                       "machine type (%s) isn't consistent with target type (%s).",
                       machine_type, target_info->arch);
          return false;
      }
      snprintf(target_buf, target_buf_size, "%s", target_info->arch);
      return true;
  }
  
  static bool
  check_machine_info(AOTTargetInfo *target_info,
                     char *error_buf, uint32 error_buf_size)
  {
      char target_expected[32], target_got[32];
  
      get_current_target(target_expected, sizeof(target_expected));
  
      if (!get_aot_file_target(target_info, target_got, sizeof(target_got),
                               error_buf, error_buf_size))
          return false;
  
      if (strcmp(target_expected, target_got)) {
          if (error_buf) {
            snprintf(error_buf, error_buf_size,
                    "AOT module load failed: invalid target type, "
                    "expected %s but got %s.",
                    target_expected, target_got);
          }
          return false;
      }
  
      return true;
  }
  
  static bool
  load_target_info_section(const uint8 *buf, const uint8 *buf_end,
                           AOTModule *module,
                           char *error_buf, uint32 error_buf_size)
  {
      AOTTargetInfo target_info;
      const uint8 *p = buf, *p_end = buf_end;
      bool is_target_little_endian, is_target_64_bit;
  
      read_uint32(p, p_end, target_info.bin_type);
      read_uint16(p, p_end, target_info.e_type);
      read_uint16(p, p_end, target_info.e_machine);
      read_uint32(p, p_end, target_info.e_version);
      read_uint32(p, p_end, target_info.e_flags);
      read_uint32(p, p_end, target_info.reserved);
      read_byte_array(p, p_end,
                      target_info.arch, sizeof(target_info.arch));
  
      if (p != buf_end) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid section size.");
          return false;
      }
  
      /* Check target endian type */
      is_target_little_endian = target_info.bin_type & 1 ? false : true;
      if (is_little_endian() != is_target_little_endian) {
          if (error_buf)
            snprintf(error_buf, error_buf_size,
                     "AOT module load failed: "
                     "invalid target endian type, expected %s but got %s.",
                     is_little_endian() ? "little endian" : "big endian",
                     is_target_little_endian ? "little endian" : "big endian");
          return false;
      }
  
      /* Check target bit width */
      is_target_64_bit = target_info.bin_type & 2 ? true : false;
      if ((sizeof(void*) == 8 ? true : false) != is_target_64_bit) {
          if (error_buf)
            snprintf(error_buf, error_buf_size,
                     "AOT module load failed: "
                     "invalid target bit width, expected %s but got %s.",
                     sizeof(void*) == 8 ? "64-bit" : "32-bit",
                     is_target_64_bit ? "64-bit" : "32-bit");
          return false;
      }
  
      /* Check target elf file type */
      if (target_info.e_type != E_TYPE_REL) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid object file type, "
                        "expected relocatable file type but got others.");
          return false;
      }
  
      /* Check machine info */
      if (!check_machine_info(&target_info, error_buf, error_buf_size)) {
          return false;
      }
  
      if (target_info.e_version != E_VERSION_CURRENT) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid elf file version.");
          return false;
      }
  
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_mem_init_data_list(AOTMemInitData **data_list, uint32 count,
                             bool is_jit_mode)
  {
      if (!is_jit_mode) {
          uint32 i;
          for (i = 0; i < count; i++)
              if (data_list[i])
                  wasm_free(data_list[i]);
          wasm_free(data_list);
      }
  }
  
  static bool
  load_mem_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
                          AOTModule *module,
                          char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTMemInitData **data_list;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTMemInitData *) * (uint64)module->mem_init_data_count;
      if (size >= UINT32_MAX
          || !(module->mem_init_data_list =
               data_list = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(data_list, 0, size);
  
      /* Create each memory data segment */
      for (i = 0; i < module->mem_init_data_count; i++) {
          uint32 init_expr_type, byte_count;
          uint64 init_expr_value;
          read_uint32(buf, buf_end, init_expr_type);
          read_uint64(buf, buf_end, init_expr_value);
          read_uint32(buf, buf_end, byte_count);
          size = offsetof(AOTMemInitData, bytes) + (uint64)byte_count;
          if (size >= UINT32_MAX
              || !(data_list[i] = wasm_malloc((uint32)size))) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "allocate memory failed.");
              return false;
          }
  
          data_list[i]->offset.init_expr_type = (uint8)init_expr_type;
          data_list[i]->offset.u.i64 = (int64)init_expr_value;
          data_list[i]->byte_count = byte_count;
          read_byte_array(buf, buf_end,
                          data_list[i]->bytes, data_list[i]->byte_count);
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_memory_info(const uint8 **p_buf, const uint8 *buf_end,
                   AOTModule *module,
                   char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->mem_init_page_count);
      read_uint32(buf, buf_end, module->mem_max_page_count);
      read_uint32(buf, buf_end, module->mem_init_data_count);
  
      /* load memory init data list */
      if (module->mem_init_data_count > 0
          && !load_mem_init_data_list(&buf, buf_end, module,
                                      error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_table_init_data_list(AOTTableInitData **data_list, uint32 count,
                               bool is_jit_mode)
  {
      if (!is_jit_mode) {
          uint32 i;
          for (i = 0; i < count; i++)
              if (data_list[i])
                  wasm_free(data_list[i]);
          wasm_free(data_list);
      }
  }
  
  static bool
  load_table_init_data_list(const uint8 **p_buf, const uint8 *buf_end,
                            AOTModule *module,
                            char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTTableInitData **data_list;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTTableInitData *) * (uint64)module->table_init_data_count;
      if (size >= UINT32_MAX
          || !(module->table_init_data_list =
               data_list = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(data_list, 0, size);
  
      /* Create each table data segment */
      for (i = 0; i < module->table_init_data_count; i++) {
          uint32 init_expr_type, func_index_count;
          uint64 init_expr_value, size1;
  
          read_uint32(buf, buf_end, init_expr_type);
          read_uint64(buf, buf_end, init_expr_value);
          read_uint32(buf, buf_end, func_index_count);
  
          size1 = sizeof(uint32) * (uint64)func_index_count;
          size = offsetof(AOTTableInitData, func_indexes) + size1;
          if (size >= UINT32_MAX
              || !(data_list[i] = wasm_malloc((uint32)size))) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "allocate memory failed.");
              return false;
          }
  
          data_list[i]->offset.init_expr_type = (uint8)init_expr_type;
          data_list[i]->offset.u.i64 = (int64)init_expr_value;
          data_list[i]->func_index_count = func_index_count;
          read_byte_array(buf, buf_end, data_list[i]->func_indexes, size1);
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_table_info(const uint8 **p_buf, const uint8 *buf_end,
                  AOTModule *module,
                  char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->table_size);
      read_uint32(buf, buf_end, module->table_init_data_count);
  
      /* load table init data list */
      if (module->table_init_data_count > 0
          && !load_table_init_data_list(&buf, buf_end, module,
                                        error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_func_types(AOTFuncType **func_types, uint32 count, bool is_jit_mode)
  {
      if (!is_jit_mode) {
          uint32 i;
          for (i = 0; i < count; i++)
              if (func_types[i])
                  wasm_free(func_types[i]);
          wasm_free(func_types);
      }
  }
  
  static bool
  load_func_types(const uint8 **p_buf, const uint8 *buf_end,
                  AOTModule *module,
                  char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTFuncType **func_types;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTFuncType *) * (uint64)module->func_type_count;
      if (size >= UINT32_MAX
          || !(module->func_types = func_types = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(func_types, 0, size);
  
      /* Create each function type */
      for (i = 0; i < module->func_type_count; i++) {
          uint32 param_count, result_count;
          uint64 size1;
  
          read_uint32(buf, buf_end, param_count);
          read_uint32(buf, buf_end, result_count);
  
          size1 = (uint64)param_count + (uint64)result_count;
          size = offsetof(AOTFuncType, types) + size1;
          if (size >= UINT32_MAX
              || !(func_types[i] = wasm_malloc((uint32)size))) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "allocate memory failed.");
              return false;
          }
  
          func_types[i]->param_count = param_count;
          func_types[i]->result_count = result_count;
          read_byte_array(buf, buf_end, func_types[i]->types, (uint32)size1);
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_func_type_info(const uint8 **p_buf, const uint8 *buf_end,
                      AOTModule *module,
                      char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->func_type_count);
  
      /* load function type */
      if (module->func_type_count > 0
          && !load_func_types(&buf, buf_end, module, error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_import_globals(AOTImportGlobal *import_globals, bool is_jit_mode)
  {
      if (!is_jit_mode)
          wasm_free(import_globals);
  }
  
  static bool
  load_import_globals(const uint8 **p_buf, const uint8 *buf_end,
                      AOTModule *module,
                      char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTImportGlobal *import_globals;
      uint64 size;
      uint32 i, data_offset = 0;
  
      /* Allocate memory */
      size = sizeof(AOTImportGlobal) * (uint64)module->import_global_count;
      if (size >= UINT32_MAX
          || !(module->import_globals =
               import_globals = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(import_globals, 0, size);
  
      /* Create each import global */
      for (i = 0; i < module->import_global_count; i++) {
          read_uint8(buf, buf_end, import_globals[i].type);
          read_uint8(buf, buf_end, import_globals[i].is_mutable);
          read_string(buf, buf_end, import_globals[i].module_name);
          read_string(buf, buf_end, import_globals[i].global_name);
  
          import_globals[i].size = wasm_value_type_size(import_globals[i].type);
          import_globals[i].data_offset = data_offset;
          data_offset += import_globals[i].size;
          module->global_data_size += import_globals[i].size;
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_import_global_info(const uint8 **p_buf, const uint8 *buf_end,
                          AOTModule *module,
                          char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->import_global_count);
  
      /* load import globals */
      if (module->import_global_count > 0
          && !load_import_globals(&buf, buf_end, module,
                                  error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_globals(AOTGlobal *globals, bool is_jit_mode)
  {
      if (!is_jit_mode)
          wasm_free(globals);
  }
  
  static bool
  load_globals(const uint8 **p_buf, const uint8 *buf_end,
               AOTModule *module,
               char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTGlobal *globals;
      uint64 size;
      uint32 i, data_offset = 0;
      AOTImportGlobal *last_import_global;
  
      /* Allocate memory */
      size = sizeof(AOTGlobal) * (uint64)module->global_count;
      if (size >= UINT32_MAX
          || !(module->globals = globals = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(globals, 0, size);
  
      if (module->import_global_count > 0) {
          last_import_global =
              &module->import_globals[module->import_global_count - 1];
          data_offset = last_import_global->data_offset
                        + last_import_global->size;
      }
  
      /* Create each global */
      for (i = 0; i < module->global_count; i++) {
          uint16 init_expr_type;
          uint64 init_expr_value;
  
          read_uint8(buf, buf_end, globals[i].type);
          read_uint8(buf, buf_end, globals[i].is_mutable);
          read_uint16(buf, buf_end, init_expr_type);
          read_uint64(buf, buf_end, init_expr_value);
          globals[i].init_expr.init_expr_type = (uint8)init_expr_type;
          globals[i].init_expr.u.i64 = (int64)init_expr_value;
  
          globals[i].size = wasm_value_type_size(globals[i].type);
          globals[i].data_offset = data_offset;
          data_offset += globals[i].size;
          module->global_data_size += globals[i].size;
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_global_info(const uint8 **p_buf, const uint8 *buf_end,
                   AOTModule *module,
                   char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->global_count);
  
      /* load globals */
      if (module->global_count > 0
          && !load_globals(&buf, buf_end, module, error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_import_funcs(AOTImportFunc *import_funcs, bool is_jit_mode)
  {
      if (!is_jit_mode)
          wasm_free(import_funcs);
  }
  
  static void*
  resolve_sym(const char *module_name, const char *field_name)
  {
      void *sym;
  
  #if WASM_ENABLE_LIBC_BUILTIN != 0
      if ((sym = wasm_native_lookup_libc_builtin_func(module_name,
                                                      field_name)))
          return sym;
  #endif
  
  #if WASM_ENABLE_LIBC_WASI != 0
      if ((sym = wasm_native_lookup_libc_wasi_func(module_name,
                                                   field_name)))
          return sym;
  #endif
  
  #if WASM_ENABLE_BASE_LIB != 0
      if ((sym = wasm_native_lookup_base_lib_func(module_name,
                                                  field_name)))
          return sym;
  #endif
  
      if ((sym = wasm_native_lookup_extension_lib_func(module_name,
                                                       field_name)))
          return sym;
  
      return NULL;
  }
  
  static bool
  load_import_funcs(const uint8 **p_buf, const uint8 *buf_end,
                    AOTModule *module,
                    char *error_buf, uint32 error_buf_size)
  {
      const char *module_name, *field_name;
      const uint8 *buf = *p_buf;
      AOTImportFunc *import_funcs;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTImportFunc) * (uint64)module->import_func_count;
      if (size >= UINT32_MAX
          || !(module->import_funcs =
               import_funcs = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(import_funcs, 0, size);
  
      /* Create each import func */
      for (i = 0; i < module->import_func_count; i++) {
          read_uint16(buf, buf_end, import_funcs[i].func_type_index);
          if (import_funcs[i].func_type_index >= module->func_type_count) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "invalid function type index.");
              return false;
          }
          read_string(buf, buf_end, import_funcs[i].module_name);
          read_string(buf, buf_end, import_funcs[i].func_name);
  
          module_name = import_funcs[i].module_name;
          field_name = import_funcs[i].func_name;
          if (!(import_funcs[i].func_ptr_linked =
                      resolve_sym(module_name, field_name))) {
              LOG_WARNING("warning: fail to link import function (%s, %s)\n",
                          module_name, field_name);
          }
  
  #if WASM_ENABLE_LIBC_WASI != 0
          if (!strcmp(import_funcs[i].module_name, "wasi_unstable"))
              module->is_wasi_module = true;
  #endif
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_import_func_info(const uint8 **p_buf, const uint8 *buf_end,
                        AOTModule *module,
                        char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->import_func_count);
  
      /* load import funcs */
      if (module->import_func_count > 0
          && !load_import_funcs(&buf, buf_end, module,
                                  error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_object_data_sections(AOTObjectDataSection *data_sections,
                               uint32 data_section_count)
  {
      uint32 i;
      AOTObjectDataSection *data_section = data_sections;
      for (i = 0; i < data_section_count; i++, data_section++)
          if (data_section->data)
              bh_munmap(data_section->data, data_section->size);
      wasm_free(data_sections);
  }
  
  static bool
  load_object_data_sections(const uint8 **p_buf, const uint8 *buf_end,
                            AOTModule *module,
                            char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTObjectDataSection *data_sections;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTObjectDataSection) * (uint64)module->data_section_count;
      if (size >= UINT32_MAX
          || !(module->data_sections =
               data_sections = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(data_sections, 0, size);
  
      /* Create each data section */
      for (i = 0; i < module->data_section_count; i++) {
          int map_prot = MMAP_PROT_READ | MMAP_PROT_WRITE;
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
          /* aot code and data in x86_64 must be in range 0 to 2G due to
             relocation for R_X86_64_32/32S/PC32 */
          int map_flags = MMAP_MAP_32BIT;
  #else
          int map_flags = MMAP_MAP_NONE;
  #endif
  
          read_string(buf, buf_end, data_sections[i].name);
          read_uint32(buf, buf_end, data_sections[i].size);
  
          /* Allocate memory for data */
          if (!(data_sections[i].data =
                      bh_mmap(NULL, data_sections[i].size, map_prot, map_flags))) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "allocate memory failed.");
              return false;
          }
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
          /* address must be in the first 2 Gigabytes of
             the process address space */
          bh_assert((uintptr_t)data_sections[i].data < INT32_MAX);
  #endif
  
          read_byte_array(buf, buf_end,
                          data_sections[i].data, data_sections[i].size);
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_object_data_sections_info(const uint8 **p_buf, const uint8 *buf_end,
                                 AOTModule *module,
                                 char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
  
      read_uint32(buf, buf_end, module->data_section_count);
  
      /* load object data sections */
      if (module->data_section_count > 0
          && !load_object_data_sections(&buf, buf_end, module,
                                        error_buf, error_buf_size))
          return false;
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_init_data_section(const uint8 *buf, const uint8 *buf_end,
                         AOTModule *module,
                         char *error_buf, uint32 error_buf_size)
  {
      const uint8 *p = buf, *p_end = buf_end;
  
      if (!load_memory_info(&p, p_end, module, error_buf, error_buf_size)
          || !load_table_info(&p, p_end, module, error_buf, error_buf_size)
          || !load_func_type_info(&p, p_end, module, error_buf, error_buf_size)
          || !load_import_global_info(&p, p_end, module, error_buf, error_buf_size)
          || !load_global_info(&p, p_end, module, error_buf, error_buf_size)
          || !load_import_func_info(&p, p_end, module, error_buf, error_buf_size))
          return false;
  
      /* load function count and start function index */
      read_uint32(p, p_end, module->func_count);
      read_uint32(p, p_end, module->start_func_index);
  
      /* check start function index */
      if (module->start_func_index != (uint32)-1
          && (module->start_func_index < module->import_func_count
              || module->start_func_index >= module->import_func_count
                                             + module->func_count)) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "invalid start function index");
          return false;
      }
  
      if (!load_object_data_sections_info(&p, p_end, module,
                                          error_buf, error_buf_size))
          return false;
  
      if (p != p_end) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "invalid init data section size");
          return false;
      }
  
      return true;
  
  fail:
      return false;
  }
  
  static uint32
  get_plt_item_size();
  
  static uint32
  get_plt_table_size();
  
  static void
  init_plt_table(uint8 *plt);
  
  static bool
  load_text_section(const uint8 *buf, const uint8 *buf_end,
                    AOTModule *module,
                    char *error_buf, uint32 error_buf_size)
  {
      uint8 *plt_base;
  
      if (module->func_count > 0 && buf_end == buf) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid code size.");
          return false;
      }
  
      module->code = (void*)buf;
      module->code_size = (uint32)(buf_end - buf);
  
      if (module->code_size > 0) {
          plt_base = (uint8*)buf_end - get_plt_table_size();
          init_plt_table(plt_base);
      }
      return true;
  }
  
  static bool
  load_function_section(const uint8 *buf, const uint8 *buf_end,
                        AOTModule *module,
                        char *error_buf, uint32 error_buf_size)
  {
      const uint8 *p = buf, *p_end = buf_end;
      uint32 i;
      uint64 size, text_offset;
  
      size = sizeof(void*) * (uint64)module->func_count;
      if (size >= UINT32_MAX
          || !(module->func_ptrs = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: allocate memory failed.");
          return false;
      }
  
      for (i = 0; i < module->func_count; i++) {
          if (sizeof(void*) == 8) {
              read_uint64(p, p_end, text_offset);
          }
          else {
              uint32 text_offset32;
              read_uint32(p, p_end, text_offset32);
              text_offset = text_offset32;
          }
          if (text_offset >= module->code_size) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "invalid function code offset.");
              return false;
          }
          module->func_ptrs[i] = (uint8*)module->code + text_offset;
  #if defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_THUMB_VFP)
          /* bits[0] of thumb function address must be 1 */
          module->func_ptrs[i] = (void*)((uintptr_t)module->func_ptrs[i] | 1);
  #endif
      }
  
      /* Set start function when function pointers are resolved */
      if (module->start_func_index != (uint32)-1) {
          module->start_function =
              module->func_ptrs[module->start_func_index
                                - module->import_func_count];
      }
      else {
          module->start_function = NULL;
      }
  
      size = sizeof(uint32) * (uint64)module->func_count;
      if (size >= UINT32_MAX
          || !(module->func_type_indexes = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: allocate memory failed.");
          return false;
      }
  
      for (i = 0; i < module->func_count; i++) {
          read_uint32(p, p_end, module->func_type_indexes[i]);
          if (module->func_type_indexes[i] >= module->func_type_count) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "invalid function type index.");
              return false;
          }
      }
  
      if (p != buf_end) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "invalid function section size");
          return false;
      }
  
      return true;
  fail:
      return false;
  }
  
  static void
  destroy_export_funcs(AOTExportFunc *export_funcs, bool is_jit_mode)
  {
      if (!is_jit_mode)
          wasm_free(export_funcs);
  }
  
  static bool
  load_export_funcs(const uint8 **p_buf, const uint8 *buf_end,
                    AOTModule *module,
                    char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf = *p_buf;
      AOTExportFunc *export_funcs;
      uint64 size;
      uint32 i;
  
      /* Allocate memory */
      size = sizeof(AOTExportFunc) * (uint64)module->export_func_count;
      if (size >= UINT32_MAX
          || !(module->export_funcs =
               export_funcs = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return false;
      }
  
      memset(export_funcs, 0, size);
  
      /* Create each export func */
      for (i = 0; i < module->export_func_count; i++) {
          read_uint32(buf, buf_end, export_funcs[i].func_index);
          if (export_funcs[i].func_index >=
                module->func_count + module->import_func_count) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "function index is out of range.");
              return false;
          }
          read_string(buf, buf_end, export_funcs[i].func_name);
      }
  
      *p_buf = buf;
      return true;
  fail:
      return false;
  }
  
  static bool
  load_export_section(const uint8 *buf, const uint8 *buf_end,
                      AOTModule *module,
                      char *error_buf, uint32 error_buf_size)
  {
      const uint8 *p = buf, *p_end = buf_end;
  
      /* load export functions */
      read_uint32(p, p_end, module->export_func_count);
      if (module->export_func_count > 0
          && !load_export_funcs(&p, p_end, module, error_buf, error_buf_size))
          return false;
  
      if (p != p_end) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "invalid export section size");
          return false;
      }
  
      return true;
  
  fail:
      return false;
  }
  
  #define R_386_32        1   /* Direct 32 bit  */
  #define R_386_PC32      2   /* PC relative 32 bit */
  
  #define R_X86_64_64     1   /* Direct 64 bit  */
  #define R_X86_64_PC32   2   /* PC relative 32 bit signed */
  #define R_X86_64_PLT32  4   /* 32 bit PLT address */
  #define R_X86_64_32     10  /* Direct 32 bit zero extended */
  #define R_X86_64_32S    11  /* Direct 32 bit sign extended */
  
  #define R_ARM_CALL      28  /* PC relative 24 bit (BL, BLX).  */
  #define R_ARM_JMP24     29  /* PC relative 24 bit (B/BL<cond>).  */
  #define R_ARM_ABS32     2   /* Direct 32 bit */
  
  #define R_ARM_THM_CALL  10  /* PC relative (Thumb BL and ARMv5 Thumb BLX). */
  #define R_ARM_THM_JMP24 30  /* B.W */
  
  #define R_MIPS_32       2   /* Direct 32 bit */
  #define R_MIPS_26       4   /* Direct 26 bit shifted */
  
  #ifndef BH_MB
  #define BH_MB 1024 * 1024
  #endif
  
  static bool
  check_reloc_offset(uint32 target_section_size,
                     uint64 reloc_offset, uint32 reloc_data_size,
                     char *error_buf, uint32 error_buf_size)
  {
      if (!(reloc_offset < (uint64)target_section_size
            && reloc_offset + reloc_data_size <= (uint64)target_section_size)) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid relocation offset.");
          return false;
      }
      return true;
  }
  
  #define CHECK_RELOC_OFFSET(data_size) do {                                  \
      if (!check_reloc_offset(target_section_size, reloc_offset, data_size,   \
                              error_buf, error_buf_size))                     \
          return false;                                                       \
    } while (0)
  
  static bool
  apply_relocation(AOTModule *module,
                   uint8 *target_section_addr, uint32 target_section_size,
                   uint64 reloc_offset, uint64 reloc_addend,
                   uint32 reloc_type, void *symbol_addr, int32 symbol_index,
                   char *error_buf, uint32 error_buf_size)
  {
      switch (reloc_type) {
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
          case R_X86_64_64:
          {
              intptr_t value;
  
              CHECK_RELOC_OFFSET(sizeof(void*));
              value = *(intptr_t*)(target_section_addr + (uint32)reloc_offset);
              *(uint8**)(target_section_addr + reloc_offset)
                  = (uint8*)symbol_addr + reloc_addend + value;   /* S + A */
              break;
          }
          case R_X86_64_PC32:
          {
              intptr_t target_addr = (intptr_t)   /* S + A - P */
                                     ((uint8*)symbol_addr + reloc_addend
                                      - (target_section_addr + reloc_offset));
  
              CHECK_RELOC_OFFSET(sizeof(int32));
              if ((int32)target_addr != target_addr) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "relocation truncated to fit R_X86_64_PC32 failed");
                  return false;
              }
  
              *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr;
              break;
          }
          case R_X86_64_32:
          case R_X86_64_32S:
          {
              char buf[128];
              uintptr_t target_addr = (uintptr_t) /* S + A */
                                      ((uint8*)symbol_addr + reloc_addend);
  
              CHECK_RELOC_OFFSET(sizeof(int32));
  
              if ((reloc_type == R_X86_64_32
                   && (uint32)target_addr != (uint64)target_addr)
                  || (reloc_type == R_X86_64_32S
                      && (int32)target_addr != (int64)target_addr)) {
                  snprintf(buf, sizeof(buf),
                          "AOT module load failed: "
                          "relocation truncated to fit %s failed",
                          reloc_type == R_X86_64_32
                          ? "R_X86_64_32" : "R_X86_64_32S");
                  set_error_buf(error_buf, error_buf_size, buf);
                  return false;
              }
  
              *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr;
              break;
          }
          case R_X86_64_PLT32:
          {
              uint8 *plt = module->code + module->code_size - get_plt_table_size()
                           + get_plt_item_size() * symbol_index;
              intptr_t target_addr = (intptr_t)   /* L + A - P */
                                     (plt + reloc_addend
                                      - (target_section_addr + reloc_offset));
  
              CHECK_RELOC_OFFSET(sizeof(int32));
  
              if (symbol_index < 0) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "invalid symbol index for relocation");
                  return false;
              }
  
              if ((int32)target_addr != target_addr) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "relocation truncated to fit R_X86_64_PC32 failed");
                  return false;
              }
  
              *(int32*)(target_section_addr + reloc_offset) = (int32)target_addr;
              break;
          }
  #endif /* end of BUILD_TARGET_X86_64 || BUILD_TARGET_AMD_64 */
  
  #if defined(BUILD_TARGET_X86_32)
          case R_386_32:
          {
              intptr_t value;
  
              CHECK_RELOC_OFFSET(sizeof(void*));
              value = *(intptr_t*)(target_section_addr + (uint32)reloc_offset);
              *(uint8**)(target_section_addr + reloc_offset)
                  = (uint8*)symbol_addr + reloc_addend + value;   /* S + A */
              break;
          }
  
          case R_386_PC32:
          {
              int32 value;
  
              CHECK_RELOC_OFFSET(sizeof(void*));
              value = *(int32*)(target_section_addr + (uint32)reloc_offset);
              *(uint32*)(target_section_addr + (uint32)reloc_offset) = (uint32)
                  ((uint8*)symbol_addr + (uint32)reloc_addend
                   - (uint8*)(target_section_addr + (uint32)reloc_offset)
                   + value);  /* S + A - P */
              break;
          }
  #endif /* end of BUILD_TARGET_X86_32 */
  
  #if defined(BUILD_TARGET_ARM) || defined(BUILD_TARGET_ARM_VFP)
          /* TODO: implement ARM relocation */
          case R_ARM_CALL:
          case R_ARM_JMP24:
          case R_ARM_ABS32:
  #endif
  
  #if defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_THUMB_VFP)
          /* TODO: implement THUMB relocation */
          case R_ARM_THM_CALL:
          case R_ARM_THM_JMP24:
  #endif
  
  #if defined(BUILD_TARGET_MIPS_32)
          case R_MIPS_26:
          case R_MIPS_32:
              /* TODO: implement relocation for mips */
  #endif
  
          default:
              if (error_buf != NULL)
                  snprintf(error_buf, error_buf_size,
                           "Load import section failed: "
                           "invalid relocation type %d.",
                           reloc_type);
              return false;
      }
      return true;
  }
  
  static void *
  get_data_section_addr(AOTModule *module, const char *section_name,
                        uint32 *p_data_size)
  {
      uint32 i;
      AOTObjectDataSection *data_section = module->data_sections;
  
      for (i = 0; i < module->data_section_count; i++, data_section++)
          if (!strcmp(data_section->name, section_name)) {
              if (p_data_size)
                  *p_data_size = data_section->size;
              return data_section->data;
          }
  
      return NULL;
  }
  
  typedef struct {
      const char *symbol_name;
      void *symbol_addr;
  } SymbolMap;
  
  #define REG_SYM(symbol) { #symbol, (void*)symbol }
  
  #if defined(BUILD_TARGET_X86_32)
  void __divdi3();
  void __udivdi3();
  void __moddi3();
  void __umoddi3();
  #endif
  
  #if defined(BUILD_TARGET_ARM) \
      || defined(BUILD_TARGET_ARM_VFP) \
      || defined(BUILD_TARGET_THUMB) \
      || defined(BUILD_TARGET_THUMB_VFP)
  void __divdi3();
  void __udivdi3();
  void __moddi3();
  void __umoddi3();
  void __divsi3();
  void __udivsi3();
  void __modsi3();
  void __udivmoddi4();
  void __clzsi2();
  void __fixsfdi();
  void __fixunssfdi();
  void __fixdfdi();
  void __fixunsdfdi();
  void __floatdisf();
  void __floatundisf();
  void __floatdidf();
  void __floatundidf();
  void __aeabi_l2f();
  void __aeabi_f2lz();
  void __aeabi_ul2f();
  void __aeabi_d2lz();
  void __aeabi_l2d();
  void __aeabi_f2ulz();
  void __aeabi_ul2d();
  void __aeabi_d2ulz();
  void __aeabi_idiv();
  void __aeabi_uidiv();
  void __aeabi_idivmod();
  void __aeabi_uidivmod();
  void __aeabi_ldivmod();
  void __aeabi_uldivmod();
  #endif
  
  static SymbolMap target_sym_map[] = {
      REG_SYM(aot_set_exception_with_id),
      REG_SYM(aot_get_exception),
      REG_SYM(aot_is_wasm_type_equal),
      REG_SYM(wasm_runtime_enlarge_memory),
      REG_SYM(wasm_runtime_set_exception),
      REG_SYM(fmin),
      REG_SYM(fminf),
      REG_SYM(fmax),
      REG_SYM(fmaxf),
      REG_SYM(ceil),
      REG_SYM(ceilf),
      REG_SYM(floor),
      REG_SYM(floorf),
      REG_SYM(trunc),
      REG_SYM(truncf),
      REG_SYM(rint),
      REG_SYM(rintf),
      /* compiler-rt symbols that come from compiler(e.g. gcc) */
  #if defined(BUILD_TARGET_X86_32)
      REG_SYM(__divdi3),
      REG_SYM(__udivdi3),
      REG_SYM(__moddi3),
      REG_SYM(__umoddi3)
  #elif defined(BUILD_TARGET_ARM) \
        || defined(BUILD_TARGET_ARM_VFP) \
        || defined(BUILD_TARGET_THUMB) \
        || defined(BUILD_TARGET_THUMB_VFP)
      REG_SYM(__divdi3),
      REG_SYM(__udivdi3),
      REG_SYM(__umoddi3),
      REG_SYM(__divsi3),
      REG_SYM(__udivsi3),
      REG_SYM(__modsi3),
      REG_SYM(__udivmoddi4),
      REG_SYM(__clzsi2),
      REG_SYM(__fixsfdi),
      REG_SYM(__fixunssfdi),
      REG_SYM(__fixdfdi),
      REG_SYM(__fixunsdfdi),
      REG_SYM(__floatdisf),
      REG_SYM(__floatundisf),
      REG_SYM(__floatdidf),
      REG_SYM(__floatundidf),
      REG_SYM(__aeabi_l2f),
      REG_SYM(__aeabi_f2lz),
      REG_SYM(__aeabi_ul2f),
      REG_SYM(__aeabi_d2lz),
      REG_SYM(__aeabi_l2d),
      REG_SYM(__aeabi_f2ulz),
      REG_SYM(__aeabi_ul2d),
      REG_SYM(__aeabi_d2ulz),
      REG_SYM(__aeabi_idiv),
      REG_SYM(__aeabi_uidiv),
      REG_SYM(__aeabi_idivmod),
      REG_SYM(__aeabi_uidivmod),
      REG_SYM(__aeabi_ldivmod),
      REG_SYM(__aeabi_uldivmod),
  
  #endif /* end of BUILD_TARGET_X86_32 */
  };
  
  static void *
  resolve_target_sym(const char *symbol, int32 *p_index)
  {
      uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap);
      for (i = 0; i < num; i++)
          if (!strcmp(target_sym_map[i].symbol_name, symbol)) {
              *p_index = (int32)i;
              return target_sym_map[i].symbol_addr;
          }
      return NULL;
  }
  
  static inline uint32
  get_plt_item_size()
  {
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
      /* size of mov instruction and jmp instruction */
      return 12;
  #elif defined(BUILD_TARGET_ARM) || defined(BUILD_TARGET_ARM_VFP)
      /* 20 bytes instructions and 4 bytes symbol address */
      return 24;
  #elif defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_THUMB_VFP)
      /* 16 bytes instructions and 4 bytes symbol address */
      return 20;
  #endif
      return 0;
  }
  
  static uint32
  get_plt_table_size()
  {
      return get_plt_item_size() * (sizeof(target_sym_map) / sizeof(SymbolMap));
  }
  
  static void
  init_plt_table(uint8 *plt)
  {
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
      uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap);
      for (i = 0; i < num; i++) {
          uint8 *p = plt;
          /* mov symbol_addr, rax */
          *p++ = 0x48;
          *p++ = 0xB8;
          *(uint64*)p = (uint64)(uintptr_t)target_sym_map[i].symbol_addr;
          p += sizeof(uint64);
          /* jmp rax */
          *p++ = 0xFF;
          *p++ = 0xE0;
          plt += get_plt_item_size();
      }
  #endif
  
  #if defined(BUILD_TARGET_ARM) || defined(BUILD_TARGET_ARM_VFP)
      uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap);
      for (i = 0; i < num; i++) {
          uint32 *p = (uint32*)plt;
          /* push {lr} */
          *p++ = 0xe52de004;
          /* ldr lr, [pc, #8] */
          *p++ = 0xe59fe008;
          /* blx lr */
          *p++ = 0xe12fff3e;
          /* pop {lr} */
          *p++ = 0xe49de004;
          /* bx lr */
          *p++ = 0xe12fff1e;
          /* symbol addr */
          *p++ = (uint32)(uintptr_t)target_sym_map[i].symbol_addr;;
          plt += get_plt_item_size();
      }
  #endif
  
  #if defined(BUILD_TARGET_THUMB) || defined(BUILD_TARGET_THUMB_VFP)
      uint32 i, num = sizeof(target_sym_map) / sizeof(SymbolMap);
      for (i = 0; i < num; i++) {
          uint16 *p = (uint16*)plt;
          /* push {lr} */
          *p++ = 0xb500;
          /* push {r4, r5} */
          *p++ = 0xb430;
          /* add  r4, pc, #8 */
          *p++ = 0xa402;
          /* ldr  r5, [r4, #0] */
          *p++ = 0x6825;
          /* blx  r5 */
          *p++ = 0x47a8;
          /* pop  {r4, r5} */
          *p++ = 0xbc30;
          /* pop  {pc} */
          *p++ = 0xbd00;
          p++;
          /* symbol addr */
          *(uint32*)p = (uint32)(uintptr_t)target_sym_map[i].symbol_addr;;
          plt += get_plt_item_size();
      }
  
  #endif
  }
  
  static bool
  do_text_relocation(AOTModule *module,
                     AOTRelocationGroup *group,
                     char *error_buf, uint32 error_buf_size)
  {
      uint8 *aot_text = module->code;
      uint32 aot_text_size = module->code_size;
      uint32 i, func_index, symbol_len;
      char symbol_buf[128]  = { 0 }, *symbol, *p;
      void *symbol_addr;
      AOTRelocation *relocation = group->relocations;
  
      if (group->relocation_count > 0 && !aot_text) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid text relocation count.");
          return false;
      }
  
      for (i = 0; i < group->relocation_count; i++, relocation++) {
          int32 symbol_index = -1;
          symbol_len = (uint32)strlen(relocation->symbol_name);
          if (symbol_len + 1 <= sizeof(symbol_buf))
              symbol = symbol_buf;
          else {
              if (!(symbol = wasm_malloc(symbol_len + 1))) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "allocate memory failed.");
                  return false;
              }
          }
          memcpy(symbol, relocation->symbol_name, symbol_len);
          symbol[symbol_len] = '\0';
  
          if (!strncmp(symbol, AOT_FUNC_PREFIX, strlen(AOT_FUNC_PREFIX))) {
              p = symbol + strlen(AOT_FUNC_PREFIX);
              if (*p == '\0'
                  || (func_index = (uint32)atoi(p)) > module->func_count) {
                  if (error_buf != NULL)
                      snprintf(error_buf, error_buf_size,
                               "AOT module load failed: "
                               "invalid import symbol %s.",
                               symbol);
                  goto check_symbol_fail;
              }
              symbol_addr = module->func_ptrs[func_index];
          }
          else if (!strcmp(symbol, ".text")) {
              symbol_addr = module->code;
          }
          else if (!strcmp(symbol, ".data")
                   || !strcmp(symbol, ".rodata")
                   /* ".rodata.cst4/8/16/.." */
                   || !strncmp(symbol, ".rodata.cst", strlen(".rodata.cst"))) {
              symbol_addr = get_data_section_addr(module, symbol, NULL);
              if (!symbol_addr) {
                  if (error_buf != NULL)
                      snprintf(error_buf, error_buf_size,
                               "AOT module load failed: "
                               "invalid data section (%s).",
                               symbol);
                  goto check_symbol_fail;
              }
          }
          else if (!(symbol_addr = resolve_target_sym(symbol, &symbol_index))) {
              if (error_buf != NULL)
                  snprintf(error_buf, error_buf_size,
                           "AOT module load failed: "
                           "resolve symbol %s failed.",
                           symbol);
              goto check_symbol_fail;
          }
  
          if (symbol != symbol_buf)
              wasm_free(symbol);
  
          if (!apply_relocation(module,
                                aot_text, aot_text_size,
                                relocation->relocation_offset,
                                relocation->relocation_addend,
                                relocation->relocation_type,
                                symbol_addr, symbol_index,
                                error_buf, error_buf_size))
              return false;
      }
  
      return true;
  
  check_symbol_fail:
      if (symbol != symbol_buf)
          wasm_free(symbol);
      return false;
  }
  
  static bool
  do_data_relocation(AOTModule *module,
                     AOTRelocationGroup *group,
                     char *error_buf, uint32 error_buf_size)
  
  {
      uint8 *data_addr;
      uint32 data_size = 0, i;
      AOTRelocation *relocation = group->relocations;
      void *symbol_addr;
      char *symbol, *data_section_name;
  
      if (!strncmp(group->section_name, ".rela.", 6)) {
          data_section_name = group->section_name + strlen(".rela");
      }
      else if (!strncmp(group->section_name, ".rel.", 5)) {
          data_section_name = group->section_name + strlen(".rel");
      }
      else {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "invalid data relocation section name.");
          return false;
      }
  
      data_addr = get_data_section_addr(module, data_section_name,
                                        &data_size);
      if (group->relocation_count > 0 && !data_addr) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: invalid data relocation count.");
          return false;
      }
  
      for (i = 0; i < group->relocation_count; i++, relocation++) {
          symbol = relocation->symbol_name;
          if (!strcmp(symbol, ".text")) {
              symbol_addr = module->code;
          }
          else {
              if (error_buf != NULL)
                  snprintf(error_buf, error_buf_size,
                           "AOT module load failed: "
                           "invalid relocation symbol %s.",
                           symbol);
              return false;
          }
  
          if (!apply_relocation(module,
                                data_addr, data_size,
                                relocation->relocation_offset,
                                relocation->relocation_addend,
                                relocation->relocation_type,
                                symbol_addr, -1,
                                error_buf, error_buf_size))
              return false;
      }
  
      return true;
  }
  
  static bool
  validate_symbol_table(uint8 *buf, uint8 *buf_end,
                        uint32 *offsets, uint32 count,
                        char *error_buf, uint32 error_buf_size)
  {
      uint32 i, str_len_addr = 0;
      uint16 str_len;
  
      for (i = 0; i < count; i++) {
          if (offsets[i] != str_len_addr)
              return false;
  
          read_uint16(buf, buf_end, str_len);
          str_len_addr += (uint32)sizeof(uint16) + str_len;
          str_len_addr = align_uint(str_len_addr, 2);
          buf += str_len;
          buf = (uint8*)align_ptr(buf, 2);
      }
  
      if (buf == buf_end)
          return true;
  fail:
      return false;
  }
  
  static bool
  load_relocation_section(const uint8 *buf, const uint8 *buf_end,
                          AOTModule *module,
                          char *error_buf, uint32 error_buf_size)
  {
      AOTRelocationGroup *groups = NULL, *group;
      uint32 symbol_count = 0;
      uint32 group_count = 0, i, j, func_index, func_type_index;
      uint64 size;
      uint32 *symbol_offsets, total_string_len;
      uint8 *symbol_buf, *symbol_buf_end;
      bool ret = false;
      AOTExportFunc *export_func;
  
      read_uint32(buf, buf_end, symbol_count);
  
      symbol_offsets = (uint32 *)buf;
      for (i = 0; i < symbol_count; i++) {
          CHECK_BUF(buf, buf_end, sizeof(uint32));
          buf += sizeof(uint32);
      }
  
      read_uint32(buf, buf_end, total_string_len);
      symbol_buf = (uint8 *)buf;
      symbol_buf_end = symbol_buf + total_string_len;
  
      if (!validate_symbol_table(symbol_buf, symbol_buf_end,
                                 symbol_offsets, symbol_count,
                                 error_buf, error_buf_size)) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "validate symbol table failed.");
          goto fail;
      }
  
      buf = symbol_buf_end;
      read_uint32(buf, buf_end, group_count);
  
      /* Allocate memory for relocation groups */
      size = sizeof(AOTRelocationGroup) * (uint64)group_count;
      if (size >= UINT32_MAX || !(groups = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          goto fail;
      }
  
      memset(groups, 0, size);
  
      /* Load each relocation group */
      for (i = 0, group = groups; i < group_count; i++, group++) {
          AOTRelocation *relocation;
          uint32 name_index;
          uint16 str_len;
          uint8 *name_addr;
  
          /* section name address is 4 bytes aligned. */
          buf = (uint8*)align_ptr(buf, sizeof(uint32));
          read_uint32(buf, buf_end, name_index);
  
          if (name_index >= symbol_count) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "symbol index out of range.");
              goto fail;
          }
  
          name_addr = symbol_buf + symbol_offsets[name_index];
          str_len = *(uint16 *)name_addr;
  
          if (!(group->section_name =
                      const_str_set_insert(name_addr + sizeof(uint16),
                                           (int32)str_len, module,
                                           error_buf, error_buf_size))) {
              goto fail;
          }
  
          read_uint32(buf, buf_end, group->relocation_count);
  
          /* Allocate memory for relocations */
          size = sizeof(AOTRelocation) * (uint64)group->relocation_count;
          if (size >= UINT32_MAX
              || !(group->relocations = relocation =
                   wasm_malloc((uint32)size))) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "allocate memory failed.");
              ret = false;
              goto fail;
          }
  
          memset(group->relocations, 0, size);
  
          /* Load each relocation */
          for (j = 0; j < group->relocation_count; j++, relocation++) {
              uint32 symbol_index;
              uint16 str_len;
              uint8 *symbol_addr;
  
              if (sizeof(void *) == 8) {
                  read_uint64(buf, buf_end, relocation->relocation_offset);
                  read_uint64(buf, buf_end, relocation->relocation_addend);
              }
              else {
                  uint32 offset32, addend32;
                  read_uint32(buf, buf_end, offset32);
                  relocation->relocation_offset = (uint64)offset32;
                  read_uint32(buf, buf_end, addend32);
                  relocation->relocation_addend = (uint64)addend32;
              }
              read_uint32(buf, buf_end, relocation->relocation_type);
              read_uint32(buf, buf_end, symbol_index);
  
              if (symbol_index >= symbol_count) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "symbol index out of range.");
                  goto fail;
              }
  
              symbol_addr = symbol_buf + symbol_offsets[symbol_index];
              str_len = *(uint16 *)symbol_addr;
  
              if (!(relocation->symbol_name =
                      const_str_set_insert(symbol_addr + sizeof(uint16),
                                           (int32)str_len, module,
                                           error_buf, error_buf_size))) {
                  goto fail;
              }
          }
  
          if (!strcmp(group->section_name, ".rel.text")
              || !strcmp(group->section_name, ".rela.text")) {
              if (!do_text_relocation(module, group, error_buf, error_buf_size))
                  return false;
          }
          else {
              if (!do_data_relocation(module, group, error_buf, error_buf_size))
                  return false;
          }
      }
  
      export_func = module->export_funcs;
      for (i = 0; i < module->export_func_count; i++, export_func++) {
          func_index = export_func->func_index - module->import_func_count;
          if (func_index >= module->func_count) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: "
                            "invalid export function index.");
              ret = false;
              goto fail;
          }
          func_type_index = module->func_type_indexes[func_index];
          export_func->func_type = module->func_types[func_type_index];
          export_func->func_ptr = module->func_ptrs[func_index];
      }
  
      ret = true;
  
  fail:
      if (groups) {
          for (i = 0, group = groups; i < group_count; i++, group++)
              if (group->relocations)
                  wasm_free(group->relocations);
          wasm_free(groups);
      }
  
      return ret;
  }
  
  static bool
  load_from_sections(AOTModule *module, AOTSection *sections,
                     char *error_buf, uint32 error_buf_size)
  {
      AOTSection *section = sections;
      const uint8 *buf, *buf_end;
      uint32 last_section_type = (uint32)-1, section_type;
  
      while (section) {
          buf = section->section_body;
          buf_end = buf + section->section_body_size;
          /* Check sections */
          section_type = (uint32)section->section_type;
          if ((last_section_type == (uint32)-1
               && section_type != AOT_SECTION_TYPE_TARGET_INFO)
              || (last_section_type != (uint32)-1
                  && section_type != last_section_type + 1)) {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: invalid section order.");
              return false;
          }
          last_section_type = section_type;
          switch (section_type) {
              case AOT_SECTION_TYPE_TARGET_INFO:
                  if (!load_target_info_section(buf, buf_end, module,
                                                error_buf, error_buf_size))
                      return false;
                  break;
              case AOT_SECTION_TYPE_INIT_DATA:
                  if (!load_init_data_section(buf, buf_end, module,
                                              error_buf, error_buf_size))
                      return false;
                  break;
              case AOT_SECTION_TYPE_TEXT:
                  if (!load_text_section(buf, buf_end, module,
                                         error_buf, error_buf_size))
                      return false;
                  break;
              case AOT_SECTION_TYPE_FUNCTION:
                  if (!load_function_section(buf, buf_end, module,
                                             error_buf, error_buf_size))
                      return false;
                  break;
              case AOT_SECTION_TYPE_EXPORT:
                  if (!load_export_section(buf, buf_end, module,
                                           error_buf, error_buf_size))
                      return false;
                  break;
              case AOT_SECTION_TYPE_RELOCATION:
                  if (!load_relocation_section(buf, buf_end, module,
                                               error_buf, error_buf_size))
                      return false;
                  break;
          }
  
          section = section->next;
      }
  
      if (last_section_type != AOT_SECTION_TYPE_RELOCATION) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: section missing.");
          return false;
      }
  
      return true;
  }
  
  #if BEIHAI_ENABLE_MEMORY_PROFILING != 0
  static void aot_free(void *ptr)
  {
      wasm_free(ptr);
  }
  #else
  #define aot_free wasm_free
  #endif
  
  static AOTModule*
  create_module(char *error_buf, uint32 error_buf_size)
  {
      AOTModule *module = wasm_malloc(sizeof(AOTModule));
  
      if (!module) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "allocate memory failed.");
          return NULL;
      }
  
      memset(module, 0, sizeof(AOTModule));
  
      module->module_type = Wasm_Module_AoT;
  
      if (!(module->const_str_set =
                  bh_hash_map_create(32, false,
                                     (HashFunc)wasm_string_hash,
                                     (KeyEqualFunc)wasm_string_equal,
                                     NULL,
                                     aot_free))) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: "
                        "create const string set failed.");
          wasm_free(module);
          return NULL;
      }
  
      return module;
  }
  
  AOTModule*
  aot_load_from_sections(AOTSection *section_list,
                         char *error_buf, uint32 error_buf_size)
  {
      AOTModule *module = create_module(error_buf, error_buf_size);
  
      if (!module)
          return NULL;
  
      if (!load_from_sections(module, section_list,
                              error_buf, error_buf_size)) {
          aot_unload(module);
          return NULL;
      }
  
      LOG_VERBOSE("Load module from sections success.\n");
      return module;
  }
  
  static void
  destroy_sections(AOTSection *section_list, bool destroy_aot_text)
  {
      AOTSection *section = section_list, *next;
      while (section) {
          next = section->next;
          if (destroy_aot_text
              && section->section_type == AOT_SECTION_TYPE_TEXT
              && section->section_body)
              bh_munmap((uint8*)section->section_body, section->section_body_size);
          wasm_free(section);
          section = next;
      }
  }
  
  static bool
  create_sections(const uint8 *buf, uint32 size,
                  AOTSection **p_section_list,
                  char *error_buf, uint32 error_buf_size)
  {
      AOTSection *section_list = NULL, *section_list_end = NULL, *section;
      const uint8 *p = buf, *p_end = buf + size;
      uint32 section_type;
      uint32 section_size;
      uint64 total_size;
      uint8 *aot_text;
  
      p += 8;
      while (p < p_end) {
          read_uint32(p, p_end, section_type);
          if (section_type < AOT_SECTION_TYPE_SIGANATURE) {
              read_uint32(p, p_end, section_size);
              CHECK_BUF(p, p_end, section_size);
  
              if (!(section = wasm_malloc(sizeof(AOTSection)))) {
                  set_error_buf(error_buf, error_buf_size,
                                "AOT module load failed: "
                                "allocate memory failed.");
                  goto fail;
              }
  
              memset(section, 0, sizeof(AOTSection));
              section->section_type = (int32)section_type;
              section->section_body = p;
              section->section_body_size = section_size;
  
              if (section_type == AOT_SECTION_TYPE_TEXT) {
                  if (section_size > 0) {
                      int map_prot = MMAP_PROT_READ | MMAP_PROT_WRITE
                                     | MMAP_PROT_EXEC;
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
                      /* aot code and data in x86_64 must be in range 0 to 2G due to
                         relocation for R_X86_64_32/32S/PC32 */
                      int map_flags = MMAP_MAP_32BIT;
  #else
                      int map_flags = MMAP_MAP_NONE;
  #endif
                      total_size = (uint64)section_size + aot_get_plt_table_size();
                      total_size = (total_size + 3) & ~((uint64)3);
                      if (total_size >= UINT32_MAX
                          || !(aot_text = bh_mmap(NULL, (uint32)total_size,
                                                  map_prot, map_flags))) {
                          wasm_free(section);
                          set_error_buf(error_buf, error_buf_size,
                                        "AOT module load failed: "
                                        "mmap memory failed.");
                          goto fail;
                      }
  #if defined(BUILD_TARGET_X86_64) || defined(BUILD_TARGET_AMD_64)
                      /* address must be in the first 2 Gigabytes of
                         the process address space */
                      bh_assert((uintptr_t)aot_text < INT32_MAX);
  #endif
                      bh_memcpy_s(aot_text, (uint32)total_size,
                                  section->section_body, (uint32)section_size);
                      section->section_body = aot_text;
  
                      if ((uint32)total_size > section->section_body_size) {
                          memset(aot_text + (uint32)section_size,
                                 0, (uint32)total_size - section_size);
                          section->section_body_size = (uint32)total_size;
                      }
                  }
                  else
                      section->section_body = NULL;
              }
  
              if (!section_list)
                  section_list = section_list_end = section;
              else {
                  section_list_end->next = section;
                  section_list_end = section;
              }
  
              p += section_size;
          }
          else {
              set_error_buf(error_buf, error_buf_size,
                            "AOT module load failed: invalid section id.");
              goto fail;
          }
      }
  
      if (!section_list) {
          set_error_buf(error_buf, error_buf_size,
                        "AOT module load failed: create section list failed.");
          return false;
      }
  
      *p_section_list = section_list;
      return true;
  fail:
      if (section_list)
          destroy_sections(section_list, true);
      return false;
  }
  
  static bool
  load(const uint8 *buf, uint32 size, AOTModule *module,
       char *error_buf, uint32 error_buf_size)
  {
      const uint8 *buf_end = buf + size;
      const uint8 *p = buf, *p_end = buf_end;
      uint32 magic_number, version;
      AOTSection *section_list = NULL;
      bool ret;
  
      read_uint32(p, p_end, magic_number);
      if (magic_number != AOT_MAGIC_NUMBER) {
          set_error_buf(error_buf, error_buf_size, "magic header not detected");
          return false;
      }
  
      read_uint32(p, p_end, version);
      if (version != AOT_CURRENT_VERSION) {
          set_error_buf(error_buf, error_buf_size, "unknown binary version");
          return false;
      }
  
      if (!create_sections(buf, size, &section_list, error_buf, error_buf_size))
          return false;
  
      ret = load_from_sections(module, section_list, error_buf, error_buf_size);
      if (!ret) {
          /* If load_from_sections() fails, then aot text is destroyed
             in destroy_sections() */
          destroy_sections(section_list, true);
          /* aot_unload() won't destroy aot text again */
          module->code = NULL;
      }
      else {
          /* If load_from_sections() succeeds, then aot text is set to
             module->code and will be destroyed in aot_unload() */
          destroy_sections(section_list, false);
      }
      return ret;
  fail:
      return false;
  }
  
  AOTModule*
  aot_load_from_aot_file(const uint8 *buf, uint32 size,
                         char *error_buf, uint32 error_buf_size)
  {
      AOTModule *module = create_module(error_buf, error_buf_size);
  
      if (!module)
          return NULL;
  
      if (!load(buf, size, module, error_buf, error_buf_size)) {
          aot_unload(module);
          return NULL;
      }
  
      LOG_VERBOSE("Load module success.\n");
      return module;
  }
  
  #if WASM_ENABLE_JIT != 0
  static AOTModule*
  aot_load_from_comp_data(AOTCompData *comp_data, AOTCompContext *comp_ctx,
                          char *error_buf, uint32 error_buf_size)
  {
      uint32 i;
      uint64 size;
      char func_name[32];
      AOTModule *module;
  
      /* Allocate memory for module */
      if (!(module = wasm_malloc(sizeof(AOTModule)))) {
          set_error_buf(error_buf, error_buf_size,
                        "Allocate memory for AOT module failed.");
          return NULL;
      }
  
      memset(module, 0, sizeof(AOTModule));
  
      module->module_type = Wasm_Module_AoT;
      module->mem_init_page_count = comp_data->mem_init_page_count;
      module->mem_max_page_count = comp_data->mem_max_page_count;
  
      module->mem_init_data_list = comp_data->mem_init_data_list;
      module->mem_init_data_count = comp_data->mem_init_data_count;
  
      module->table_init_data_list = comp_data->table_init_data_list;
      module->table_init_data_count = comp_data->table_init_data_count;
      module->table_size = comp_data->table_size;
  
      module->func_type_count = comp_data->func_type_count;
      module->func_types = comp_data->func_types;
  
      module->import_global_count = comp_data->import_global_count;
      module->import_globals = comp_data->import_globals;
  
      module->global_count = comp_data->global_count;
      module->globals = comp_data->globals;
  
      module->global_count = comp_data->global_count;
      module->globals = comp_data->globals;
  
      module->global_data_size = comp_data->global_data_size;
  
      module->import_func_count = comp_data->import_func_count;
      module->import_funcs = comp_data->import_funcs;
  
      module->func_count = comp_data->func_count;
  
      /* Allocate memory for function pointers */
      size = (uint64)module->func_count * sizeof(void *);
      if (size >= UINT32_MAX
          || !(module->func_ptrs = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size, "Create func ptrs fail.");
          goto fail1;
      }
  
      /* Resolve function addresses */
      bh_assert(comp_ctx->exec_engine);
      memset(module->func_ptrs, 0, (uint32)size);
      for (i = 0; i < comp_data->func_count; i++) {
          snprintf(func_name, sizeof(func_name), "%s%d", AOT_FUNC_PREFIX, i);
          if (!(module->func_ptrs[i] =
                      (void *)LLVMGetFunctionAddress(comp_ctx->exec_engine,
                                                     func_name))) {
              set_error_buf(error_buf, error_buf_size,
                            "Get function address fail.");
              goto fail2;
          }
      }
  
      /* Allocation memory for function type indexes */
      size = (uint64)module->func_count * sizeof(uint32);
      if (size >= UINT32_MAX
          || !(module->func_type_indexes = wasm_malloc((uint32)size))) {
          set_error_buf(error_buf, error_buf_size, "Create func type indexes fail.");
          goto fail2;
      }
      memset(module->func_type_indexes, 0, (uint32)size);
      for (i = 0; i < comp_data->func_count; i++)
          module->func_type_indexes[i] = comp_data->funcs[i]->func_type_index;
  
      module->export_func_count = comp_data->export_func_count;
      module->export_funcs = comp_data->export_funcs;
  
      /* Set export function pointers */
      for (i = 0; i < module->export_func_count; i++) {
          module->export_funcs[i].func_ptr =
              module->func_ptrs[module->export_funcs[i].func_index
                                - module->import_func_count];
      }
  
      module->start_func_index = comp_data->start_func_index;
      if (comp_data->start_func_index != (uint32)-1) {
          bh_assert(comp_data->start_func_index >= module->import_func_count
                    && comp_data->start_func_index < module->import_func_count
                                                     + module->func_count);
          module->start_function =
              module->func_ptrs[comp_data->start_func_index
                                - module->import_func_count];
      }
      else {
          module->start_function = NULL;
      }
  
      module->code = NULL;
      module->code_size = 0;
  
      module->is_jit_mode = true;
  
      module->wasm_module = comp_data->wasm_module;
      module->comp_ctx = comp_ctx;
      module->comp_data = comp_data;
  
  #if WASM_ENABLE_LIBC_WASI != 0
      module->is_wasi_module = comp_data->wasm_module->is_wasi_module;
  #endif
  
      return module;
  
  fail2:
      wasm_free(module->func_ptrs);
  fail1:
      wasm_free(module);
      return NULL;
  }
  
  AOTModule*
  aot_convert_wasm_module(WASMModule *wasm_module,
                          char *error_buf, uint32 error_buf_size)
  {
      AOTCompData *comp_data;
      AOTCompContext *comp_ctx;
      AOTModule *aot_module;
      AOTCompOption option = { 0 };
      char *aot_last_error;
  
      comp_data = aot_create_comp_data(wasm_module);
      if (!comp_data) {
          aot_last_error = aot_get_last_error();
          bh_assert(aot_last_error != NULL);
          set_error_buf(error_buf, error_buf_size, aot_last_error);
          return NULL;
      }
  
      option.is_jit_mode = true;
      comp_ctx = aot_create_comp_context(comp_data, &option);
      if (!comp_ctx) {
          aot_last_error = aot_get_last_error();
          bh_assert(aot_last_error != NULL);
          set_error_buf(error_buf, error_buf_size, aot_last_error);
          goto fail1;
      }
  
      if (!aot_compile_wasm(comp_ctx)) {
          aot_last_error = aot_get_last_error();
          bh_assert(aot_last_error != NULL);
          set_error_buf(error_buf, error_buf_size, aot_last_error);
          goto fail2;
      }
  
      aot_module = aot_load_from_comp_data(comp_data, comp_ctx,
                                           error_buf, error_buf_size);
      if (!aot_module) {
          goto fail2;
      }
  
      return aot_module;
  
  fail2:
      aot_destroy_comp_context(comp_ctx);
  fail1:
      aot_destroy_comp_data(comp_data);
      return NULL;
  }
  #endif
  
  void
  aot_unload(AOTModule *module)
  {
  #if WASM_ENABLE_JIT != 0
      if (module->comp_data)
          aot_destroy_comp_data(module->comp_data);
      if (module->comp_ctx)
          aot_destroy_comp_context(module->comp_ctx);
      if (module->wasm_module)
          wasm_loader_unload(module->wasm_module);
  #endif
      if (module->mem_init_data_list)
          destroy_mem_init_data_list(module->mem_init_data_list,
                                     module->mem_init_data_count,
                                     module->is_jit_mode);
      if (module->table_init_data_list)
          destroy_table_init_data_list(module->table_init_data_list,
                                       module->table_init_data_count,
                                       module->is_jit_mode);
      if (module->func_types)
          destroy_func_types(module->func_types,
                             module->func_type_count,
                             module->is_jit_mode);
      if (module->import_globals)
          destroy_import_globals(module->import_globals,
                                 module->is_jit_mode);
      if (module->globals)
          destroy_globals(module->globals,
                          module->is_jit_mode);
      if (module->import_funcs)
          destroy_import_funcs(module->import_funcs,
                               module->is_jit_mode);
      if (module->export_funcs)
          destroy_export_funcs(module->export_funcs,
                               module->is_jit_mode);
      if (module->func_type_indexes)
          wasm_free(module->func_type_indexes);
      if (module->func_ptrs)
          wasm_free(module->func_ptrs);
      if (module->const_str_set)
          bh_hash_map_destroy(module->const_str_set);
      if (module->code)
          bh_munmap(module->code, module->code_size);
      if (module->data_sections)
          destroy_object_data_sections(module->data_sections,
                                       module->data_section_count);
      wasm_free(module);
  }
  
  uint32
  aot_get_plt_table_size()
  {
      return get_plt_table_size();
  }
  
  