mo-ld: Implement GOT.func imports

Fixes #1810

Author: osa1

rts/char.c

@@ -20,6 +20,18 @@ export int32_t char_to_lower(int32_t c) {
     return musl_fn((unsigned)c) != 0; \
   }
 
+__attribute__ ((visibility("default")))
+int c_fn_2(int x, int y)
+{
+    return x + y;
+}
+
+__attribute__ ((visibility("default")))
+int (*c_fn(void)) (int x, int y)
+{
+    return &c_fn_2;
+}
+
 CHAR_PRED(char_is_whitespace, iswspace)
 CHAR_PRED(char_is_uppercase, iswupper)
 CHAR_PRED(char_is_lowercase, iswlower)

src/lib/lib.ml

@@ -264,6 +264,21 @@ struct
     then (take n xs, drop n xs)
     else (xs, [])
 
+  let rec init_ xs =
+    match xs with
+    | [] -> []
+    | [_] -> []
+    | x :: xs -> x :: init_ xs
+
+  let init xs =
+    match xs with
+    | [] -> failwith "init -- empty list"
+    | _ -> init_ xs
+
+  let null = function
+    | [] -> true
+    | _ :: _ -> false
+
   let hd_opt = function
     | x :: _ -> Some x
     | _ -> None

src/lib/lib.mli

@@ -18,6 +18,9 @@ sig
   val take : int -> 'a list -> 'a list (* raises Failure *)
   val drop : int -> 'a list -> 'a list (* raises Failure *)
   val split_at : int -> 'a list -> ('a list * 'a list)
+  val init : 'a list -> 'a list (* raises Failure when the list is empty *)
+  val init_ : 'a list -> 'a list (* like init, but returns empty when the list is empty *)
+  val null : 'a list -> bool
 
   val hd_opt : 'a list -> 'a option
   val last : 'a list -> 'a (* raises Failure *)

src/linking/linkModule.ml

@@ -18,6 +18,78 @@ through further refactoring before we are happy with it. Things to do:
    of functions for each syntactic category.
 *)
 
+(*
+Resolving GOT.func and GOT.mem imports
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+GOT.func and GOT.mem imports arise from function and data pointers,
+respectively, in languages with pointers (e.g. C and Rust). The idea is that if
+a shared library exposes a function/data pointer the entire process should use
+the same pointer for the function/data so that the pointer arithmetic and
+comparisons will work. For example, this C code:
+
+    __attribute__ ((visibility("default")))
+    int f0(int x, int y)
+    {
+        return x + y;
+    }
+
+    __attribute__ ((visibility("default")))
+    int (\*f1(void)) (int x, int y)
+    {
+        return &f0;
+    }
+
+generates this GOT.func import:
+
+    (import "GOT.func" "f0" (global (;N;) (mut i32)))
+
+The host is responsible of allocating a table index for this function and
+resolving the import to the table index for `f0` so that this code in the
+importing module would work:
+
+    assert(f1() == f0);
+
+Note that the definition of `f1` is in the *imported* module and this assertion
+is in the *importing* module.
+
+Similarly exposing a data pointer generates a GOT.mem import. All GOT.mem
+imports to a symbol should resolve to the same constant to support equality as
+above, and additionally pointer arithmetic.
+
+(Pointer arithmetic on function pointers are undefined behavior is C and is not
+supported by clang's wasm backend)
+
+Normally this stuff is for dynamic linking, but we want to link the RTS
+statically, so we resolve these imports during linking. Currently we only
+support GOT.func imports, but implementing GOT.mem imports would be similar.
+Secondly, we only support GOT.func imports in the module that defines the
+function that we take the address of. This currently works as moc-generated code
+doesn't import function addresses from the RTS.
+
+We resolve GOT.func imports in two steps:
+
+- After loading the RTS module we generate a list of (global index, function
+  index) pairs of GOT.func imports. In the example above, global index is N and
+  function index is the index of f0 in the defining module (the RTS).
+
+  This is implemented in `collect_got_func_imports`.
+
+- After merging the sections we add the functions to the table and replace
+  `GOT.func` imports with globals to the functions' table indices.
+
+  Note that we don't reuse table entries when a function is already in the
+  table, to avoid breakage when [ref-types] proposal is implemented, which will
+  allow mutating table entries.
+
+  [ref-types]: https://github.com/WebAssembly/reference-types
+
+  This is implemented in `replace_got_func_imports`.
+
+See also the test `test/ld/fun-ptr` for a concrete exaple of GOT.func generation
+and resolving.
+*)
+
 (* Linking *)
 
 type imports = (int32 * name) list
@@ -64,7 +136,8 @@ let remove_imports is_thing resolved : module_' -> module_' = fun m ->
         if List.mem_assoc i resolved
         then go (Int32.add i 1l) is
         else imp :: go (Int32.add i 1l) is
-      else imp :: go i is in
+      else imp :: go i is
+  in
   { m with imports = go 0l m.imports }
 
 let count_imports is_thing m =
@@ -191,7 +264,7 @@ let remove_non_ic_exports (em : extended_module) : extended_module =
   let keep_export exp =
     is_ic_export exp ||
     match exp.it.edesc.it with
-      | FuncExport var -> false
+      | FuncExport _ -> false
       | GlobalExport _ -> false
       | MemoryExport _ -> true
       | TableExport _ -> true in
@@ -211,7 +284,7 @@ let resolve imports exports : (int32 * int32) list =
     | None -> []
     ) imports)
 
