From bd0fa1b5197255840969a693e6d5151f6cfa1e25 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Wed, 10 Jan 2024 18:00:24 +0900
Subject: [PATCH 01/10] Add option to compile only on WCC

---
 README.md           |  1 +
 src/wcc/emit_wasm.c | 47 +++++++++++++++++++++++++++++++++++++++++++++
 src/wcc/traverse.c  |  6 ++++--
 src/wcc/wasm_obj.h  |  8 ++++++++
 src/wcc/wcc.c       | 37 ++++++++++++++++++++++++-----------
 src/wcc/wcc.h       |  8 ++++++++
 src/wcc/wcc_util.c  |  1 +
 7 files changed, 95 insertions(+), 13 deletions(-)
 create mode 100644 src/wcc/wasm_obj.h

diff --git a/README.md b/README.md
index c40aea29d..5bcdcdcdd 100644
--- a/README.md
+++ b/README.md
@@ -95,6 +95,7 @@ Command line options:
   * `-o <filename>`: Set output filename (default: `a.wasm`)
   * `-I <path>`:     Add include path
   * `-D <label>(=value)`:  Define macro
+  * `-c`:            Output object file
   * `--entry-point=func_name`:  Specify entry point (default: `_start`)
   * `-e func_name,...`:  Export function names (comma separated)
   * `--stack-size=<size>`:  Set stack size (default: 8192)
diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 0bc7297e7..d0757f32e 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -12,6 +12,7 @@
 #include "util.h"
 #include "var.h"
 #include "wasm.h"
