Remove code corresponding to an hypothetical core Wasm support

Author: vouillon

compiler/lib/wasm/wa_asm_output.ml

@@ -18,10 +18,6 @@
 
 type var = Code.Var.t
 
-type symbol =
-  | V of var
-  | S of string
-
 type packed_type =
   | I8
   | I16
@@ -137,23 +133,18 @@ type memarg = int32
 
 type expression =
   | Const of (int32, int64, float, float) op
-  | ConstSym of symbol * int
   | UnOp of (int_un_op, int_un_op, float_un_op, float_un_op) op * expression
   | BinOp of
       (int_bin_op, int_bin_op, float_bin_op, float_bin_op) op * expression * expression
   | I32WrapI64 of expression
   | I64ExtendI32 of signage * expression
   | F32DemoteF64 of expression
   | F64PromoteF32 of expression
-  | Load of (memarg, memarg, memarg, memarg) op * expression
-  | Load8 of signage * (memarg, memarg, memarg, memarg) op * expression
   | LocalGet of var
   | LocalTee of var * expression
-  | GlobalGet of symbol
+  | GlobalGet of var
   | BlockExpr of func_type * instruction list
-  | Call_indirect of func_type * expression * expression list
   | Call of var * expression list
-  | MemoryGrow of int * expression
   | Seq of instruction list * expression
   | Pop of value_type
   | RefFunc of var
@@ -177,10 +168,8 @@ type expression =
 
 and instruction =
   | Drop of expression
-  | Store of (memarg, memarg, memarg, memarg) op * expression * expression
-  | Store8 of (memarg, memarg, memarg, memarg) op * expression * expression
   | LocalSet of var * expression
-  | GlobalSet of symbol * expression
+  | GlobalSet of var * expression
   | Loop of func_type * instruction list
   | Block of func_type * instruction list
   | If of func_type * expression * instruction list * instruction list
@@ -200,7 +189,6 @@ and instruction =
   | Rethrow of int
   | ArraySet of var * expression * expression * expression
   | StructSet of var * int * expression * expression
-  | Return_call_indirect of func_type * expression * expression list
   | Return_call of var * expression list
   | Return_call_ref of var * expression * expression list
   | Location of Code.loc * instruction
@@ -211,14 +199,6 @@ type import_desc =
   | Global of global_type
   | Tag of value_type
 
-type data =
-  | DataI8 of int
-  | DataI32 of int32
-  | DataI64 of int64
-  | DataBytes of string
-  | DataSym of symbol * int
-  | DataSpace of int
-
 type type_field =
   { name : var
   ; typ : str_type
@@ -237,12 +217,10 @@ type module_field =
       }
   | Data of
       { name : var
-      ; active : bool
-      ; read_only : bool
-      ; contents : data list
+      ; contents : string
       }
   | Global of
