Output relocation for table index

  * Add relocation types:
    * R_WASM_MEMORY_ADDR_SLEB
    * R_WASM_TABLE_NUMBER_LEB
  * Relocation type for `i32.const` is `sleb`
  * Handle multiple output for same function (`main`)

Author: tyfkda

src/_debug/wcc-ld.c

@@ -13,6 +13,7 @@
 static void init(void) {
   functypes = new_vector();
   tags = new_vector();
+  tables = new_vector();
   table_init(&indirect_function_table);
 }
 

src/util/util.c

@@ -538,6 +538,16 @@ void data_string(DataStorage *data, const void *str, size_t len) {
   data_append(data, (const unsigned char*)str, len);
 }
 
+void data_varint32(DataStorage *data, ssize_t pos, int64_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_varuint32(DataStorage *data, ssize_t pos, uint64_t val) {
   unsigned char buf[5], *p = buf;
   for (int i = 0; i < 4; ++i) {

src/util/util.h

@@ -98,6 +98,7 @@ 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_varint32(DataStorage *data, ssize_t pos, int64_t val);
 void data_varuint32(DataStorage *data, ssize_t pos, uint64_t val);
 
 // StringBuffer

src/wcc/emit_wasm.c

@@ -264,15 +264,17 @@ static void emit_import_section(EmitWasm *ew) {
     data_uleb128(&imports_section, -1, 0);  // size
     ++imports_count;
   }
-  if (indirect_function_table.count > 0 || (compile_unit_flag & CUF_INDIRECT_CALL)) {
-    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, INDIRECT_FUNCTION_TABLE_START_INDEX);  // initial
-    ++imports_count;
+  if (tables->len > 0) {
+    for (int i = 0; i < tables->len; ++i) {
+      TableInfo *t = tables->data[i];
+      data_string(&imports_section, env_module_name, sizeof(env_module_name) - 1);  // import module name
+      data_string(&imports_section, t->name->chars, t->name->bytes);  // import name
+      data_push(&imports_section, IMPORT_TABLE);  // import kind
+      data_push(&imports_section, t->type);
+      data_push(&imports_section, 0x00);  // limits: flags
+      data_leb128(&imports_section, -1, INDIRECT_FUNCTION_TABLE_START_INDEX);  // initial
+      ++imports_count;
+    }
   }
 
   {
@@ -655,6 +657,16 @@ static void emit_linking_section(EmitWasm *ew) {
       ++count;
     }
   }
+  if (tables->len > 0) {  // Table
+    for (int i = 0, len = tables->len; i < len; ++i) {
+      TableInfo *ti = tables->data[i];
+      int flags = WASM_SYM_UNDEFINED | WASM_SYM_EXPORTED | WASM_SYM_NO_STRIP;
+      data_push(&linking_section, SIK_SYMTAB_TABLE);  // kind
+      data_uleb128(&linking_section, -1, flags);
+      data_uleb128(&linking_section, -1, ti->index);
+      ++count;
+    }
+  }
   if (tags->len > 0) {  // Tag
     for (int i = 0, len = tags->len; i < len; ++i) {
       TagInfo *ti = tags->data[i];
@@ -739,13 +751,15 @@ static void emit_reloc_section(EmitWasm *ew, int section_index, Vector *relocs,
       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;
+      case R_WASM_MEMORY_ADDR_SLEB:
+      case R_WASM_MEMORY_ADDR_SLEB64:
         data_leb128(&ds, -1, reloc->addend);
         break;
       default: break;

src/wcc/gen_wasm.c

@@ -27,6 +27,7 @@
 
 #define ADD_LEB128(x)  data_leb128(CODE, -1, x)
 #define ADD_ULEB128(x) data_uleb128(CODE, -1, x)
+#define ADD_VARINT32(x)   data_varint32(CODE, -1, x)
 #define ADD_VARUINT32(x)  data_varuint32(CODE, -1, x)
 
 // TODO: Endian.
@@ -389,19 +390,29 @@ static void gen_funcall(Expr *expr) {
     gen_funcall_by_name(func->var.name);
   } else {
     gen_expr(func, true);
-    int index = get_func_type_index(functype);
-    assert(index >= 0);
     ADD_CODE(OP_CALL_INDIRECT);
+
     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
+    {
+      int index = get_func_type_index(functype);
+      assert(index >= 0);
+      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);
+    }
+    {
+      TableInfo *ti = getsert_indirect_function_table();
+      RelocInfo *ri = calloc_or_die(sizeof(*ri));
+      ri->type = R_WASM_TABLE_NUMBER_LEB;
+      ri->index = ti->symbol_index;
+      ri->offset = code->len;
+      vec_push(extra->reloc_code, ri);
+      ADD_VARUINT32(ti->index);  // table index
+    }
   }
 }
 
@@ -459,21 +470,21 @@ static void gen_ref_sub(Expr *expr) {
           ri->index = info->index;  // Assume that symtab index is same as function index.
           vec_push(extra->reloc_code, ri);
 
-          ADD_VARUINT32(info->indirect_index);
+          ADD_VARINT32(info->indirect_index);
         } else {
           GVarInfo *info = get_gvar_info(expr);
           assert(info != NULL);
           ADD_CODE(OP_I32_CONST);
           FuncExtra *extra = curfunc->extra;
           DataStorage *code = extra->code;
           RelocInfo *ri = calloc_or_die(sizeof(*ri));
-          ri->type = R_WASM_MEMORY_ADDR_LEB;
+          ri->type = R_WASM_MEMORY_ADDR_SLEB;
           ri->offset = code->len;
           ri->addend = 0;
           ri->index = info->symbol_index;
           vec_push(extra->reloc_code, ri);
 
-          ADD_VARUINT32(info->non_prim.address);
+          ADD_VARINT32(info->non_prim.address);
         }
       } else {
         VReg *vreg = varinfo->local.vreg;

src/wcc/traverse.c

@@ -130,6 +130,7 @@ static uint32_t register_indirect_function(const Name *name) {
   info = register_func_info(name, NULL, NULL, FF_INDIRECT | FF_REFERRED);
   uint32_t index = indirect_function_table.count;
   table_put(&indirect_function_table, name, info);
+  getsert_indirect_function_table();
   return index;
 }
 
@@ -208,7 +209,7 @@ static void traverse_func_expr(Expr **pexpr) {
     assert(type != NULL && type->kind == TY_FUNC);
     getsert_func_type_index(type, true);
     traverse_expr(pexpr, true);
-    compile_unit_flag |= CUF_INDIRECT_CALL;
+    getsert_indirect_function_table();
   }
 }
 
@@ -958,6 +959,12 @@ void traverse_ast(Vector *decls) {
       }
     }
 
+    // Table
+    for (int i = 0, len = tables->len; i < len; ++i) {
+      TableInfo *ti = tables->data[i];
+      ti->symbol_index = symbol_index++;
+    }
+
     // Tag
     for (int i = 0, len = tags->len; i < len; ++i) {
       TagInfo *ti = tags->data[i];