+#include "wasm_obj.h"
 
 static void emit_global_number(void *ud, const Type *type, Expr *var, Fixnum offset) {
   DataStorage *ds = ud;
@@ -190,11 +191,24 @@ static void emit_type_section(EmitWasm *ew) {
 }
 
 static void emit_import_section(EmitWasm *ew) {
+  static const char env_module_name[] = "env";
+
   DataStorage imports_section;
   data_init(&imports_section);
   data_open_chunk(&imports_section);
   data_open_chunk(&imports_section);
   uint32_t imports_count = 0;
+
+  if (out_type < OutExecutable) {
+    static const char kMemoryName[] = "__linear_memory";
+    data_string(&imports_section, env_module_name, sizeof(env_module_name) - 1);  // import module name
+    data_string(&imports_section, kMemoryName, sizeof(kMemoryName) - 1);  // import name
+    data_push(&imports_section, IMPORT_MEMORY);  // import kind
+    data_uleb128(&imports_section, -1, 0);  // index
+    data_uleb128(&imports_section, -1, 0);  // size
+    ++imports_count;
+  }
+
   {
     const char *module_name = ew->import_module_name;
     size_t module_name_len = strlen(module_name);
@@ -254,6 +268,9 @@ static void emit_function_section(EmitWasm *ew) {
 }
 
 static void emit_table_section(EmitWasm *ew) {
+  if (out_type < OutExecutable)
+    return;
+
   DataStorage table_section;
   data_init(&table_section);
   data_open_chunk(&table_section);
@@ -268,6 +285,9 @@ static void emit_table_section(EmitWasm *ew) {
 }
 
 static void emit_memory_section(EmitWasm *ew) {
+  if (out_type < OutExecutable)
+    return;
+
   DataStorage memory_section;
   data_init(&memory_section);
   data_open_chunk(&memory_section);
@@ -318,6 +338,9 @@ static void emit_global_section(EmitWasm *ew) {
 }
 
 static void emit_export_section(EmitWasm *ew, Vector *exports) {
+  if (out_type < OutExecutable)
+    return;
+
   DataStorage exports_section;
   data_init(&exports_section);
   data_open_chunk(&exports_section);
@@ -482,6 +505,26 @@ static void emit_data_section(EmitWasm *ew) {
   fwrite(datasec.buf, datasec.len, 1, ew->ofp);
 }
 
+static void emit_linking_section(EmitWasm *ew) {
+  DataStorage linking_section;
+  static const char kLinkingName[] = "linking";
+  const int LINK_VERSION = 2;
+  data_init(&linking_section);
+  data_open_chunk(&linking_section);
+  data_string(&linking_section, kLinkingName, sizeof(kLinkingName) - 1);
+  data_uleb128(&linking_section, -1, LINK_VERSION);
+  data_push(&linking_section, LT_WASM_SYMBOL_TABLE);  // subsec type
+  data_uleb128(&linking_section, -1, 0);  // count
+  // TODO:
+
+  if (linking_section.len > 0) {
+    data_close_chunk(&linking_section, -1);
+
+    fputc(SEC_CUSTOM, ew->ofp);
+    fwrite(linking_section.buf, linking_section.len, 1, ew->ofp);
+  }
+}
+
 void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
                uint32_t address_bottom) {
   write_wasm_header(ofp);
@@ -526,4 +569,8 @@ void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
 
   // Data.
   emit_data_section(ew);
+
+  if (out_type < OutExecutable) {
+    emit_linking_section(ew);
+  }
 }
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index bfa1d2f07..a66d14495 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -665,11 +665,13 @@ static void add_builtins(void) {
     init->single = new_expr_fixlit(varinfo->type, NULL, 0);  // Dummy
     varinfo->global.init = init;
 
-    register_gvar_info(varinfo->name, varinfo);
+    GVarInfo *info = register_gvar_info(varinfo->name, varinfo);
+    if (out_type < OutExecutable)
+      info->flag |= GVF_UNRESOLVED;
   }
 
   // Break address.
-  {
+  if (out_type >= OutExecutable) {
     const Name *name = alloc_name(BREAK_ADDRESS_NAME, NULL, false);
     VarInfo *varinfo = add_global_var(&tyVoidPtr, name);
     Initializer *init = new_initializer(IK_SINGLE, NULL);
diff --git a/src/wcc/wasm_obj.h b/src/wcc/wasm_obj.h
new file mode 100644
index 000000000..5f8d26074
--- /dev/null
+++ b/src/wcc/wasm_obj.h
@@ -0,0 +1,8 @@
+#pragma once
+
+enum LinkingType {
+  LT_WASM_SEGMENT_INFO        = 5,
+  LT_WASM_INIT_FUNCS          = 6,
+  LT_WASM_COMDAT_INFO         = 7,
+  LT_WASM_SYMBOL_TABLE        = 8,
+};
diff --git a/src/wcc/wcc.c b/src/wcc/wcc.c
index 3a892f8da..c0388b40c 100644
--- a/src/wcc/wcc.c
+++ b/src/wcc/wcc.c
@@ -119,15 +119,16 @@ int main(int argc, char *argv[]) {
     root = JOIN_PATHS(cwd, root);
   }
 
-  const char *ofn = "a.wasm";
+  const char *ofn = NULL;
   const char *import_module_name = DEFAULT_IMPORT_MODULE_NAME;
   Vector *exports = new_vector();
   uint32_t stack_size = DEFAULT_STACK_SIZE;
-  const char *entry_point = "_start";
+  const char *entry_point = NULL;
   bool nodefaultlibs = false, nostdlib = false, nostdinc = false;
   Vector *lib_paths = new_vector();
   bool export_all = false;
   bool export_stack_pointer = false;
+  out_type = OutExecutable;
 
   FILE *ppout = tmpfile();
   if (ppout == NULL)
@@ -180,6 +181,7 @@ int main(int argc, char *argv[]) {
     OPT_MMD,
   };
   static const struct option options[] = {
+    {"c", no_argument},  // Output .o
     {"I", required_argument},  // Add include path
     {"isystem", required_argument, OPT_ISYSTEM},  // Add system include path
     {"idirafter", required_argument, OPT_IDIRAFTER},  // Add include path (after)
@@ -217,6 +219,9 @@ int main(int argc, char *argv[]) {
     case 'o':
       ofn = optarg;
       break;
+    case 'c':
+      out_type = OutObject;
+      break;
     case 'e':
       if (*optarg != '\0') {
         const char *s = optarg;
@@ -337,9 +342,11 @@ int main(int argc, char *argv[]) {
 #endif
   }
 
+  if (out_type >= OutExecutable && entry_point == NULL)
+    entry_point = "_start";
   if (entry_point != NULL)
     vec_push(exports, alloc_name(entry_point, NULL, false));
-  if (exports->len == 0 && !export_all) {
+  if (exports->len == 0 && !(export_all || out_type < OutExecutable)) {
     error("no exports (require -e<xxx>)\n");
   }
 
@@ -350,9 +357,8 @@ int main(int argc, char *argv[]) {
   }
   VERBOSES("\n");
 
-  // if (out_type >= OutExecutable)
   Vector *libs = new_vector();
-  {
+  if (out_type >= OutExecutable) {
 #if defined(__WASM)
     vec_push(lib_paths, "/usr/lib");
 #else
@@ -367,7 +373,7 @@ int main(int argc, char *argv[]) {
   Vector *toplevel = new_vector();
 
   preprocess_and_compile(ppout, sources, toplevel);
-  if (export_all)
+  if (export_all || out_type < OutExecutable)
     export_non_static_functions(exports);
   preprocess_and_compile(ppout, libs, toplevel);
 
@@ -383,7 +389,7 @@ int main(int argc, char *argv[]) {
   }
 
   gen(toplevel);
-  if (unresolved_gvar_table.count > 0) {
+  if (out_type >= OutExecutable && unresolved_gvar_table.count > 0) {
     const Name *name;
     VarInfo *varinfo;
     for (int it = 0;
@@ -398,13 +404,22 @@ int main(int argc, char *argv[]) {
   if (error_warning && compile_warning_count != 0)
     return 2;
 
-  FILE *fp = fopen(ofn, "wb");
-  if (fp == NULL) {
+  const char *outfn = ofn;
+  if (outfn == NULL) {
+    if (out_type == OutObject) {
+      char *src = sources->data[0];  // TODO:
+      outfn = change_ext(basename(src), "o");
+    } else {
+      outfn = "a.wasm";
+    }
+  }
+  FILE *ofp = fopen(outfn, "wb");
+  if (ofp == NULL) {
     error("Cannot open output file");
   } else {
-    emit_wasm(fp, exports, import_module_name, address_bottom);
+    emit_wasm(ofp, exports, import_module_name, address_bottom);
     assert(compile_error_count == 0);
-    fclose(fp);
+    fclose(ofp);
   }
 
   return 0;
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index 17aa1b592..566d12d1c 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -89,9 +89,17 @@ void install_builtins(void);
 void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name, uint32_t address_bottom);
 
 // wcc_util
+enum OutType {
+  // OutPreprocess,
+  // OutAssembly,
+  OutObject,
+  OutExecutable,
+};
+
 extern const char SP_NAME[];
 
 extern bool verbose;
+enum OutType out_type;
 extern Table func_info_table;
 extern Table gvar_info_table;
 extern Table indirect_function_table;
diff --git a/src/wcc/wcc_util.c b/src/wcc/wcc_util.c
index 90cfe0a0e..11b9278fe 100644
--- a/src/wcc/wcc_util.c
+++ b/src/wcc/wcc_util.c
@@ -14,6 +14,7 @@
 const char SP_NAME[] = "__stack_pointer";  // Variable name for stack pointer (global).
 
 bool verbose;
+enum OutType out_type;
 Table func_info_table;
 Table gvar_info_table;
 Vector *functypes;  // <DataStorage*>

From d4b2fbaba98d13bcd71e9ca1cf17d1791426dfc0 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Fri, 12 Jan 2024 13:36:42 +0900
Subject: [PATCH 02/10] Generate relocation info for function call

`R_WASM_FUNCTION_INDEX_LEB`

  * Detect code and data section index
  * Output relocation information into custom section
  * Calculate relocation offset in each function code
---
 src/wcc/emit_wasm.c | 112 ++++++++++++++++++++++++++++++++++++++++++--
 src/wcc/gen_wasm.c  |  19 +++++++-
 src/wcc/traverse.c  |   6 ++-
 src/wcc/wasm_obj.h  |  48 +++++++++++++++++++
 src/wcc/wcc.h       |   3 ++
 src/wcc/wcc_util.c  |  10 ++++
 6 files changed, 192 insertions(+), 6 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index d0757f32e..7b5ed7355 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -170,8 +170,10 @@ typedef struct {
   FILE *ofp;
   const char *import_module_name;
   uint32_t address_bottom;
+  uint32_t section_index;
   uint32_t function_count;
   int32_t table_start_index;
+  uint32_t code_section_index;
 } EmitWasm;
 
 static void emit_type_section(EmitWasm *ew) {
@@ -188,6 +190,7 @@ static void emit_type_section(EmitWasm *ew) {
 
   fputc(SEC_TYPE, ew->ofp);
   fwrite(types_section.buf, types_section.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_import_section(EmitWasm *ew) {
@@ -236,6 +239,7 @@ static void emit_import_section(EmitWasm *ew) {
 
     fputc(SEC_IMPORT, ew->ofp);
     fwrite(imports_section.buf, imports_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -264,6 +268,7 @@ static void emit_function_section(EmitWasm *ew) {
 
     fputc(SEC_FUNC, ew->ofp);
     fwrite(functions_section.buf, functions_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -282,6 +287,7 @@ static void emit_table_section(EmitWasm *ew) {
 
   fputc(SEC_TABLE, ew->ofp);
   fwrite(table_section.buf, table_section.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_memory_section(EmitWasm *ew) {
@@ -304,6 +310,7 @@ static void emit_memory_section(EmitWasm *ew) {
 
   fputc(SEC_MEMORY, ew->ofp);
   fwrite(memory_section.buf, memory_section.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_global_section(EmitWasm *ew) {
@@ -334,6 +341,7 @@ static void emit_global_section(EmitWasm *ew) {
 
     fputc(SEC_GLOBAL, ew->ofp);
     fwrite(globals_section.buf, globals_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -389,6 +397,7 @@ static void emit_export_section(EmitWasm *ew, Vector *exports) {
 
   fputc(SEC_EXPORT, ew->ofp);
   fwrite(exports_section.buf, exports_section.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_elems_section(EmitWasm *ew) {
@@ -427,6 +436,7 @@ static void emit_elems_section(EmitWasm *ew) {
 
     fputc(SEC_ELEM, ew->ofp);
     fwrite(elems_section.buf, elems_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -446,6 +456,7 @@ static void emit_tag_section(EmitWasm *ew) {
 
     fputc(SEC_TAG, ew->ofp);
     fwrite(tag_section.buf, tag_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -460,18 +471,24 @@ static void emit_code_section(EmitWasm *ew) {
   {
     const Name *name;
     FuncInfo *info;
+    size_t offset = codesec.len;
     for (int it = 0; (it = table_iterate(&func_info_table, it, &name, (void**)&info)) != -1; ) {
       Function *func = info->func;
       if (func == NULL || info->flag == 0)
         continue;
-      DataStorage *code = ((FuncExtra*)func->extra)->code;
+      FuncExtra* extra = func->extra;
+      DataStorage *code = extra->code;
       data_concat(&codesec, code);
+
+      extra->offset += offset;
+      offset += code->len;
     }
   }
   data_close_chunk(&codesec, -1);
 
   fputc(SEC_CODE, ew->ofp);
   fwrite(codesec.buf, codesec.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_data_section(EmitWasm *ew) {
@@ -503,6 +520,7 @@ static void emit_data_section(EmitWasm *ew) {
 
   fputc(SEC_DATA, ew->ofp);
   fwrite(datasec.buf, datasec.len, 1, ew->ofp);
+  ++ew->section_index;
 }
 
 static void emit_linking_section(EmitWasm *ew) {
@@ -514,14 +532,100 @@ static void emit_linking_section(EmitWasm *ew) {
   data_string(&linking_section, kLinkingName, sizeof(kLinkingName) - 1);
   data_uleb128(&linking_section, -1, LINK_VERSION);
   data_push(&linking_section, LT_WASM_SYMBOL_TABLE);  // subsec type
-  data_uleb128(&linking_section, -1, 0);  // count
-  // TODO:
+
+  data_open_chunk(&linking_section);  // Payload start.
+  data_open_chunk(&linking_section);
+  uint32_t count = 0;
+  // Functions
+  for (int k = 0; k < 2; ++k) {  // To match function index and linking order, do twice.
+    const Name *name;
+    FuncInfo *info;
+    for (int it = 0; (it = table_iterate(&func_info_table, it, &name, (void**)&info)) != -1; ) {
+      if (info->flag == 0 ||
+          (k == 0 && info->func != NULL) ||  // Put external function first.
+          (k == 1 && info->func == NULL))    // Defined function later.
+        continue;
+
+      int flags = 0;
+      if (info->func == NULL)
+        flags |= WASM_SYM_UNDEFINED;
+      if (info->varinfo->storage & VS_STATIC)
+        flags |= WASM_SYM_VISIBILITY_HIDDEN;
+
+      data_push(&linking_section, SIK_SYMTAB_FUNCTION);  // kind
+      data_uleb128(&linking_section, -1, flags);
+      data_uleb128(&linking_section, -1, info->index);
+
+      if (info->func != NULL) {  // Defined function: put name. otherwise not required.
+        data_string(&linking_section, name->chars, name->bytes);
+      }
+      ++count;
+    }
+  }
+  data_close_chunk(&linking_section, count);
+  data_close_chunk(&linking_section, -1);  // Put payload size.
 
   if (linking_section.len > 0) {
     data_close_chunk(&linking_section, -1);
 
     fputc(SEC_CUSTOM, ew->ofp);
     fwrite(linking_section.buf, linking_section.len, 1, ew->ofp);
+    ++ew->section_index;
+  }
+}
+
+static void emit_reloc_section(EmitWasm *ew) {
+  static const char kRelocCode[] = "reloc.CODE";
+
+  typedef struct {
+    Function *func;
+    RelocInfo *reloc;
+  } CodeReloc;
+
+  Vector *code_reloc_all = new_vector();
+
+  const Name *name;
+  FuncInfo *info;
+  for (int it = 0; (it = table_iterate(&func_info_table, it, &name, (void**)&info)) != -1; ) {
+    Function *func = info->func;
+    if (func == NULL || info->flag == 0)
+      continue;
+
+    FuncExtra *extra = func->extra;
+    Vector *reloc_code = extra->reloc_code;
+    for (int i = 0; i < reloc_code->len; ++i) {
+      CodeReloc *cr = calloc_or_die(sizeof(*cr));
+      cr->func = func;
+      cr->reloc = reloc_code->data[i];
+      vec_push(code_reloc_all, cr);
+    }
+  }
+
+  if (code_reloc_all->len > 0) {
+    DataStorage reloc_code_section;
+    data_init(&reloc_code_section);
+    data_open_chunk(&reloc_code_section);
+    data_string(&reloc_code_section, kRelocCode, sizeof(kRelocCode) - 1);
+    data_uleb128(&reloc_code_section, -1, ew->code_section_index);
+
+    int count = code_reloc_all->len;
+    data_uleb128(&reloc_code_section, -1, count);
+    for (int i = 0; i < count; ++i) {
+      CodeReloc *cr = code_reloc_all->data[i];
+      Function *func = cr->func;
+      RelocInfo *reloc = cr->reloc;
+      FuncExtra *extra = func->extra;
+
+      data_push(&reloc_code_section, reloc->type);
+      data_uleb128(&reloc_code_section, -1, reloc->offset + extra->offset);
+      data_uleb128(&reloc_code_section, -1, reloc->index);
+      // TODO: addend?
+    }
+    data_close_chunk(&reloc_code_section, -1);
+
+    fputc(SEC_CUSTOM, ew->ofp);
+    fwrite(reloc_code_section.buf, reloc_code_section.len, 1, ew->ofp);
+    ++ew->section_index;
   }
 }
 
@@ -565,6 +669,7 @@ void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
   emit_elems_section(ew);
 
   // Code.
+  ew->code_section_index = ew->section_index;
   emit_code_section(ew);
 
   // Data.
@@ -572,5 +677,6 @@ void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
 
   if (out_type < OutExecutable) {
     emit_linking_section(ew);
+    emit_reloc_section(ew);
   }
 }
diff --git a/src/wcc/gen_wasm.c b/src/wcc/gen_wasm.c
index c334aec4b..6e3185cb3 100644
--- a/src/wcc/gen_wasm.c
+++ b/src/wcc/gen_wasm.c
@@ -16,11 +16,13 @@
 #include "util.h"
 #include "var.h"
 #include "wasm.h"
+#include "wasm_obj.h"
 
 #define CODE  (((FuncExtra*)curfunc->extra)->code)
 
 #define ADD_LEB128(x)  data_leb128(CODE, -1, x)
 #define ADD_ULEB128(x) data_uleb128(CODE, -1, x)
+#define ADD_VARUINT32(x)  data_varuint32(CODE, -1, x)
 
 // TODO: Endian.
 #define ADD_F32(x)     do { float f = (x); add_code((unsigned char*)&f, sizeof(f)); } while (0)
@@ -263,7 +265,20 @@ static void gen_funcall_by_name(const Name *funcname) {
   FuncInfo *info = table_get(&func_info_table, funcname);
   assert(info != NULL);
   ADD_CODE(OP_CALL);
-  ADD_ULEB128(info->index);
+  if (out_type >= OutExecutable) {
+    ADD_ULEB128(info->index);
+  } else {
+    FuncExtra *extra = curfunc->extra;
+    DataStorage *code = extra->code;
+    RelocInfo *ri = calloc_or_die(sizeof(*ri));
+    ri->type = R_WASM_FUNCTION_INDEX_LEB;
+    ri->offset = code->len;
+    ri->addend = 0;
+    ri->index = info->index;
+    vec_push(extra->reloc_code, ri);
+
+    ADD_VARUINT32(info->index);
+  }
 }
 
 static void gen_funcall(Expr *expr) {
@@ -1628,7 +1643,9 @@ static void gen_defun(Function *func) {
 
   ADD_CODE(OP_END);
 
+  size_t before = code->len;
   data_uleb128(code, 0, code->len);  // Insert code size at the top.
+  extra->offset = code->len - before;
 
   curfunc = NULL;
   assert(cur_depth == 0);
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index a66d14495..dd26c07c4 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -596,7 +596,9 @@ static void traverse_defun(Function *func) {
   if (func->scopes == NULL)  // Prototype definition
     return;
 
-  func->extra = calloc_or_die(sizeof(FuncExtra));
+  FuncExtra *extra = calloc_or_die(sizeof(FuncExtra));
+  extra->reloc_code = new_vector();
+  func->extra = extra;
 
   Type *functype = func->type;
   assert(func->params != NULL);
@@ -773,7 +775,7 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
       init->single->fixnum = sp_bottom;
       VERBOSE("SP bottom: 0x%x  (size=0x%x)\n", sp_bottom, stack_size);
     }
-    {  // Break address.
+    if (out_type >= OutExecutable) {  // Break address.
       VarInfo *varinfo = scope_find(global_scope, alloc_name(BREAK_ADDRESS_NAME, NULL, false), NULL);
       assert(varinfo != NULL);
       Initializer *init = varinfo->global.init;
diff --git a/src/wcc/wasm_obj.h b/src/wcc/wasm_obj.h
index 5f8d26074..2c62e0be9 100644
--- a/src/wcc/wasm_obj.h
+++ b/src/wcc/wasm_obj.h
@@ -6,3 +6,51 @@ enum LinkingType {
   LT_WASM_COMDAT_INFO         = 7,
   LT_WASM_SYMBOL_TABLE        = 8,
 };
+
+enum SymInfoKind {
+  SIK_SYMTAB_FUNCTION         = 0,
+  SIK_SYMTAB_DATA             = 1,
+  SIK_SYMTAB_GLOBAL           = 2,
+  SIK_SYMTAB_SECTION          = 3,
+  SIK_SYMTAB_EVENT            = 4,
+  SIK_SYMTAB_TABLE            = 5,
+};
+
+// enum SymFlags
+#define WASM_SYM_BINDING_WEAK       (1 << 0)
+#define WASM_SYM_BINDING_LOCAL      (1 << 1)
+#define WASM_SYM_VISIBILITY_HIDDEN  (1 << 2)
+#define WASM_SYM_UNDEFINED          (1 << 4)
+#define WASM_SYM_EXPORTED           (1 << 5)
+#define WASM_SYM_EXPLICIT_NAME      (1 << 6)
+#define WASM_SYM_NO_STRIP           (1 << 7)
+#define WASM_SYM_TLS                (1 << 8)
+#define WASM_SYM_ABSOLUTE           (1 << 9)
+
+enum RelocType {
+  R_WASM_FUNCTION_INDEX_LEB    = 0,
+  R_WASM_TABLE_INDEX_SLEB      = 1,
+  R_WASM_TABLE_INDEX_I32       = 2,
+  R_WASM_MEMORY_ADDR_LEB       = 3,
+  R_WASM_MEMORY_ADDR_SLEB      = 4,
+  R_WASM_MEMORY_ADDR_I32       = 5,
+  R_WASM_TYPE_INDEX_LEB        = 6,
+  R_WASM_GLOBAL_INDEX_LEB      = 7,
+  R_WASM_FUNCTION_OFFSET_I32   = 8,
+  R_WASM_SECTION_OFFSET_I32    = 9,
+  R_WASM_EVENT_INDEX_LEB       = 10,
+  R_WASM_GLOBAL_INDEX_I32      = 13,
+  R_WASM_MEMORY_ADDR_LEB64     = 14,
+  R_WASM_MEMORY_ADDR_SLEB64    = 15,
+  R_WASM_MEMORY_ADDR_I64       = 16,
+  R_WASM_TABLE_INDEX_SLEB64    = 18,
+  R_WASM_TABLE_INDEX_I64       = 19,
+  R_WASM_TABLE_NUMBER_LEB      = 20,
+};
+
+typedef struct {
+  uint32_t offset;  // from its function top (not section top).
+  uint32_t index;
+  uint32_t addend;
+  uint8_t type;     // enum RelocType
+} RelocInfo;
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index 566d12d1c..d30422570 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -135,11 +135,14 @@ void data_uleb128(DataStorage *data, ssize_t pos, uint64_t val);
 void data_string(DataStorage *data, const void *str, size_t len);
 void data_open_chunk(DataStorage *data);
 void data_close_chunk(DataStorage *data, ssize_t num);
+void data_varuint32(DataStorage *data, ssize_t pos, uint64_t val);
 
 typedef struct FuncExtra {
   Vector *funcall_results;  // [0]=Expr*, [1]=VarInfo*
   DataStorage *code;
+  Vector *reloc_code;  // <RelocInfo*>
   int setjmp_count;
+  size_t offset;  // from code section top (exclude section size).
 } FuncExtra;
 
 Expr *get_sp_var(void);
diff --git a/src/wcc/wcc_util.c b/src/wcc/wcc_util.c
index 11b9278fe..961c220df 100644
--- a/src/wcc/wcc_util.c
+++ b/src/wcc/wcc_util.c
@@ -168,6 +168,16 @@ void data_string(DataStorage *data, const void *str, size_t len) {
   data_append(data, (const unsigned char*)str, len);
 }
 
+void data_varuint32(DataStorage *data, ssize_t pos, uint64_t val) {
+  unsigned char buf[5], *p = buf;
+  for (int i = 0; i < 4; ++i) {
+    *p++ = (val & 0x7f) | 0x80;
+    val >>= 7;
+  }
+  *p++ = val & 0x7f;
+  data_insert(data, pos, buf, p - buf);
+}
+
 void data_open_chunk(DataStorage *data) {
   Vector *stack = data->chunk_stack;
   if (stack == NULL)

From c5d0e2b326efc6f0b500acefaea88e131036c1b5 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Tue, 16 Jan 2024 09:24:51 +0900
Subject: [PATCH 03/10] Generate data relocation information

For global variable.
---
 src/wcc/emit_wasm.c | 41 +++++++++++++++++++++++++++++
 src/wcc/gen_wasm.c  | 15 ++++++++++-
 src/wcc/traverse.c  | 64 ++++++++++++++++++++++++++++++++++-----------
 src/wcc/wcc.h       |  4 ++-
 4 files changed, 107 insertions(+), 17 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 7b5ed7355..1c644021a 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -562,6 +562,34 @@ static void emit_linking_section(EmitWasm *ew) {
       ++count;
     }
   }
+  {  // Globals
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+        continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL)
+        continue;
+
+      int flags = 0;
+      if (info->flag & GVF_UNRESOLVED)
+        flags |= WASM_SYM_UNDEFINED;
+      if (varinfo->storage & VS_STATIC)
+        flags |= WASM_SYM_VISIBILITY_HIDDEN;
+
+      data_push(&linking_section, SIK_SYMTAB_DATA);  // kind
+      data_uleb128(&linking_section, -1, flags);
+      const Name *name = varinfo->name;
+      data_string(&linking_section, name->chars, name->bytes);
+      if (!(info->flag & GVF_UNRESOLVED)) {  // Defined function: put name. otherwise not required.
+        data_uleb128(&linking_section, -1, info->non_prim.item_index);
+        data_uleb128(&linking_section, -1, 0);  // TODO: offset
+        data_uleb128(&linking_section, -1, type_size(varinfo->type));  // size
+      }
+
+      ++count;
+    }
+  }
   data_close_chunk(&linking_section, count);
   data_close_chunk(&linking_section, -1);  // Put payload size.
 
@@ -619,6 +647,19 @@ static void emit_reloc_section(EmitWasm *ew) {
       data_push(&reloc_code_section, reloc->type);
       data_uleb128(&reloc_code_section, -1, reloc->offset + extra->offset);
       data_uleb128(&reloc_code_section, -1, reloc->index);
+      switch (reloc->type) {
+      case R_WASM_MEMORY_ADDR_LEB:
+      case R_WASM_MEMORY_ADDR_SLEB:
+      case R_WASM_MEMORY_ADDR_I32:
+      case R_WASM_MEMORY_ADDR_LEB64:
+      case R_WASM_MEMORY_ADDR_SLEB64:
+      case R_WASM_MEMORY_ADDR_I64:
+      case R_WASM_FUNCTION_OFFSET_I32:
+      case R_WASM_SECTION_OFFSET_I32:
+        data_uleb128(&reloc_code_section, -1, reloc->addend);
+        break;
+      default: break;
+      }
       // TODO: addend?
     }
     data_close_chunk(&reloc_code_section, -1);
diff --git a/src/wcc/gen_wasm.c b/src/wcc/gen_wasm.c
index 6e3185cb3..cbd172639 100644
--- a/src/wcc/gen_wasm.c
+++ b/src/wcc/gen_wasm.c
@@ -464,7 +464,20 @@ static void gen_ref_sub(Expr *expr) {
         } else {
           GVarInfo *info = get_gvar_info(expr);
           ADD_CODE(OP_I32_CONST);
-          ADD_LEB128(info->non_prim.address);
+          if (out_type >= OutExecutable) {
+            ADD_LEB128(info->non_prim.address);
+          } else {
+            FuncExtra *extra = curfunc->extra;
+            DataStorage *code = extra->code;
+            RelocInfo *ri = calloc_or_die(sizeof(*ri));
+            ri->type = R_WASM_MEMORY_ADDR_LEB;
+            ri->offset = code->len;
+            ri->addend = 0;
+            ri->index = info->non_prim.symbol_index;
+            vec_push(extra->reloc_code, ri);
+
+            ADD_VARUINT32(info->non_prim.address);
+          }
         }
       } else {
         VReg *vreg = varinfo->local.vreg;
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index dd26c07c4..59df28b91 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -249,6 +249,11 @@ static void te_var(Expr **pexpr, bool needval) {
   if (expr->type->kind == TY_FUNC) {
     register_indirect_function(expr->var.name);
     traverse_func_expr(pexpr);
+  } else {
+    if (out_type < OutExecutable && is_global_scope(expr->var.scope)) {
+      // Register used global variable even if the entity is `extern`.
+      get_gvar_info(expr);
+    }
   }
 }
 
@@ -710,6 +715,33 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
     register_func_info(name, NULL, FF_REFERRED);
   }
 
+  // Linking information.
+  if (out_type < OutExecutable) {
+    uint32_t symbol_index = 0;
+    const Name *name;
+    FuncInfo *info;
+    for (int it = 0; (it = table_iterate(&func_info_table, it, &name, (void**)&info)) != -1; ) {
+      if (info->flag == 0)
+        continue;
+      ++symbol_index;
+    }
+
+    // Assign linking index to globals.
+    uint32_t global_index = 0;
+    uint32_t data_index = 0;
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+        continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL)
+        continue;
+      uint32_t index = !is_global_datsec_var(varinfo, global_scope) ? global_index++ : !(varinfo->storage & VS_EXTERN) ? data_index++ : (uint32_t)-1;
+      info->non_prim.item_index = index;
+      info->non_prim.symbol_index = symbol_index++;
+    }
+  }
+
   {
     // Enumerate functions.
     VERBOSES("### Functions\n");
@@ -767,21 +799,23 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
 
     // Set initial values.
     sp_bottom = ALIGN(address + stack_size, 16);
-    {  // Stack pointer.
-      VarInfo *varinfo = scope_find(global_scope, alloc_name(SP_NAME, NULL, false), NULL);
-      assert(varinfo != NULL);
-      Initializer *init = varinfo->global.init;
-      assert(init != NULL && init->kind == IK_SINGLE && init->single->kind == EX_FIXNUM);
-      init->single->fixnum = sp_bottom;
-      VERBOSE("SP bottom: 0x%x  (size=0x%x)\n", sp_bottom, stack_size);
-    }
-    if (out_type >= OutExecutable) {  // Break address.
-      VarInfo *varinfo = scope_find(global_scope, alloc_name(BREAK_ADDRESS_NAME, NULL, false), NULL);
-      assert(varinfo != NULL);
-      Initializer *init = varinfo->global.init;
-      assert(init != NULL && init->kind == IK_SINGLE && init->single->kind == EX_FIXNUM);
-      init->single->fixnum = sp_bottom;
-      VERBOSE("Break address: 0x%x\n", sp_bottom);
+    if (out_type >= OutExecutable) {
+      {  // Stack pointer.
+        VarInfo *varinfo = scope_find(global_scope, alloc_name(SP_NAME, NULL, false), NULL);
+        assert(varinfo != NULL);
+        Initializer *init = varinfo->global.init;
+        assert(init != NULL && init->kind == IK_SINGLE && init->single->kind == EX_FIXNUM);
+        init->single->fixnum = sp_bottom;
+        VERBOSE("SP bottom: 0x%x  (size=0x%x)\n", sp_bottom, stack_size);
+      }
+      {  // Break address.
+        VarInfo *varinfo = scope_find(global_scope, alloc_name(BREAK_ADDRESS_NAME, NULL, false), NULL);
+        assert(varinfo != NULL);
+        Initializer *init = varinfo->global.init;
+        assert(init != NULL && init->kind == IK_SINGLE && init->single->kind == EX_FIXNUM);
+        init->single->fixnum = sp_bottom;
+        VERBOSE("Break address: 0x%x\n", sp_bottom);
+      }
     }
   }
 
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index d30422570..6d3494fa5 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -34,7 +34,7 @@ typedef struct {
   Function *func;
   VarInfo *varinfo;
   const Name *bpname;
-  uint32_t index;
+  uint32_t index;  // also represents symbol_index (because functions are put first in symbol table.)
   int flag;
   uint32_t type_index;
   uint32_t indirect_index;
@@ -52,6 +52,8 @@ typedef struct {
     } prim;
     struct {
       uint32_t address;
+      uint32_t item_index;    // global, or data
+      uint32_t symbol_index;  // index in symbol table.
     } non_prim;
   };
 } GVarInfo;

From 1bb90d1987981134529c172a7bdc2233a2726256 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Wed, 17 Jan 2024 16:05:44 +0900
Subject: [PATCH 04/10] Output global variable

Unity global and data output order:

  * Imported (unresolved)
  * Defined in this compile unit
---
 src/cc/frontend/cc_misc.c |  2 +
 src/wcc/emit_wasm.c       | 84 +++++++++++++++++++++++++++++++--------
 src/wcc/gen_wasm.c        | 30 +++++++++++++-
 src/wcc/traverse.c        | 50 ++++++++++++++---------
 4 files changed, 130 insertions(+), 36 deletions(-)

diff --git a/src/cc/frontend/cc_misc.c b/src/cc/frontend/cc_misc.c
index fe37610bf..3cdd377ca 100644
--- a/src/cc/frontend/cc_misc.c
+++ b/src/cc/frontend/cc_misc.c
@@ -166,6 +166,7 @@ void construct_initial_value(const Type *type, const Initializer *init,
     if (init->kind == IK_SINGLE) {
       Expr *e = strip_cast(init->single);
       if (e->kind == EX_STR && is_char_type(type->pa.ptrof, e->str.kind)) {
+        assert(vtable->emit_string != NULL);
         (*vtable->emit_string)(ud, e, type_size(type));
         break;
       }
@@ -198,6 +199,7 @@ void construct_initial_value(const Type *type, const Initializer *init,
         if (mem_init != NULL || !sinfo->is_union) {
           int align = align_size(member->type);
           if (offset % align != 0) {
+            assert(vtable->emit_align != NULL);
             (*vtable->emit_align)(ud, align);
             offset = ALIGN(offset, align);
           }
diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 1c644021a..6e8c4f164 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -131,15 +131,19 @@ typedef struct {
 static Vector *construct_data_segment(void) {
   // Enumerate global variables.
   Vector *segments = new_vector();
-  const Name *name;
-  GVarInfo *info;
 #ifndef NDEBUG
   uint32_t address = 0;
 #endif
-  for (int it = 0; (it = table_iterate(&gvar_info_table, it, &name, (void**)&info)) != -1; ) {
-    const VarInfo *varinfo = info->varinfo;
+  for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+    VarInfo *varinfo = global_scope->vars->data[i];
+    if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+      continue;
     if (varinfo->global.init == NULL || !is_global_datsec_var(varinfo, global_scope))
       continue;
+    GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+    if (info == NULL)
+      continue;
+
 #ifndef NDEBUG
     uint32_t adr = info->non_prim.address;
     assert(adr >= address);
@@ -174,6 +178,7 @@ typedef struct {
   uint32_t function_count;
   int32_t table_start_index;
   uint32_t code_section_index;
+  uint32_t import_global_count;
 } EmitWasm;
 
 static void emit_type_section(EmitWasm *ew) {
@@ -201,6 +206,7 @@ static void emit_import_section(EmitWasm *ew) {
   data_open_chunk(&imports_section);
   data_open_chunk(&imports_section);
   uint32_t imports_count = 0;
+  uint32_t global_count = 0;
 
   if (out_type < OutExecutable) {
     static const char kMemoryName[] = "__linear_memory";
@@ -233,6 +239,32 @@ static void emit_import_section(EmitWasm *ew) {
       ++imports_count;
     }
   }
+
+  {
+    const char *module_name = ew->import_module_name;
+    size_t module_name_len = strlen(module_name);
+
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+        continue;
+      if (is_global_datsec_var(varinfo, global_scope))
+        continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL || !(info->flag & GVF_UNRESOLVED))
+        continue;
+
+      const Name *name = varinfo->name;
+      data_string(&imports_section, module_name, module_name_len);  // import module name
+      data_string(&imports_section, name->chars, name->bytes);  // import name
+      data_push(&imports_section, IMPORT_GLOBAL);  // import kind
+      data_push(&imports_section, to_wtype(varinfo->type));  // type
+      data_push(&imports_section, !(varinfo->type->qualifier & TQ_CONST));  // mutable
+      ++imports_count;
+      ++global_count;
+    }
+  }
+
   if (imports_count > 0) {
     data_close_chunk(&imports_section, imports_count);
     data_close_chunk(&imports_section, -1);
@@ -241,6 +273,8 @@ static void emit_import_section(EmitWasm *ew) {
     fwrite(imports_section.buf, imports_section.len, 1, ew->ofp);
     ++ew->section_index;
   }
+
+  ew->import_global_count = global_count;
 }
 
 static void emit_function_section(EmitWasm *ew) {
@@ -320,10 +354,14 @@ static void emit_global_section(EmitWasm *ew) {
   data_open_chunk(&globals_section);
   uint32_t globals_count = 0;
   {
-    const Name *name;
-    GVarInfo *info;
-    for (int it = 0; (it = table_iterate(&gvar_info_table, it, &name, (void**)&info)) != -1; ) {
-      const VarInfo *varinfo = info->varinfo;
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+        continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL)
+        continue;
+
       if ((info->flag & GVF_UNRESOLVED) || is_global_datsec_var(varinfo, global_scope))
         continue;
       unsigned char wt = to_wtype(varinfo->type);
@@ -562,7 +600,8 @@ static void emit_linking_section(EmitWasm *ew) {
       ++count;
     }
   }
-  {  // Globals
+  // Globals
+  for (int k = 0; k < 2; ++k) {  // 0=unresolved, 1=resolved
     for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
       VarInfo *varinfo = global_scope->vars->data[i];
       if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
@@ -570,6 +609,8 @@ static void emit_linking_section(EmitWasm *ew) {
       GVarInfo *info = get_gvar_info_from_name(varinfo->name);
       if (info == NULL)
         continue;
+      if ((k == 0 && !(info->flag & GVF_UNRESOLVED)) || (k != 0 && (info->flag & GVF_UNRESOLVED)))
+        continue;
 
       int flags = 0;
       if (info->flag & GVF_UNRESOLVED)
@@ -577,14 +618,25 @@ static void emit_linking_section(EmitWasm *ew) {
       if (varinfo->storage & VS_STATIC)
         flags |= WASM_SYM_VISIBILITY_HIDDEN;
 
-      data_push(&linking_section, SIK_SYMTAB_DATA);  // kind
-      data_uleb128(&linking_section, -1, flags);
-      const Name *name = varinfo->name;
-      data_string(&linking_section, name->chars, name->bytes);
-      if (!(info->flag & GVF_UNRESOLVED)) {  // Defined function: put name. otherwise not required.
+      if (is_global_datsec_var(varinfo, global_scope)) {
+        data_push(&linking_section, SIK_SYMTAB_DATA);  // kind
+        data_uleb128(&linking_section, -1, flags);
+        const Name *name = varinfo->name;
+        data_string(&linking_section, name->chars, name->bytes);
+        if (!(info->flag & GVF_UNRESOLVED)) {  // Defined global: put name. otherwise not required.
+          data_uleb128(&linking_section, -1, info->non_prim.item_index);
+          data_uleb128(&linking_section, -1, 0);  // offset (must start from the begining)
+          data_uleb128(&linking_section, -1, type_size(varinfo->type));  // size
+        }
+      } else {
+        data_push(&linking_section, SIK_SYMTAB_GLOBAL);  // kind
+        data_uleb128(&linking_section, -1, flags);
         data_uleb128(&linking_section, -1, info->non_prim.item_index);
-        data_uleb128(&linking_section, -1, 0);  // TODO: offset
-        data_uleb128(&linking_section, -1, type_size(varinfo->type));  // size
+        // if (!(info->flag & GVF_UNRESOLVED)) {
+        if (info->non_prim.item_index >= ew->import_global_count) {
+          const Name *name = varinfo->name;
+          data_string(&linking_section, name->chars, name->bytes);
+        }
       }
 
       ++count;
diff --git a/src/wcc/gen_wasm.c b/src/wcc/gen_wasm.c
index cbd172639..a1177b29c 100644
--- a/src/wcc/gen_wasm.c
+++ b/src/wcc/gen_wasm.c
@@ -540,7 +540,20 @@ static void gen_var(Expr *expr, bool needval) {
       } else {
         GVarInfo *info = get_gvar_info(expr);
         ADD_CODE(OP_GLOBAL_GET);
-        ADD_ULEB128(info->non_prim.address);
+        if (out_type >= OutExecutable) {
+          ADD_ULEB128(info->non_prim.address);
+        } else {
+          FuncExtra *extra = curfunc->extra;
+          DataStorage *code = extra->code;
+          RelocInfo *ri = calloc_or_die(sizeof(*ri));
+          ri->type = R_WASM_GLOBAL_INDEX_LEB;
+          ri->offset = code->len;
+          ri->addend = 0;
+          ri->index = info->non_prim.symbol_index;
+          vec_push(extra->reloc_code, ri);
+
+          ADD_VARUINT32(0);
+        }
       }
     }
     break;
@@ -593,7 +606,20 @@ static void gen_set_to_var(Expr *var) {
     assert(!is_global_datsec_var(varinfo, var->var.scope));
     GVarInfo *info = get_gvar_info(var);
     ADD_CODE(OP_GLOBAL_SET);
-    ADD_ULEB128(info->prim.index);
+    if (out_type >= OutExecutable) {
+      ADD_ULEB128(info->prim.index);
+    } else {
+      FuncExtra *extra = curfunc->extra;
+      DataStorage *code = extra->code;
+      RelocInfo *ri = calloc_or_die(sizeof(*ri));
+      ri->type = R_WASM_GLOBAL_INDEX_LEB;
+      ri->offset = code->len;
+      ri->addend = 0;
+      ri->index = info->non_prim.symbol_index;
+      vec_push(extra->reloc_code, ri);
+
+      ADD_VARUINT32(0);
+    }
   }
 }
 
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index 59df28b91..031a35c32 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -729,16 +729,20 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
     // Assign linking index to globals.
     uint32_t global_index = 0;
     uint32_t data_index = 0;
-    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
-      VarInfo *varinfo = global_scope->vars->data[i];
-      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
-        continue;
-      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
-      if (info == NULL)
-        continue;
-      uint32_t index = !is_global_datsec_var(varinfo, global_scope) ? global_index++ : !(varinfo->storage & VS_EXTERN) ? data_index++ : (uint32_t)-1;
-      info->non_prim.item_index = index;
-      info->non_prim.symbol_index = symbol_index++;
+    for (int k = 0; k < 2; ++k) {  // 0=unresolved, 1=resolved
+      for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+        VarInfo *varinfo = global_scope->vars->data[i];
+        if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+          continue;
+        GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+        if (info == NULL)
+          continue;
+        if ((k == 0) == ((info->flag & GVF_UNRESOLVED) == 0))
+          continue;
+        uint32_t index = !is_global_datsec_var(varinfo, global_scope) ? global_index++ : !(varinfo->storage & VS_EXTERN) ? data_index++ : (uint32_t)-1;
+        info->non_prim.item_index = index;
+        info->non_prim.symbol_index = symbol_index++;
+      }
     }
   }
 
@@ -765,35 +769,45 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
     // Enumerate global variables.
     const uint32_t START_ADDRESS = 1;  // Avoid valid poiter is NULL.
     uint32_t address = START_ADDRESS;
-    const Name *name;
-    GVarInfo *info;
 
     VERBOSE("### Memory  0x%x\n", address);
     for (int k = 0; k < 2; ++k) {  // 0: data, 1: bss
       if (k == 1)
         VERBOSE("---- BSS  0x%x\n", address);
-      for (int it = 0; (it = table_iterate(&gvar_info_table, it, &name, (void**)&info)) != -1; ) {
-        const VarInfo *varinfo = info->varinfo;
+      for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+        VarInfo *varinfo = global_scope->vars->data[i];
+        if (varinfo->storage & (VS_EXTERN | VS_ENUM_MEMBER) || varinfo->type->kind == TY_FUNC)
+          continue;
         if ((varinfo->global.init == NULL) == (k == 0) || !is_global_datsec_var(varinfo, global_scope))
           continue;
+        GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+        if (info == NULL)
+          continue;
+
         // Mapped to memory
         address = ALIGN(address, align_size(varinfo->type));
         info->non_prim.address = address;
         size_t size = type_size(varinfo->type);
         address += size;
-        VERBOSE("%04x: %.*s  (size=0x%lx)\n", info->non_prim.address, NAMES(name), size);
+        VERBOSE("%04x: %.*s  (size=0x%lx)\n", info->non_prim.address, NAMES(varinfo->name), size);
       }
     }
 
     // Primitive types (Globals).
     VERBOSES("\n### Globals\n");
     uint32_t index = 0;
-    for (int it = 0; (it = table_iterate(&gvar_info_table, it, &name, (void**)&info)) != -1; ) {
-      const VarInfo *varinfo = info->varinfo;
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
+        continue;
       if (is_global_datsec_var(varinfo, global_scope))
         continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL)
+        continue;
+
       info->prim.index = index++;
-      VERBOSE("%2d: %.*s\n", info->prim.index, NAMES(name));
+      VERBOSE("%2d: %.*s\n", info->prim.index, NAMES(varinfo->name));
     }
     VERBOSES("\n");
 

From 295991dd5ea770a791ee8bd63f67a458f580ab43 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Sun, 28 Jan 2024 12:41:05 +0900
Subject: [PATCH 05/10] Output wasm

---
 src/wcc/emit_wasm.c | 220 +++++++++++++++++++++++++++-----------------
 src/wcc/wcc.h       |  18 ++++
 2 files changed, 154 insertions(+), 84 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 6e8c4f164..b1c20693a 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -67,13 +67,19 @@ static void construct_primitive_global(DataStorage *ds, const VarInfo *varinfo)
   construct_initial_value(type, init, &kVtable, ds);
 }
 
+typedef struct {
+  DataStorage *ds;
+  Vector *reloc_data;
+} EmitDataParam;
+
 static void emit_fixnum(DataStorage *ds, Fixnum v, size_t size) {
   // Assume endian and CHAR_BIT are same on host and target.
   data_append(ds, (unsigned char*)&v, size);
 }
 
 static void emit_align(void *ud, int align) {
-  DataStorage *ds = ud;
+  EmitDataParam *edp = ud;
+  DataStorage *ds = edp->ds;
   int offset = ds->len;
   int d = offset % align;
   if (d > 0) {
@@ -83,6 +89,8 @@ static void emit_align(void *ud, int align) {
   }
 }
 static void emit_number(void *ud, const Type *type, Expr *var, Fixnum offset) {
+  EmitDataParam *edp = ud;
+  DataStorage *ds = edp->ds;
   Fixnum v = offset;
   if (var != NULL) {
     assert(var->kind == EX_VAR);
@@ -94,14 +102,27 @@ static void emit_number(void *ud, const Type *type, Expr *var, Fixnum offset) {
       const GVarInfo *info = get_gvar_info(var);
       assert(!is_prim_type(info->varinfo->type) || (info->varinfo->storage & VS_REF_TAKEN));
       v += info->non_prim.address;
+
+      if (out_type < OutExecutable) {
+        RelocInfo *ri = calloc_or_die(sizeof(*ri));
+        ri->type = R_WASM_MEMORY_ADDR_I32;
+        ri->offset = ds->len;
+        ri->addend = offset;
+        ri->index = info->non_prim.symbol_index;
+
+        Vector *reloc_data = edp->reloc_data;
+        if (reloc_data == NULL)
+          edp->reloc_data = reloc_data = new_vector();
+        vec_push(reloc_data, ri);
+      }
     }
   }
-  DataStorage *ds = ud;
   emit_fixnum(ds, v, type_size(type));
 }
 static void emit_string(void *ud, Expr *str, size_t size) {
   assert(str->kind == EX_STR);
-  DataStorage *ds = ud;
+  EmitDataParam *edp = ud;
+  DataStorage *ds = edp->ds;
   size_t src_size = str->str.len * type_size(str->type->pa.ptrof);
   if (size > src_size) {
     unsigned char *buf = calloc_or_die(size);
@@ -114,18 +135,24 @@ static void emit_string(void *ud, Expr *str, size_t size) {
   }
 }
 
-static void construct_data_segment_sub(DataStorage *ds, const VarInfo *varinfo) {
+static Vector *construct_data_segment_sub(DataStorage *ds, const VarInfo *varinfo) {
   static const ConstructInitialValueVTable kVtable = {
     .emit_align = emit_align,
     .emit_number = emit_number,
     .emit_string = emit_string,
   };
-  construct_initial_value(varinfo->type, varinfo->global.init, &kVtable, ds);
+  EmitDataParam edp = {
+    .ds = ds,
+    .reloc_data = NULL,
+  };
+  construct_initial_value(varinfo->type, varinfo->global.init, &kVtable, &edp);
+  return edp.reloc_data;
 }
 
 typedef struct {
   GVarInfo *gvarinfo;
   DataStorage ds;
+  Vector *reloc_data;
 } DataSegment;
 
 static Vector *construct_data_segment(void) {
@@ -152,7 +179,7 @@ static Vector *construct_data_segment(void) {
     DataSegment *segment = malloc_or_die(sizeof(*segment));
     segment->gvarinfo = info;
     data_init(&segment->ds);
-    construct_data_segment_sub(&segment->ds, varinfo);
+    segment->reloc_data = construct_data_segment_sub(&segment->ds, varinfo);
     vec_push(segments, segment);
 
 #ifndef NDEBUG
@@ -170,18 +197,7 @@ static int compare_indirect(const void *pa, const void *pb) {
 
 //
 
-typedef struct {
-  FILE *ofp;
-  const char *import_module_name;
-  uint32_t address_bottom;
-  uint32_t section_index;
-  uint32_t function_count;
-  int32_t table_start_index;
-  uint32_t code_section_index;
-  uint32_t import_global_count;
-} EmitWasm;
-
-static void emit_type_section(EmitWasm *ew) {
+void emit_type_section(EmitWasm *ew) {
   DataStorage types_section;
   data_init(&types_section);
   data_open_chunk(&types_section);
@@ -306,7 +322,7 @@ static void emit_function_section(EmitWasm *ew) {
   }
 }
 
-static void emit_table_section(EmitWasm *ew) {
+void emit_table_section(EmitWasm *ew) {
   if (out_type < OutExecutable)
     return;
 
@@ -324,7 +340,7 @@ static void emit_table_section(EmitWasm *ew) {
   ++ew->section_index;
 }
 
-static void emit_memory_section(EmitWasm *ew) {
+void emit_memory_section(EmitWasm *ew) {
   if (out_type < OutExecutable)
     return;
 
@@ -438,7 +454,7 @@ static void emit_export_section(EmitWasm *ew, Vector *exports) {
   ++ew->section_index;
 }
 
-static void emit_elems_section(EmitWasm *ew) {
+void emit_elems_section(EmitWasm *ew) {
   DataStorage elems_section;
   data_init(&elems_section);
   if (indirect_function_table.count > 0) {
@@ -478,7 +494,7 @@ static void emit_elems_section(EmitWasm *ew) {
   }
 }
 
-static void emit_tag_section(EmitWasm *ew) {
+void emit_tag_section(EmitWasm *ew) {
   DataStorage tag_section;
   data_init(&tag_section);
   if (tags->len > 0) {
@@ -529,36 +545,50 @@ static void emit_code_section(EmitWasm *ew) {
   ++ew->section_index;
 }
 
-static void emit_data_section(EmitWasm *ew) {
+static Vector *emit_data_section(EmitWasm *ew) {
   Vector *segments = construct_data_segment();
-  if (segments->len <= 0)
-    return;
+  Vector *reloc_data = NULL;
+  if (segments->len > 0) {
+    reloc_data = new_vector();
+
+    VERBOSES("### Data\n");
+    DataStorage datasec;
+    data_init(&datasec);
+    data_open_chunk(&datasec);
+    data_uleb128(&datasec, -1, segments->len);
+    for (int i = 0; i < segments->len; ++i) {
+      DataSegment *segment = segments->data[i];
+      data_push(&datasec, 0);  // flags
+      // Init (address).
+      uint32_t address = segment->gvarinfo->non_prim.address;
+      VERBOSE("%04x: %.*s (size=%zu)\n", address, NAMES(segment->gvarinfo->varinfo->name),
+              type_size(segment->gvarinfo->varinfo->type));
+      data_push(&datasec, OP_I32_CONST);
+      data_leb128(&datasec, -1, address);
+      data_push(&datasec, OP_END);
+      // Content
+      data_uleb128(&datasec, -1, segment->ds.len);
+      uint32_t offset = datasec.len;
+      data_concat(&datasec, &segment->ds);
+
+      // Reloc data.
+      Vector *relocs = segment->reloc_data;
+      if (relocs != NULL) {
+        for (int i = 0; i < relocs->len; ++i) {
+          RelocInfo *reloc = relocs->data[i];
+          reloc->offset += offset;
+          vec_push(reloc_data, reloc);
+        }
+      }
+    }
+    data_close_chunk(&datasec, -1);
+    VERBOSES("\n");
 
-  VERBOSES("### Data\n");
-  DataStorage datasec;
-  data_init(&datasec);
-  data_open_chunk(&datasec);
-  data_uleb128(&datasec, -1, segments->len);
-  for (int i = 0; i < segments->len; ++i) {
-    DataSegment *segment = segments->data[i];
-    data_push(&datasec, 0);  // flags
-    // Init (address).
-    uint32_t address = segment->gvarinfo->non_prim.address;
-    VERBOSE("%04x: %.*s (size=%zu)\n", address, NAMES(segment->gvarinfo->varinfo->name),
-            type_size(segment->gvarinfo->varinfo->type));
-    data_push(&datasec, OP_I32_CONST);
-    data_leb128(&datasec, -1, address);
-    data_push(&datasec, OP_END);
-    // Content
-    data_uleb128(&datasec, -1, segment->ds.len);
-    data_concat(&datasec, &segment->ds);
+    fputc(SEC_DATA, ew->ofp);
+    fwrite(datasec.buf, datasec.len, 1, ew->ofp);
+    ++ew->section_index;
   }
-  data_close_chunk(&datasec, -1);
-  VERBOSES("\n");
-
-  fputc(SEC_DATA, ew->ofp);
-  fwrite(datasec.buf, datasec.len, 1, ew->ofp);
-  ++ew->section_index;
+  return reloc_data;
 }
 
 static void emit_linking_section(EmitWasm *ew) {
@@ -654,9 +684,46 @@ static void emit_linking_section(EmitWasm *ew) {
   }
 }
 
-static void emit_reloc_section(EmitWasm *ew) {
-  static const char kRelocCode[] = "reloc.CODE";
+static void emit_reloc_section(EmitWasm *ew, int section_index, Vector *relocs, const char *name) {
+  assert(relocs != NULL);
+  if (relocs->len > 0) {
+    DataStorage ds;
+    data_init(&ds);
+    data_open_chunk(&ds);
+    data_string(&ds, name, strlen(name));
+    data_uleb128(&ds, -1, section_index);
+
+    int count = relocs->len;
+    data_uleb128(&ds, -1, count);
+    for (int i = 0; i < count; ++i) {
+      RelocInfo *reloc = relocs->data[i];
+      data_push(&ds, reloc->type);
+      data_uleb128(&ds, -1, reloc->offset);
+      data_uleb128(&ds, -1, reloc->index);
+      switch (reloc->type) {
+      case R_WASM_MEMORY_ADDR_LEB:
+      case R_WASM_MEMORY_ADDR_SLEB:
+      case R_WASM_MEMORY_ADDR_I32:
+      case R_WASM_MEMORY_ADDR_LEB64:
+      case R_WASM_MEMORY_ADDR_SLEB64:
+      case R_WASM_MEMORY_ADDR_I64:
+      case R_WASM_FUNCTION_OFFSET_I32:
+      case R_WASM_SECTION_OFFSET_I32:
+        data_uleb128(&ds, -1, reloc->addend);
+        break;
+      default: break;
+      }
+      // TODO: addend?
+    }
+    data_close_chunk(&ds, -1);
+
+    fputc(SEC_CUSTOM, ew->ofp);
+    fwrite(ds.buf, ds.len, 1, ew->ofp);
+    ++ew->section_index;
+  }
+}
 
+static void emit_reloc_code_section(EmitWasm *ew) {
   typedef struct {
     Function *func;
     RelocInfo *reloc;
@@ -681,47 +748,30 @@ static void emit_reloc_section(EmitWasm *ew) {
     }
   }
 
-  if (code_reloc_all->len > 0) {
-    DataStorage reloc_code_section;
-    data_init(&reloc_code_section);
-    data_open_chunk(&reloc_code_section);
-    data_string(&reloc_code_section, kRelocCode, sizeof(kRelocCode) - 1);
-    data_uleb128(&reloc_code_section, -1, ew->code_section_index);
-
-    int count = code_reloc_all->len;
-    data_uleb128(&reloc_code_section, -1, count);
+  int count = code_reloc_all->len;
+  if (count > 0) {
     for (int i = 0; i < count; ++i) {
       CodeReloc *cr = code_reloc_all->data[i];
       Function *func = cr->func;
       RelocInfo *reloc = cr->reloc;
       FuncExtra *extra = func->extra;
-
-      data_push(&reloc_code_section, reloc->type);
-      data_uleb128(&reloc_code_section, -1, reloc->offset + extra->offset);
-      data_uleb128(&reloc_code_section, -1, reloc->index);
-      switch (reloc->type) {
-      case R_WASM_MEMORY_ADDR_LEB:
-      case R_WASM_MEMORY_ADDR_SLEB:
-      case R_WASM_MEMORY_ADDR_I32:
-      case R_WASM_MEMORY_ADDR_LEB64:
-      case R_WASM_MEMORY_ADDR_SLEB64:
-      case R_WASM_MEMORY_ADDR_I64:
-      case R_WASM_FUNCTION_OFFSET_I32:
-      case R_WASM_SECTION_OFFSET_I32:
-        data_uleb128(&reloc_code_section, -1, reloc->addend);
-        break;
-      default: break;
-      }
-      // TODO: addend?
+      reloc->offset += extra->offset;
+      code_reloc_all->data[i] = reloc;  // Replace from CodeReloc* to RelocInfo*
     }
-    data_close_chunk(&reloc_code_section, -1);
 
-    fputc(SEC_CUSTOM, ew->ofp);
-    fwrite(reloc_code_section.buf, reloc_code_section.len, 1, ew->ofp);
-    ++ew->section_index;
+    static const char kRelocCode[] = "reloc.CODE";
+    emit_reloc_section(ew, ew->code_section_index, code_reloc_all, kRelocCode);
   }
 }
 
+static void emit_reloc_data_section(EmitWasm *ew, Vector *reloc_data) {
+  if (reloc_data == NULL)
+    return;
+
+  static const char kRelocData[] = "reloc.DATA";
+  emit_reloc_section(ew, ew->data_section_index, reloc_data, kRelocData);
+}
+
 void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
                uint32_t address_bottom) {
   write_wasm_header(ofp);
@@ -766,10 +816,12 @@ void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name,
   emit_code_section(ew);
 
   // Data.
-  emit_data_section(ew);
+  ew->data_section_index = ew->section_index;
+  Vector *reloc_data = emit_data_section(ew);
 
   if (out_type < OutExecutable) {
     emit_linking_section(ew);
-    emit_reloc_section(ew);
+    emit_reloc_code_section(ew);
+    emit_reloc_data_section(ew, reloc_data);
   }
 }
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index 6d3494fa5..4916d8967 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -88,8 +88,26 @@ void add_code(const unsigned char* buf, size_t size);
 void install_builtins(void);
 
 // emit_wasm
+typedef struct {
+  FILE *ofp;
+  const char *import_module_name;
+  uint32_t address_bottom;
+  uint32_t section_index;
+  uint32_t function_count;
+  int32_t table_start_index;
+  uint32_t code_section_index;
+  uint32_t data_section_index;
+  uint32_t import_global_count;
+} EmitWasm;
+
 void emit_wasm(FILE *ofp, Vector *exports, const char *import_module_name, uint32_t address_bottom);
 
+void emit_type_section(EmitWasm *ew);
+void emit_table_section(EmitWasm *ew);
+void emit_memory_section(EmitWasm *ew);
+void emit_tag_section(EmitWasm *ew);
+void emit_elems_section(EmitWasm *ew);
+
 // wcc_util
 enum OutType {
   // OutPreprocess,

From 5d697235f87ac9efe9b604de4ae6d1a405052580 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Fri, 2 Feb 2024 18:47:07 +0900
Subject: [PATCH 06/10] Generate relocation for calling through function
 pointer

  * Import table for indirect function indices: `env.__indirect_function_table`
  * type signature (index) for `call_indirect`
---
 src/wcc/emit_wasm.c | 29 ++++++++++++++++++++++++++++-
 src/wcc/gen_wasm.c  | 32 +++++++++++++++++++++++++++++---
 2 files changed, 57 insertions(+), 4 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index b1c20693a..a90970244 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -97,6 +97,23 @@ static void emit_number(void *ud, const Type *type, Expr *var, Fixnum offset) {
     if (var->type->kind == TY_FUNC) {
       assert(v == 0);
       v = get_indirect_function_index(var->var.name);
+
+      if (out_type < OutExecutable) {
+        FuncInfo *info = table_get(&func_info_table, var->var.name);
+        if (info == NULL)
+          error("`%.*s' not found", NAMES(var->var.name));
+
+        RelocInfo *ri = calloc_or_die(sizeof(*ri));
+        ri->type = R_WASM_TABLE_INDEX_I32;
+        ri->offset = ds->len;
+        ri->addend = offset;
+        ri->index = info->index;
+
+        Vector *reloc_data = edp->reloc_data;
+        if (reloc_data == NULL)
+          edp->reloc_data = reloc_data = new_vector();
+        vec_push(reloc_data, ri);
+      }
     } else {
       assert(var->kind == EX_VAR);
       const GVarInfo *info = get_gvar_info(var);
@@ -233,6 +250,16 @@ static void emit_import_section(EmitWasm *ew) {
     data_uleb128(&imports_section, -1, 0);  // size
     ++imports_count;
   }
+  if (indirect_function_table.count > 0 && out_type < OutExecutable) {
+    static const char kTableName[] = "__indirect_function_table";
+    data_string(&imports_section, env_module_name, sizeof(env_module_name) - 1);  // import module name
+    data_string(&imports_section, kTableName, sizeof(kTableName) - 1);  // import name
+    data_push(&imports_section, IMPORT_TABLE);  // import kind
+    data_push(&imports_section, WT_FUNCREF);
+    data_push(&imports_section, 0x00);  // limits: flags
+    data_leb128(&imports_section, -1, ew->table_start_index);  // initial
+    ++imports_count;
+  }
 
   {
     const char *module_name = ew->import_module_name;
@@ -482,7 +509,7 @@ void emit_elems_section(EmitWasm *ew) {
     data_leb128(&elems_section, -1, count);  // num elems
     for (int i = 0; i < count; ++i) {
       FuncInfo *info = indirect_funcs[i];
-      VERBOSE("%2d: %.*s (%d)\n", i + 1, NAMES(info->func->name), (int)info->index);
+      VERBOSE("%2d: %.*s (%u)\n", i + 1, NAMES(info->varinfo->name), info->index);
       data_leb128(&elems_section, -1, info->index);  // elem function index
     }
     data_close_chunk(&elems_section, -1);
diff --git a/src/wcc/gen_wasm.c b/src/wcc/gen_wasm.c
index a1177b29c..429cea2f4 100644
--- a/src/wcc/gen_wasm.c
+++ b/src/wcc/gen_wasm.c
@@ -402,7 +402,19 @@ static void gen_funcall(Expr *expr) {
     int index = get_func_type_index(functype);
     assert(index >= 0);
     ADD_CODE(OP_CALL_INDIRECT);
-    ADD_ULEB128(index);  // signature index
+    if (out_type >= OutExecutable) {
+      ADD_ULEB128(index);  // signature index
+    } else {
+      FuncExtra *extra = curfunc->extra;
+      DataStorage *code = extra->code;
+      RelocInfo *ri = calloc_or_die(sizeof(*ri));
+      ri->type = R_WASM_TYPE_INDEX_LEB;
+      ri->index = index;
+      ri->offset = code->len;
+      vec_push(extra->reloc_code, ri);
+
+      ADD_VARUINT32(index);
+    }
     ADD_ULEB128(0);      // table index
   }
 
@@ -458,9 +470,23 @@ static void gen_ref_sub(Expr *expr) {
              is_global_datsec_var(varinfo, scope));
       if (is_global_scope(scope) || !is_local_storage(varinfo)) {
         if (varinfo->type->kind == TY_FUNC) {
-          uint32_t indirect_func = get_indirect_function_index(expr->var.name);
           ADD_CODE(OP_I32_CONST);
-          ADD_LEB128(indirect_func);
+          if (out_type >= OutExecutable) {
+            uint32_t indirect_func = get_indirect_function_index(expr->var.name);
+            ADD_LEB128(indirect_func);
+          } else {
+            FuncInfo *info = table_get(&indirect_function_table, expr->var.name);
+            assert(info != NULL && info->indirect_index > 0);
+            FuncExtra *extra = curfunc->extra;
+            DataStorage *code = extra->code;
+            RelocInfo *ri = calloc_or_die(sizeof(*ri));
+            ri->type = R_WASM_TABLE_INDEX_SLEB;
+            ri->offset = code->len;
+            ri->index = info->index;
+            vec_push(extra->reloc_code, ri);
+
+            ADD_VARUINT32(info->indirect_index);
+          }
         } else {
           GVarInfo *info = get_gvar_info(expr);
           ADD_CODE(OP_I32_CONST);

From d713d88c4280b29e1fc3ca2bcd4d096265707622 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Sat, 3 Feb 2024 10:58:12 +0900
Subject: [PATCH 07/10] Enable to use emcc to link object file

  * Rename `main` function according to parameter count
---
 src/cc/frontend/fe_misc.c | 13 ++++++++-
 src/wcc/traverse.c        | 42 +++++++++++++++++++++++----
 src/wcc/wcc.c             | 60 +++++++++++++++++++++++++++++++++------
 src/wcc/wcc.h             |  2 ++
 tests/test.sh             |  2 +-
 5 files changed, 104 insertions(+), 15 deletions(-)

diff --git a/src/cc/frontend/fe_misc.c b/src/cc/frontend/fe_misc.c
index 777e38fb6..c809d151c 100644
--- a/src/cc/frontend/fe_misc.c
+++ b/src/cc/frontend/fe_misc.c
@@ -1408,6 +1408,17 @@ static void check_func_return(Function *func) {
   Type *type = func->type;
   Type *rettype = type->func.ret;
   const Token *rbrace = func->body_block->block.rbrace;
+
+  static const Name *main_name;
+  if (main_name == NULL)
+    main_name = alloc_name("main", NULL, false);
+  if (equal_name(func->name, main_name)) {
+    if (rettype->kind == TY_VOID) {
+      // Force return type to `int' for `main' function.
+      type->func.ret = rettype = &tyInt;
+    }
+  }
+
   if (func->flag & FUNCF_NORETURN) {
     if (rettype->kind != TY_VOID) {
       parse_error(PE_WARNING, rbrace, "`noreturn' function should not return value");
@@ -1420,7 +1431,7 @@ static void check_func_return(Function *func) {
   } else if (rettype->kind != TY_VOID && !(func->body_block->reach & REACH_STOP)) {
     Vector *stmts = func->body_block->block.stmts;
     if (stmts->len == 0 || ((Stmt*)stmts->data[stmts->len - 1])->kind != ST_ASM) {
-      if (equal_name(func->name, alloc_name("main", NULL, false))) {
+      if (equal_name(func->name, main_name)) {
         // Return 0 if `return` statement is omitted in `main` function.
         if (!is_fixnum(rettype->kind) || rettype->fixnum.kind != FX_INT) {
           parse_error(PE_WARNING, rbrace, "`main' return type should be `int'");
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index 031a35c32..41dccf756 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -597,7 +597,7 @@ static void traverse_stmts(Vector *stmts) {
   }
 }
 
-static void traverse_defun(Function *func) {
+static void traverse_defun(Function *func, Vector *exports) {
   if (func->scopes == NULL)  // Prototype definition
     return;
 
@@ -607,7 +607,38 @@ static void traverse_defun(Function *func) {
 
   Type *functype = func->type;
   assert(func->params != NULL);
-  if (equal_name(func->name, alloc_name("main", NULL, false))) {
+  const Name *main_name = alloc_name("main", NULL, false);
+  if (equal_name(func->name, main_name)) {
+#if USE_EMCC_AS_LINKER
+    const Name *newname = NULL;
+    switch (func->params->len) {
+    case 0:  newname = alloc_name("__main_void", NULL, false);  break;
+    case 2:  newname = alloc_name("__main_argc_argv", NULL, false);  break;
+    default:
+      error("main function must take no argument or two arguments");
+      break;
+    }
+
+    // Rename two arguments `main` to `__main_argc_argv`.
+    VarInfo *org_varinfo = scope_find(global_scope, main_name, NULL);
+    assert(org_varinfo != NULL);
+    func->name = newname;
+    VarInfo *varinfo = scope_add(global_scope, newname, functype, org_varinfo->storage);
+    varinfo->global.func = func;
+
+    // Clear `main` function.
+    assert(org_varinfo->global.func == func);
+    org_varinfo->global.func = NULL;
+
+    // Replace exports.
+    for (int i = 0; i < exports->len; ++i) {
+      if (equal_name(exports->data[i], main_name)) {
+        exports->data[i] = (void*)newname;
+        break;
+      }
+    }
+#else
+    UNUSED(exports);
     // Force `main' function takes two arguments.
     if (func->params->len < 1) {
       assert(func->scopes->len > 0);
@@ -625,6 +656,7 @@ static void traverse_defun(Function *func) {
       vec_push((Vector*)func->params, scope_add(scope, name, type, 0));
       vec_push((Vector*)functype->func.params, type);
     }
+#endif
   }
   if (functype->func.vaargs) {
     Type *tyvalist = find_typedef(curscope, alloc_name("__builtin_va_list", NULL, false), NULL);
@@ -647,13 +679,13 @@ static void traverse_defun(Function *func) {
   // Static variables are traversed through global variables.
 }
 
-static void traverse_decl(Declaration *decl) {
+static void traverse_decl(Declaration *decl, Vector *exports) {
   if (decl == NULL)
     return;
 
   switch (decl->kind) {
   case DCL_DEFUN:
-    traverse_defun(decl->defun.func);
+    traverse_defun(decl->defun.func, exports);
     break;
   case DCL_VARDECL:
     break;
@@ -703,7 +735,7 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
 
   for (int i = 0, len = decls->len; i < len; ++i) {
     Declaration *decl = decls->data[i];
-    traverse_decl(decl);
+    traverse_decl(decl, exports);
   }
 
   // Check exports
diff --git a/src/wcc/wcc.c b/src/wcc/wcc.c
index c0388b40c..01ebe4793 100644
--- a/src/wcc/wcc.c
+++ b/src/wcc/wcc.c
@@ -342,6 +342,15 @@ int main(int argc, char *argv[]) {
 #endif
   }
 
+#if USE_EMCC_AS_LINKER
+  bool do_emcc_link = false;
+  if (out_type >= OutExecutable) {
+    do_emcc_link = true;
+    out_type = OutObject;
+  }
+  if (import_module_name == DEFAULT_IMPORT_MODULE_NAME)
+    import_module_name = "env";
+#endif
   if (out_type >= OutExecutable && entry_point == NULL)
     entry_point = "_start";
   if (entry_point != NULL)
@@ -404,16 +413,32 @@ int main(int argc, char *argv[]) {
   if (error_warning && compile_warning_count != 0)
     return 2;
 
-  const char *outfn = ofn;
-  if (outfn == NULL) {
-    if (out_type == OutObject) {
-      char *src = sources->data[0];  // TODO:
-      outfn = change_ext(basename(src), "o");
-    } else {
-      outfn = "a.wasm";
+  FILE *ofp;
+#if USE_EMCC_AS_LINKER
+  char *tmpfn;
+  if (do_emcc_link) {
+    char template[] = "/tmp/xcc-XXXXXX.o";
+    int obj_fd = mkstemps(template, 2);
+    if (obj_fd == -1) {
+      perror("Failed to open output file");
+      exit(1);
+    }
+    tmpfn = strdup(template);
+    ofp = fdopen(obj_fd, "wb");
+  } else
+#endif
+  {
+    const char *outfn = ofn;
+    if (outfn == NULL) {
+      if (out_type == OutObject) {
+        char *src = sources->data[0];  // TODO:
+        outfn = change_ext(basename(src), "o");
+      } else {
+        outfn = "a.wasm";
+      }
     }
+    ofp = fopen(outfn, "wb");
   }
-  FILE *ofp = fopen(outfn, "wb");
   if (ofp == NULL) {
     error("Cannot open output file");
   } else {
@@ -422,5 +447,24 @@ int main(int argc, char *argv[]) {
     fclose(ofp);
   }
 
+#if USE_EMCC_AS_LINKER
+  if (do_emcc_link) {
+    char *finalfn = (char*)ofn;
+    if (finalfn == NULL) {
+      finalfn = "a.wasm";
+    } else {
+      finalfn = change_ext(finalfn, "wasm");
+    }
+
+    char *argv[] = {
+      "emcc",
+      "-o", finalfn,
+      tmpfn,
+      NULL,
+    };
+    return execvp("emcc", argv);
+  }
+#endif
+
   return 0;
 }
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index 4916d8967..f4ea47af6 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -6,6 +6,8 @@
 #include <stdio.h>
 #include <sys/types.h>  // ssize_t
 
+// #define USE_EMCC_AS_LINKER  1
+
 typedef struct DataStorage DataStorage;
 typedef struct Expr Expr;
 typedef struct Function Function;
diff --git a/tests/test.sh b/tests/test.sh
index 84d02c603..4cfe62e30 100755
--- a/tests/test.sh
+++ b/tests/test.sh
@@ -102,7 +102,7 @@ test_basic() {
   compile_error 'variable definition conflict' 'int x = 0; int x = 123; int main(void) {return x;}'
   compile_error 'illegal type combination' 'int main(void) {long short x = 99; return x;}'
   compile_error 'assign array to struct' 'int main(void) {int a[3][2] = {11,22,33,44,55,66}; struct { int a[3][2]; } s; s = a; return s.a[1][1]; } //-WNOERR'
-  try_direct 'direct addressing' 99 'int main(int argc) {if (argc < 0) { *(volatile short*)0x12 = 0x34; return *(volatile int*)0x5678; } return 99;}'
+  try_direct 'direct addressing' 99 'int main(int argc, char *argv[]) {if (argc < 0) { *(volatile short*)0x12 = 0x34; return *(volatile int*)0x5678; } return 99;}'
   try_direct 'restrict for array in funparam' 83 'int sub(int arr[restrict]) { return arr[0]; } int main(void) { int a[] = {83}; return sub(a); }'
 
   end_test_suite

From 9a62292cfdbf42e5851c6e5900c0753dfb56ca5f Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Sat, 3 Feb 2024 11:55:33 +0900
Subject: [PATCH 08/10] Output BSS into data

To notify start address and size.

They will be eliminated in linker.
---
 src/wcc/emit_wasm.c | 49 +++++++++++++++++++++++++++++----------------
 1 file changed, 32 insertions(+), 17 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index a90970244..01230af3c 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -178,30 +178,45 @@ static Vector *construct_data_segment(void) {
 #ifndef NDEBUG
   uint32_t address = 0;
 #endif
-  for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
-    VarInfo *varinfo = global_scope->vars->data[i];
-    if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
-      continue;
-    if (varinfo->global.init == NULL || !is_global_datsec_var(varinfo, global_scope))
-      continue;
-    GVarInfo *info = get_gvar_info_from_name(varinfo->name);
-    if (info == NULL)
-      continue;
+  for (int k = 0; k < 2; ++k) {  // 0=data, 1=bss
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & (VS_EXTERN | VS_ENUM_MEMBER) || varinfo->type->kind == TY_FUNC)
+        continue;
+      if ((k == 0 && (varinfo->global.init == NULL || !is_global_datsec_var(varinfo, global_scope))) ||
+          (k != 0 && varinfo->global.init != NULL))
+        continue;
+      GVarInfo *info = get_gvar_info_from_name(varinfo->name);
+      if (info == NULL)
+        continue;
 
 #ifndef NDEBUG
-    uint32_t adr = info->non_prim.address;
-    assert(adr >= address);
+      uint32_t adr = info->non_prim.address;
+      assert(adr >= address);
 #endif
 
-    DataSegment *segment = malloc_or_die(sizeof(*segment));
-    segment->gvarinfo = info;
-    data_init(&segment->ds);
-    segment->reloc_data = construct_data_segment_sub(&segment->ds, varinfo);
-    vec_push(segments, segment);
+      DataSegment *segment = malloc_or_die(sizeof(*segment));
+      segment->gvarinfo = info;
+      data_init(&segment->ds);
+      if (k == 0) {
+        segment->reloc_data = construct_data_segment_sub(&segment->ds, varinfo);
+      } else {
+        // Output BSS as zero-filled data to tell its size.
+        DataStorage *ds = &segment->ds;
+        size_t start = ds->len;
+        size_t size = type_size(varinfo->type);
+        data_reserve(ds, start + size);
+        memset(ds->buf + start, 0, size);
+        ds->len += size;
+      }
+      vec_push(segments, segment);
 
 #ifndef NDEBUG
-    address = adr + type_size(varinfo->type);
+      address = adr + type_size(varinfo->type);
 #endif
+    }
+    if (out_type >= OutExecutable)
+      break;
   }
   return segments;
 }

From 589c3f596d98b1337b7bd359001bc061509ed461 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Sat, 3 Feb 2024 14:19:29 +0900
Subject: [PATCH 09/10] Fix output data order

  * Imported (unresolved)
  * Defined with initializer (.data)
  * w/o initializer (.bss)

Travese in two stages:

  1. register global variables
  2. traverse initializer

(String literal generates correspoinding char array to global variable
**after** the original one.)
---
 src/wcc/emit_wasm.c |  5 +++--
 src/wcc/traverse.c  | 21 +++++++++++++--------
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 01230af3c..7ab706fd4 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -673,7 +673,7 @@ static void emit_linking_section(EmitWasm *ew) {
     }
   }
   // Globals
-  for (int k = 0; k < 2; ++k) {  // 0=unresolved, 1=resolved
+  for (int k = 0; k < 3; ++k) {  // 0=unresolved, 1=resolved(data), 2=resolved(bss)
     for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
       VarInfo *varinfo = global_scope->vars->data[i];
       if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
@@ -681,7 +681,8 @@ static void emit_linking_section(EmitWasm *ew) {
       GVarInfo *info = get_gvar_info_from_name(varinfo->name);
       if (info == NULL)
         continue;
-      if ((k == 0 && !(info->flag & GVF_UNRESOLVED)) || (k != 0 && (info->flag & GVF_UNRESOLVED)))
+      if ((k == 0 && !(info->flag & GVF_UNRESOLVED)) ||
+          (k != 0 && ((info->flag & GVF_UNRESOLVED) || (varinfo->global.init == NULL) == (k == 1))))
         continue;
 
       int flags = 0;
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index 41dccf756..657aadbdb 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -723,12 +723,16 @@ static void add_builtins(void) {
 
 uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
   // Global scope
-  for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
-    VarInfo *varinfo = global_scope->vars->data[i];
-    if (varinfo->storage & (VS_EXTERN | VS_ENUM_MEMBER) || varinfo->type->kind == TY_FUNC)
-      continue;
-    register_gvar_info(varinfo->name, varinfo);
-    traverse_initializer(varinfo->global.init);
+  for (int k = 0; k < 2; ++k) {  // 0=register, 1=traverse
+    for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
+      VarInfo *varinfo = global_scope->vars->data[i];
+      if (varinfo->storage & (VS_EXTERN | VS_ENUM_MEMBER) || varinfo->type->kind == TY_FUNC)
+        continue;
+      if (k == 0)
+        register_gvar_info(varinfo->name, varinfo);
+      else
+        traverse_initializer(varinfo->global.init);
+    }
   }
 
   add_builtins();
@@ -761,7 +765,7 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
     // Assign linking index to globals.
     uint32_t global_index = 0;
     uint32_t data_index = 0;
-    for (int k = 0; k < 2; ++k) {  // 0=unresolved, 1=resolved
+    for (int k = 0; k < 3; ++k) {  // 0=unresolved, 1=resolved(data), 2=resolved(bss)
       for (int i = 0, len = global_scope->vars->len; i < len; ++i) {
         VarInfo *varinfo = global_scope->vars->data[i];
         if (varinfo->storage & VS_ENUM_MEMBER || varinfo->type->kind == TY_FUNC)
@@ -769,7 +773,8 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
         GVarInfo *info = get_gvar_info_from_name(varinfo->name);
         if (info == NULL)
           continue;
-        if ((k == 0) == ((info->flag & GVF_UNRESOLVED) == 0))
+        if ((k == 0 && !(info->flag & GVF_UNRESOLVED)) ||
+            (k != 0 && ((info->flag & GVF_UNRESOLVED) || (varinfo->global.init == NULL) == (k == 1))))
           continue;
         uint32_t index = !is_global_datsec_var(varinfo, global_scope) ? global_index++ : !(varinfo->storage & VS_EXTERN) ? data_index++ : (uint32_t)-1;
         info->non_prim.item_index = index;

From e8fa8fea156ec197b3d7cc990534bb2523208f26 Mon Sep 17 00:00:00 2001
From: tyfkda <tyfkda@gmail.com>
Date: Sun, 4 Feb 2024 13:51:27 +0900
Subject: [PATCH 10/10] Generate relocation for longjmp

  * Register tag in traversal stage
---
 src/wcc/emit_wasm.c | 17 ++++++++++++++--
 src/wcc/gen_wasm.c  | 48 ++++++++++++++++++++++++++++++++-------------
 src/wcc/traverse.c  |  6 ++++++
 src/wcc/wasm_obj.h  |  2 +-
 src/wcc/wcc.h       | 11 +++++++++--
 src/wcc/wcc_util.c  | 30 ++++++++++++++++++++--------
 6 files changed, 87 insertions(+), 27 deletions(-)

diff --git a/src/wcc/emit_wasm.c b/src/wcc/emit_wasm.c
index 7ab706fd4..2f56611e1 100644
--- a/src/wcc/emit_wasm.c
+++ b/src/wcc/emit_wasm.c
@@ -543,10 +543,10 @@ void emit_tag_section(EmitWasm *ew) {
     data_open_chunk(&tag_section);
     data_uleb128(&tag_section, -1, tags->len);  // tag count
     for (int i = 0; i < tags->len; ++i) {
-      int typeindex = VOIDP2INT(tags->data[i]);
+      TagInfo *t = tags->data[i];
       int attribute = 0;
       data_uleb128(&tag_section, -1, attribute);
-      data_uleb128(&tag_section, -1, typeindex);
+      data_uleb128(&tag_section, -1, t->typeindex);
     }
     data_close_chunk(&tag_section, -1);
 
@@ -715,6 +715,19 @@ static void emit_linking_section(EmitWasm *ew) {
       ++count;
     }
   }
+  if (tags->len > 0) {  // Tag
+    assert(tags->len == 1);
+    static const char kTagName[] = "__c_longjmp";
+    for (int i = 0, len = tags->len; i < len; ++i) {
+      // TagInfo *ti = tags->data[i];
+      int flags = 0;
+      data_push(&linking_section, SIK_SYMTAB_EVENT);  // kind
+      data_uleb128(&linking_section, -1, flags);
+      data_uleb128(&linking_section, -1, i);
+      data_string(&linking_section, kTagName, sizeof(kTagName) - 1);
+      ++count;
+    }
+  }
   data_close_chunk(&linking_section, count);
   data_close_chunk(&linking_section, -1);  // Put payload size.
 
diff --git a/src/wcc/gen_wasm.c b/src/wcc/gen_wasm.c
index 429cea2f4..d43200e21 100644
--- a/src/wcc/gen_wasm.c
+++ b/src/wcc/gen_wasm.c
@@ -1746,21 +1746,13 @@ void gen(Vector *decls) {
 
 ////////////////////////////////////////////////
 
-static int register_longjmp_tag(void) {
-  // Exception type: (void*, int)
-  Vector *params = new_vector();
-  vec_push(params, &tyInt);
-  vec_push(params, &tyVoidPtr);
-  Type *functype = new_func_type(&tyVoid, params, false);
-  int typeindex = getsert_func_type_index(functype, true);
-  return getsert_tag(typeindex);
-}
-
 static void gen_builtin_setjmp(Expr *expr, enum BuiltinFunctionPhase phase) {
   if (phase == BFP_TRAVERSE) {
     FuncExtra *extra = curfunc->extra;
     assert(extra != NULL);
     ++extra->setjmp_count;
+
+    register_longjmp_tag();
     return;
   }
 
@@ -1770,6 +1762,8 @@ static void gen_builtin_setjmp(Expr *expr, enum BuiltinFunctionPhase phase) {
 }
 
 static void gen_builtin_longjmp(Expr *expr, enum BuiltinFunctionPhase phase) {
+  if (phase == BFP_TRAVERSE)
+    register_longjmp_tag();
   if (phase != BFP_GEN)
     return;
 
@@ -1793,9 +1787,22 @@ static void gen_builtin_longjmp(Expr *expr, enum BuiltinFunctionPhase phase) {
   }
 
   gen_expr(args->data[0], true);
-  int tag = register_longjmp_tag();
+  TagInfo *ti = register_longjmp_tag();
   ADD_CODE(OP_THROW);
-  ADD_ULEB128(tag);
+  if (out_type >= OutExecutable) {
+    ADD_ULEB128(ti->index);
+  } else {
+    FuncExtra *extra = curfunc->extra;
+    DataStorage *code = extra->code;
+    RelocInfo *ri = calloc_or_die(sizeof(*ri));
+    ri->type = R_WASM_TAG_INDEX_LEB;
+    ri->offset = code->len;
+    ri->addend = 0;
+    ri->index = ti->symbol_index;
+    vec_push(extra->reloc_code, ri);
+
+    ADD_VARUINT32(ti->index);
+  }
 }
 
 static void gen_builtin_try_catch_longjmp(Expr *expr, enum BuiltinFunctionPhase phase) {
@@ -1815,8 +1822,21 @@ static void gen_builtin_try_catch_longjmp(Expr *expr, enum BuiltinFunctionPhase
         gen_stmt(try_block_expr->block, false);
         ADD_CODE(OP_BR, 2);
       } ADD_CODE(OP_CATCH); {
-        int tag = register_longjmp_tag();
-        ADD_ULEB128(tag);
+        TagInfo *ti = register_longjmp_tag();
+        if (out_type >= OutExecutable) {
+          ADD_ULEB128(ti->index);
+        } else {
+          FuncExtra *extra = curfunc->extra;
+          DataStorage *code = extra->code;
+          RelocInfo *ri = calloc_or_die(sizeof(*ri));
+          ri->type = R_WASM_TAG_INDEX_LEB;
+          ri->offset = code->len;
+          ri->addend = 0;
+          ri->index = ti->symbol_index;
+          vec_push(extra->reloc_code, ri);
+
+          ADD_VARUINT32(ti->index);
+        }
 
         // Assume env has no side effect.
         Expr *env = args->data[0];
diff --git a/src/wcc/traverse.c b/src/wcc/traverse.c
index 657aadbdb..419594078 100644
--- a/src/wcc/traverse.c
+++ b/src/wcc/traverse.c
@@ -781,6 +781,12 @@ uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size) {
         info->non_prim.symbol_index = symbol_index++;
       }
     }
+
+    // Tag
+    for (int i = 0, len = tags->len; i < len; ++i) {
+      TagInfo *ti = tags->data[i];
+      ti->symbol_index = symbol_index++;
+    }
   }
 
   {
diff --git a/src/wcc/wasm_obj.h b/src/wcc/wasm_obj.h
index 2c62e0be9..aee78f50a 100644
--- a/src/wcc/wasm_obj.h
+++ b/src/wcc/wasm_obj.h
@@ -38,7 +38,7 @@ enum RelocType {
   R_WASM_GLOBAL_INDEX_LEB      = 7,
   R_WASM_FUNCTION_OFFSET_I32   = 8,
   R_WASM_SECTION_OFFSET_I32    = 9,
-  R_WASM_EVENT_INDEX_LEB       = 10,
+  R_WASM_TAG_INDEX_LEB         = 10,  // R_WASM_EVENT_INDEX_LEB
   R_WASM_GLOBAL_INDEX_I32      = 13,
   R_WASM_MEMORY_ADDR_LEB64     = 14,
   R_WASM_MEMORY_ADDR_SLEB64    = 15,
diff --git a/src/wcc/wcc.h b/src/wcc/wcc.h
index f4ea47af6..7cc43f070 100644
--- a/src/wcc/wcc.h
+++ b/src/wcc/wcc.h
@@ -60,6 +60,12 @@ typedef struct {
   };
 } GVarInfo;
 
+typedef struct {
+  int typeindex;
+  uint32_t index;
+  uint32_t symbol_index;
+} TagInfo;
+
 // traverse
 uint32_t traverse_ast(Vector *decls, Vector *exports, uint32_t stack_size);
 
@@ -125,7 +131,7 @@ enum OutType out_type;
 extern Table func_info_table;
 extern Table gvar_info_table;
 extern Table indirect_function_table;
-extern Vector *tags;  // <int>
+extern Vector *tags;  // <TagInfo*>
 
 #define VERBOSES(str)  do { if (verbose) printf("%s", str); } while (0)
 #define VERBOSE(fmt, ...)  do { if (verbose) printf(fmt, __VA_ARGS__); } while (0)
@@ -134,7 +140,8 @@ uint32_t get_indirect_function_index(const Name *name);
 GVarInfo *register_gvar_info(const Name *name, VarInfo *varinfo);
 GVarInfo *get_gvar_info_from_name(const Name *name);
 int getsert_func_type(unsigned char *buf, size_t size, bool reg);
-int getsert_tag(int typeindex);
+TagInfo *getsert_tag(int typeindex);
+TagInfo *register_longjmp_tag(void);
 
 void write_wasm_header(FILE *ofp);
 
diff --git a/src/wcc/wcc_util.c b/src/wcc/wcc_util.c
index 961c220df..97c525713 100644
--- a/src/wcc/wcc_util.c
+++ b/src/wcc/wcc_util.c
@@ -59,15 +59,29 @@ int getsert_func_type(unsigned char *buf, size_t size, bool reg) {
   return -1;
 }
 
-int getsert_tag(int typeindex) {
-  int len = tags->len;
-  for (int i = 0; i < len; ++i) {
-    int t = VOIDP2INT(tags->data[i]);
-    if (t == typeindex)
-      return i;
+TagInfo *getsert_tag(int typeindex) {
+  uint32_t len = tags->len;
+  for (uint32_t i = 0; i < len; ++i) {
+    TagInfo *t = tags->data[i];
+    if (t->typeindex == typeindex)
+      return t;
   }
-  vec_push(tags, INT2VOIDP(typeindex));
-  return len;
+
+  TagInfo *t = calloc_or_die(sizeof(*t));
+  t->typeindex = typeindex;
+  t->index = len;
+  vec_push(tags, t);
+  return t;
+}
+
+TagInfo *register_longjmp_tag(void) {
+  // Exception type: (void*, int)
+  Vector *params = new_vector();
+  vec_push(params, &tyInt);
+  vec_push(params, &tyVoidPtr);
+  Type *functype = new_func_type(&tyVoid, params, false);
+  int typeindex = getsert_func_type_index(functype, true);
+  return getsert_tag(typeindex);
 }
 
 //