-let calculate_renaming n_imports1 n_things1 n_imports2 n_things2 resolved12 resolved21 : (renumbering * renumbering) =
+let calculate_renaming n_imports1 n_things1 n_imports2 resolved12 resolved21 : (renumbering * renumbering) =
   let open Int32 in
 
   let n_imports1' = sub n_imports1 (Lib.List32.length resolved12) in
@@ -228,6 +301,7 @@ let calculate_renaming n_imports1 n_things1 n_imports2 n_things2 resolved12 reso
         then sub i skipped
         else sub (add i n_imports2') skipped
     in go 0l resolved12
+
   and fun2 i =
     let rec go skipped = function
       | (imp, exp)::is ->
@@ -240,6 +314,7 @@ let calculate_renaming n_imports1 n_things1 n_imports2 n_things2 resolved12 reso
         else sub (add (add i n_imports1') n_things1) skipped
     in go 0l resolved21
   in
+
   (fun1, fun2)
 
 
@@ -575,10 +650,117 @@ let align p n =
   let p = to_int p in
   shift_left (shift_right_logical (add n (sub (shift_left 1l p) 1l)) p) p
 
+let find_fun_export (name : name) (exports : export list) : var option =
+  Lib.List.first_opt (fun (export : export) ->
+    if export.it.name = name then
+      match export.it.edesc.it with
+      | FuncExport var -> Some var
+      | _ -> raise (LinkError (Format.sprintf "Export %s is not a function" (Wasm.Utf8.encode name)))
+    else
+      None
+  ) exports
+
+let remove_got_func_imports (imports : import list) : import list =
+  let got_func_str = Wasm.Utf8.decode "GOT.func" in
+  List.filter (fun import -> import.it.module_name <> got_func_str) imports
+
+(* Merge global list of a module with a sorted (on global index) list of (global
+   index, global) pairs, overriding globals at those indices, and appending
+   left-overs at the end. *)
+let add_globals (globals0 : global list) (insert0 : (int32 * global') list) : global list =
+  let rec go (current_idx : int32) globals insert =
+    match insert with
+    | [] -> globals
+    | (insert_idx, global) :: rest ->
+      if current_idx = insert_idx then
+        (global @@ no_region) :: go (Int32.add current_idx 1l) globals rest
+      else
+        match globals with
+        | [] -> List.map (fun (_, global) -> global @@ no_region) insert
+        | global :: globals -> global :: go (Int32.add current_idx 1l) globals rest
+  in
+  go 0l globals0 insert0
+
+let mk_i32_const (i : int32) =
+  Const (Wasm.Values.I32 i @@ no_region) @@ no_region
+
+let mk_i32_global (i : int32) =
+  { gtype = Wasm.Types.GlobalType (Wasm.Types.I32Type, Wasm.Types.Immutable);
+    value = [mk_i32_const i] @@ no_region }
+
+(* Generate (global index, function index) pairs for GOT.func imports of a
+   module. Uses import and export lists of the module so those should be valid. *)
+let collect_got_func_imports (m : module_') : (int32 * int32) list =
+  let got_func_name = Wasm.Utf8.decode "GOT.func" in
+
+  let get_got_func_import (global_idx, imports) import : (int32 * (int32 * int32) list) =
+    if import.it.module_name = got_func_name then
+      (* Found a GOT.func import, find the exported function for it *)
+      let name = import.it.item_name in
+      let fun_idx =
+        match find_fun_export name m.exports with
+        | None -> raise (LinkError (Format.sprintf "Can't find export for GOT.func import %s" (Wasm.Utf8.encode name)))
+        | Some export_idx -> export_idx.it
+      in
+      let global_idx =
+        if is_global_import import.it.idesc.it then
+          global_idx
+        else
+          raise (LinkError "GOT.func import is not global")
+      in
+      ( Int32.add global_idx (Int32.of_int 1), (global_idx, fun_idx) :: imports )
+    else
+      let global_idx =
+        if is_global_import import.it.idesc.it then
+          Int32.add global_idx (Int32.of_int 1)
+        else
+          global_idx
+      in
+      ( global_idx, imports )
+  in
+
+  (* (global index, function index) list *)
+  let (_, got_func_imports) =
+    List.fold_left get_got_func_import (0l, []) m.imports
+  in
+
+  got_func_imports
+
+(* Add functions imported from GOT.func to the table, replace GOT.func imports
+   with globals to the table indices.
+
+   `tbe_size` is the size of the table in the merged module before adding
+   GOT.func functions. *)
+let replace_got_func_imports (tbl_size : int32) (imports : (int32 * int32) list) (m : module_') : module_' =
+  (* null check to avoid adding empty elem section *)
+  if Lib.List.null imports then
+    m
+  else
+    let imports =
+      List.sort (fun (gbl_idx_1, _) (gbl_idx_2, _) -> compare gbl_idx_1 gbl_idx_2) imports
+    in
+
+    let elems : var list =
+      List.map (fun (_, fun_idx) -> fun_idx @@ no_region) imports
+    in
+
+    let elem_section =
+      { index = 0l @@ no_region; offset = [ mk_i32_const tbl_size ] @@ no_region; init = elems }
+    in
+
+    let globals =
+      List.mapi (fun idx (global_idx, _) -> (global_idx, mk_i32_global (Int32.add tbl_size (Int32.of_int idx)))) imports
+    in
+
+    { m with
+      elems = List.append m.elems [elem_section @@ no_region];
+      imports = remove_got_func_imports m.imports;
+      globals = add_globals m.globals globals
+    }
+
 (* The first argument specifies the global of the first module indicating the
 start of free memory *)
 let link (em1 : extended_module) libname (em2 : extended_module) =
-
   let global_exports1 = find_exports is_global_export em1.module_ in
 
   let heap_global =
@@ -595,14 +777,15 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   let lib_heap_start = align dylink.memory_alignment old_heap_start in
   let new_heap_start = align 4l (Int32.add lib_heap_start dylink.memory_size) in
 
-  let old_elem_size = read_table_size em1.module_ in
-  let lib_elem_start = align dylink.table_alignment old_elem_size in
-  let new_elem_size = Int32.add lib_elem_start dylink.table_size in
+  let old_table_size = read_table_size em1.module_ in
+  let lib_table_start = align dylink.table_alignment old_table_size in
 
-  (* Fill in memory base pointer  *)
+  (* Fill in memory and table base pointers *)
   let dm2 = em2.module_
     |> fill_memory_base_import lib_heap_start
-    |> fill_table_base_import lib_elem_start in
+    |> fill_table_base_import lib_table_start in
+
+  let got_func_imports = collect_got_func_imports dm2 in
 
   (* Link functions *)
   let fun_required1 = find_imports is_fun_import libname em1.module_ in
@@ -617,7 +800,6 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
       (count_imports is_fun_import em1.module_)
       (Lib.List32.length em1.module_.funcs)
       (count_imports is_fun_import dm2)
-      (Lib.List32.length dm2.funcs)
       fun_resolved12
       fun_resolved21 in
 
@@ -626,7 +808,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
 
   (* Link globals *)
   let global_required1 = find_imports is_global_import libname em1.module_ in
-  let global_required2 = find_imports is_global_import  "env" dm2 in
+  let global_required2 = find_imports is_global_import "env" dm2 in
   let global_exports2 = find_exports is_global_export dm2 in
   (* Resolve imports, to produce a renumbering globalction: *)
   let global_resolved12 = resolve global_required1 global_exports2 in
@@ -636,7 +818,6 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
       (count_imports is_global_import em1.module_)
       (Lib.List32.length em1.module_.globals)
       (count_imports is_global_import dm2)
-      (Lib.List32.length dm2.globals)
       global_resolved12
       global_resolved21 in
   assert (global_required1 = []); (* so far, we do not import globals *)
@@ -673,7 +854,7 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
   in
 
   (* Rename types in second module *)
-  let dm2_tys =
+  let dm2 =
     { (rename_types (ty_renamer dm2.types) dm2) with types = [] }
   in
 
@@ -692,9 +873,13 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     | Some fi -> prepend_to_start (funs2 fi) (add_or_get_ty (Wasm.Types.FuncType ([], [])))
   in
 
-  assert (dm2_tys.globals = []);
+  assert (dm2.globals = []);
+
+  let new_table_size =
+    Int32.add (Int32.add lib_table_start dylink.table_size) (Int32.of_int (List.length got_func_imports))
+  in
 
-  join_modules
+  let merged = join_modules
     ( em1_tys
     |> map_module (fun m -> { m with types = type_indices_sorted })
     |> map_module (remove_imports is_fun_import fun_resolved12)
@@ -704,9 +889,9 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     |> rename_globals_extended globals1
     |> map_module (set_global heap_global new_heap_start)
     |> map_module (set_memory_size new_heap_start)
-    |> map_module (set_table_size new_elem_size)
+    |> map_module (set_table_size new_table_size)
     )
-    ( dm2_tys
+    ( dm2
     |> remove_imports is_fun_import fun_resolved21
     |> remove_imports is_global_import global_resolved21
     |> remove_imports is_memory_import [0l, 0l]
@@ -721,3 +906,16 @@ let link (em1 : extended_module) libname (em2 : extended_module) =
     )
   |> add_call_ctors
   |> remove_non_ic_exports (* only sane if no additional files get linked in *)
+  in
+
+  (* Rename global and function indices in GOT.func stuff *)
+  let got_func_imports =
+    List.map (fun (global_idx, func_idx) -> (globals2 global_idx, funs2 func_idx)) got_func_imports
+  in
+
+  (* Replace GOT.func imports with globals to function table indices *)
+  let final =
+    replace_got_func_imports (Int32.add lib_table_start dylink.table_size) got_func_imports merged.module_
+  in
+
+  { merged with module_ = final }