-      { name : symbol
+      { name : var
       ; exported_name : string option
       ; typ : global_type
       ; init : expression

compiler/lib/wasm/wa_asm_output.mli

@@ -38,7 +38,7 @@ type constant_global =
 
 type context =
   { constants : (Var.t, W.expression) Hashtbl.t
-  ; mutable data_segments : (bool * W.data list) Var.Map.t
+  ; mutable data_segments : string Var.Map.t
   ; mutable constant_globals : constant_global Var.Map.t
   ; mutable other_fields : W.module_field list
   ; mutable imports : (Var.t * Wa_ast.import_desc) StringMap.t StringMap.t
@@ -119,12 +119,10 @@ let expression_list f l =
   in
   loop [] l
 
-let register_data_segment x ~active v st =
-  st.context.data_segments <- Var.Map.add x (active, v) st.context.data_segments;
+let register_data_segment x v st =
+  st.context.data_segments <- Var.Map.add x v st.context.data_segments;
   (), st
 
-let get_data_segment x st = Var.Map.find x st.context.data_segments, st
-
 let get_context st = st.context, st
 
 let register_constant x e st =
@@ -180,16 +178,13 @@ let heap_type_sub (ty : W.heap_type) (ty' : W.heap_type) st =
 let register_global name ?exported_name ?(constant = false) typ init st =
   st.context.other_fields <-
     W.Global { name; exported_name; typ; init } :: st.context.other_fields;
-  (match name with
-  | S _ -> ()
-  | V name ->
-      st.context.constant_globals <-
-        Var.Map.add
-          name
-          { init = (if not typ.mut then Some init else None)
-          ; constant = (not typ.mut) || constant
-          }
-          st.context.constant_globals);
+  st.context.constant_globals <-
+    Var.Map.add
+      name
+      { init = (if not typ.mut then Some init else None)
+      ; constant = (not typ.mut) || constant
+      }
+      st.context.constant_globals;
   (), st
 
 let global_is_registered name =
@@ -331,8 +326,6 @@ module Arith = struct
       | W.Const (I32 n), W.Const (I32 n') -> W.Const (I32 (Int32.add n n'))
       | W.Const (I32 0l), _ -> e'
       | _, W.Const (I32 0l) -> e
-      | W.ConstSym (sym, offset), W.Const (I32 n) ->
-          W.ConstSym (sym, offset + Int32.to_int n)
       | W.Const _, _ -> W.BinOp (I32 Add, e', e)
       | _ -> W.BinOp (I32 Add, e, e'))
 
@@ -407,8 +400,8 @@ end
 
 let is_small_constant e =
   match e with
-  | W.ConstSym _ | W.Const _ | W.RefI31 (W.Const _) | W.RefFunc _ -> return true
-  | W.GlobalGet (V name) -> global_is_constant name
+  | W.Const _ | W.RefI31 (W.Const _) | W.RefFunc _ -> return true
+  | W.GlobalGet name -> global_is_constant name
   | _ -> return false
 
 let un_op_is_smi op =
@@ -430,21 +423,16 @@ let rec is_smi e =
   | I31Get (S, _) -> true
   | I31Get (U, _)
   | Const (I64 _ | F32 _ | F64 _)
-  | ConstSym _
   | UnOp ((F32 _ | F64 _), _)
   | I32WrapI64 _
   | I64ExtendI32 _
   | F32DemoteF64 _
   | F64PromoteF32 _
-  | Load _
-  | Load8 _
   | LocalGet _
   | LocalTee _
   | GlobalGet _
   | BlockExpr _
-  | Call_indirect _
   | Call _
-  | MemoryGrow _
   | Seq _
   | Pop _
   | RefFunc _
@@ -526,12 +514,12 @@ let rec store ?(always = false) ?typ x e =
             else
               register_global
                 ~constant:true
-                (V x)
+                x
                 { mut = true; typ }
                 (W.RefI31 (Const (I32 0l)))
           in
-          let* () = register_constant x (W.GlobalGet (V x)) in
-          instr (GlobalSet (V x, e))
+          let* () = register_constant x (W.GlobalGet x) in
+          instr (GlobalSet (x, e))
         else
           let* i = add_var ?typ x in
           instr (LocalSet (i, e))

compiler/lib/wasm/wa_ast.ml

@@ -22,7 +22,7 @@ type constant_global
 
 type context =
   { constants : (Code.Var.t, Wa_ast.expression) Hashtbl.t
-  ; mutable data_segments : (bool * Wa_ast.data list) Code.Var.Map.t
+  ; mutable data_segments : string Code.Var.Map.t
   ; mutable constant_globals : constant_global Code.Var.Map.t
   ; mutable other_fields : Wa_ast.module_field list
   ; mutable imports : (Code.Var.t * Wa_ast.import_desc) StringMap.t StringMap.t
@@ -154,7 +154,7 @@ val register_import :
   ?import_module:string -> name:string -> Wa_ast.import_desc -> Wa_ast.var t
 
 val register_global :
-     Wa_ast.symbol
+     Wa_ast.var
   -> ?exported_name:string
   -> ?constant:bool
   -> Wa_ast.global_type
@@ -163,9 +163,7 @@ val register_global :
 
 val get_global : Code.Var.t -> Wa_ast.expression option t
 
-val register_data_segment : Code.Var.t -> active:bool -> Wa_ast.data list -> unit t
-
-val get_data_segment : Code.Var.t -> (bool * Wa_ast.data list) t
+val register_data_segment : Code.Var.t -> string -> unit t
 
 val register_init_code : unit t -> unit t