Consistent ordering

Author: rossberg

interpreter/binary/decode.ml

@@ -286,23 +286,23 @@ let limits uN s =
   let max = opt uN has_max s in
   at, {min; max}
 
-let tabletype s =
-  let t = reftype s in
-  let at, lim = limits u64 s in
-  TableT (at, lim, t)
-
-let memorytype s =
-  let at, lim = limits u64 s in
-  MemoryT (at, lim)
+let tagtype s =
+  zero s;
+  TagT (typeuse idx s)
 
 let globaltype s =
   let t = valtype s in
   let mut = mutability s in
   GlobalT (mut, t)
 
-let tagtype s =
-  zero s;
-  TagT (typeuse idx s)
+let memorytype s =
+  let at, lim = limits u64 s in
+  MemoryT (at, lim)
+
+let tabletype s =
+  let t = reftype s in
+  let at, lim = limits u64 s in
+  TableT (at, lim, t)
 
 let externtype s =
   match byte s with
@@ -1052,13 +1052,13 @@ let id s =
     | _ -> error s (pos s) "malformed section id"
     ) bo
 
-let section_with_size tag f default s =
+let section_with_size kind f default s =
   match id s with
-  | Some tag' when tag' = tag -> skip 1 s; sized f s
+  | Some kind' when kind' = kind -> skip 1 s; sized f s
   | _ -> default
 
-let section tag f default s =
-  section_with_size tag (fun _ -> f) default s
+let section kind f default s =
+  section_with_size kind (fun _ -> f) default s
 
 
 (* Type section *)

interpreter/binary/encode.ml

@@ -195,17 +195,17 @@ struct
     let flags = flag (max <> None) 0 + flag (at = I64AT) 2 in
     byte flags; u64 min; opt u64 max
 
-  let tabletype = function
-    | TableT (at, lim, t) -> reftype t; limits at lim
-
-  let memorytype = function
-    | MemoryT (at, lim) -> limits at lim
+  let tagtype = function
+    | TagT ut -> u32 0x00l; typeuse u32 ut
 
   let globaltype = function
     | GlobalT (mut, t) -> valtype t; mutability mut
 
-  let tagtype = function
-    | TagT ut -> u32 0x00l; typeuse u32 ut
+  let memorytype = function
+    | MemoryT (at, lim) -> limits at lim
+
+  let tabletype = function
+    | TableT (at, lim, t) -> reftype t; limits at lim
 
   let externtype = function
     | ExternFuncT ut -> byte 0x00; typeuse u32 ut

interpreter/custom/custom.ml

@@ -7,14 +7,14 @@ type section_kind =
   | Func
   | Table
   | Memory
+  | Tag
   | Global
   | Export
   | Start
   | Elem
   | DataCount
   | Code
   | Data
-  | Tag
 
 type place =
   | Before of section_kind

interpreter/custom/handler_custom.ml

@@ -51,17 +51,17 @@ and parse_annot m annot =
   let place, items'' = parse_place_opt items' in
   let content, items''' = parse_content items'' in
   parse_end items''';
-  let Ast.{types; tags; globals; tables; memories; funcs; start;
-    elems; datas; imports; exports} = m.it in
+  let Ast.{types; tags; globals; memories; tables; funcs; start;
+    datas; elems; imports; exports} = m.it in
   let outside x =
     if annot.at.left >= x.at.left && annot.at.right <= x.at.right then
       parse_error annot.at "misplaced @custom annotation"
   in
   List.iter outside types;
   List.iter outside tags;
   List.iter outside globals;
-  List.iter outside tables;
   List.iter outside memories;
+  List.iter outside tables;
   List.iter outside funcs;
   List.iter outside (Option.to_list start);
   List.iter outside elems;
@@ -97,11 +97,11 @@ and parse_direction at = function
 
 and parse_section at = function
   | {it = Atom "type"; _} :: items -> Type, items
-  | {it = Atom "tag"; _} :: items -> Tag, items
   | {it = Atom "import"; _} :: items -> Import, items
   | {it = Atom "func"; _} :: items -> Func, items
   | {it = Atom "table"; _} :: items -> Table, items
   | {it = Atom "memory"; _} :: items -> Memory, items
+  | {it = Atom "tag"; _} :: items -> Tag, items
   | {it = Atom "global"; _} :: items -> Global, items
   | {it = Atom "export"; _} :: items -> Export, items
   | {it = Atom "start"; _} :: items -> Start, items
@@ -146,11 +146,11 @@ and arrange_place = function
 and arrange_sec = function
   | Custom -> assert false
   | Type -> "type"
-  | Tag -> "tag"
   | Import -> "import"
   | Func -> "func"
   | Table -> "table"
   | Memory -> "memory"
+  | Tag -> "tag"
   | Global -> "global"
   | Export -> "export"
   | Start -> "start"

interpreter/custom/handler_name.ml

@@ -333,18 +333,18 @@ let locate_type bs x name at (ty : type_) =
 let locate_module bs name at (m : module_) =
   if not (is_contained at m.at) then
     parse_error at "misplaced @name annotation";
-  let {types; tags; globals; tables; memories; funcs; start;
-    elems; datas; imports; exports} = m.it in
+  let {types; tags; globals; memories; tables; funcs; start;
+    datas; elems; imports; exports} = m.it in
   let ats =
     List.map (fun p -> p.at) types @
     List.map (fun p -> p.at) tags @
     List.map (fun p -> p.at) globals @
-    List.map (fun p -> p.at) tables @
     List.map (fun p -> p.at) memories @
+    List.map (fun p -> p.at) tables @
     List.map (fun p -> p.at) funcs @
     List.map (fun p -> p.at) (Option.to_list start) @
-    List.map (fun p -> p.at) elems @
     List.map (fun p -> p.at) datas @
+    List.map (fun p -> p.at) elems @
     List.map (fun p -> p.at) imports @
     List.map (fun p -> p.at) exports |> List.sort compare
   in

interpreter/exec/eval.ml

@@ -101,19 +101,19 @@ let lookup category list x =
     Crash.error x.at ("undefined " ^ category ^ " " ^ Int32.to_string x.it)
 
 let type_ (inst : moduleinst) x = lookup "type" inst.types x
-let func (inst : moduleinst) x = lookup "function" inst.funcs x
-let table (inst : moduleinst) x = lookup "table" inst.tables x
-let memory (inst : moduleinst) x = lookup "memory" inst.memories x
 let tag (inst : moduleinst) x = lookup "tag" inst.tags x
 let global (inst : moduleinst) x = lookup "global" inst.globals x
-let elem (inst : moduleinst) x = lookup "element segment" inst.elems x
+let memory (inst : moduleinst) x = lookup "memory" inst.memories x
+let table (inst : moduleinst) x = lookup "table" inst.tables x
+let func (inst : moduleinst) x = lookup "function" inst.funcs x
 let data (inst : moduleinst) x = lookup "data segment" inst.datas x
+let elem (inst : moduleinst) x = lookup "element segment" inst.elems x
 let local (frame : frame) x = lookup "local" frame.locals x
 
 let comp_type (inst : moduleinst) x = expand_deftype (type_ inst x)
-let func_type (inst : moduleinst) x = functype_of_comptype (comp_type inst x)
 let struct_type (inst : moduleinst) x = structtype_of_comptype  (comp_type inst x)
 let array_type (inst : moduleinst) x = arraytype_of_comptype (comp_type inst x)
+let func_type (inst : moduleinst) x = functype_of_comptype (comp_type inst x)
 
 let subst_of (inst : moduleinst) = function
   | Idx x when x < Lib.List32.length inst.types ->
@@ -1190,16 +1190,11 @@ let init_import (inst : moduleinst) (ex : extern) (im : import) : moduleinst =
       "expected " ^ Types.string_of_externtype xt ^
       ", got " ^ Types.string_of_externtype xt');
   match ex with
-  | ExternFunc func -> {inst with funcs = inst.funcs @ [func]}
-  | ExternTable tab -> {inst with tables = inst.tables @ [tab]}
-  | ExternMemory mem -> {inst with memories = inst.memories @ [mem]}
-  | ExternGlobal glob -> {inst with globals = inst.globals @ [glob]}
   | ExternTag tag -> {inst with tags = inst.tags @ [tag]}
-
-let init_func (inst : moduleinst) (f : func) : moduleinst =
-  let Func (x, _, _) = f.it in
-  let func = Func.alloc (type_ inst x) (Lib.Promise.make ()) f in
-  {inst with funcs = inst.funcs @ [func]}
+  | ExternGlobal glob -> {inst with globals = inst.globals @ [glob]}
+  | ExternMemory mem -> {inst with memories = inst.memories @ [mem]}
+  | ExternTable tab -> {inst with tables = inst.tables @ [tab]}
+  | ExternFunc func -> {inst with funcs = inst.funcs @ [func]}
 
 let init_tag (inst : moduleinst) (tag : tag) : moduleinst =
   let Tag tt = tag.it in
@@ -1214,6 +1209,12 @@ let init_global (inst : moduleinst) (glob : global) : moduleinst =
   let glob = Global.alloc gt' v in
   {inst with globals = inst.globals @ [glob]}
 
+let init_memory (inst : moduleinst) (mem : memory) : moduleinst =
+  let Memory mt = mem.it in
+  let mt' = subst_memorytype (subst_of inst) mt in
+  let mem = Memory.alloc mt' in
+  {inst with memories = inst.memories @ [mem]}
+
 let init_table (inst : moduleinst) (tab : table) : moduleinst =
   let Table (tt, c) = tab.it in
   let tt' = subst_tabletype (subst_of inst) tt in
@@ -1225,31 +1226,30 @@ let init_table (inst : moduleinst) (tab : table) : moduleinst =
   let tab = Table.alloc tt' r in
   {inst with tables = inst.tables @ [tab]}
 
-let init_memory (inst : moduleinst) (mem : memory) : moduleinst =
-  let Memory mt = mem.it in
-  let mt' = subst_memorytype (subst_of inst) mt in
-  let mem = Memory.alloc mt' in
-  {inst with memories = inst.memories @ [mem]}
-
-let init_elem (inst : moduleinst) (elem : elem) : moduleinst =
-  let Elem (rt, cs, _emode) = elem.it in
-  let elem = Elem.alloc (List.map (fun c -> as_ref (eval_const inst c)) cs) in
-  {inst with elems = inst.elems @ [elem]}
+let init_func (inst : moduleinst) (f : func) : moduleinst =
+  let Func (x, _, _) = f.it in
+  let func = Func.alloc (type_ inst x) (Lib.Promise.make ()) f in
+  {inst with funcs = inst.funcs @ [func]}
 
 let init_data (inst : moduleinst) (data : data) : moduleinst =
   let Data (bs, _dmode) = data.it in
   let data = Data.alloc bs in
   {inst with datas = inst.datas @ [data]}
 
+let init_elem (inst : moduleinst) (elem : elem) : moduleinst =
+  let Elem (rt, cs, _emode) = elem.it in
+  let elem = Elem.alloc (List.map (fun c -> as_ref (eval_const inst c)) cs) in
+  {inst with elems = inst.elems @ [elem]}
+
 let init_export (inst : moduleinst) (ex : export) : moduleinst =
   let Export (name, xx) = ex.it in
   let ext =
     match xx.it with
-    | FuncX x -> ExternFunc (func inst x)
-    | TableX x -> ExternTable (table inst x)
-    | MemoryX x -> ExternMemory (memory inst x)
-    | GlobalX x -> ExternGlobal (global inst x)
     | TagX x -> ExternTag (tag inst x)
+    | GlobalX x -> ExternGlobal (global inst x)
+    | MemoryX x -> ExternMemory (memory inst x)
+    | TableX x -> ExternTable (table inst x)
+    | FuncX x -> ExternFunc (func inst x)
   in
   {inst with exports = inst.exports @ [(name, ext)]}
 
@@ -1308,18 +1308,18 @@ let init (m : module_) (exts : extern list) : moduleinst =
     empty_moduleinst
     |> init_list init_type m.it.types
     |> init_list2 init_import exts m.it.imports
+    |> init_list init_tag m.it.tags
     |> init_list init_func m.it.funcs
     |> init_list init_global m.it.globals
     |> init_list init_table m.it.tables
     |> init_list init_memory m.it.memories
-    |> init_list init_tag m.it.tags
-    |> init_list init_elem m.it.elems
     |> init_list init_data m.it.datas
+    |> init_list init_elem m.it.elems
     |> init_list init_export m.it.exports
   in
   List.iter (init_funcinst inst) inst.funcs;
-  let es_elem = List.concat (Lib.List32.mapi run_elem m.it.elems) in
   let es_data = List.concat (Lib.List32.mapi run_data m.it.datas) in
+  let es_elem = List.concat (Lib.List32.mapi run_elem m.it.elems) in
   let es_start = Lib.Option.get (Lib.Option.map run_start m.it.start) [] in
   ignore (eval (config inst [] (List.map plain (es_elem @ es_data @ es_start))));
   inst

interpreter/runtime/instance.ml

@@ -3,32 +3,32 @@ open Types
 type moduleinst =
 {
   types : typeinst list;
-  funcs : funcinst list;
-  tables : tableinst list;
-  memories : memoryinst list;
-  globals : globalinst list;
   tags : taginst list;
-  elems : eleminst list;
+  globals : globalinst list;
+  memories : memoryinst list;
+  tables : tableinst list;
+  funcs : funcinst list;
   datas : datainst list;
+  elems : eleminst list;
   exports : exportinst list;
 }
 
 and typeinst = deftype
-and funcinst = moduleinst Lib.Promise.t Func.t
-and tableinst = Table.t
-and memoryinst = Memory.t
-and globalinst = Global.t
 and taginst = Tag.t
-and eleminst = Elem.t
+and globalinst = Global.t
+and memoryinst = Memory.t
+and tableinst = Table.t
+and funcinst = moduleinst Lib.Promise.t Func.t
 and datainst = Data.t
+and eleminst = Elem.t
 and exportinst = Ast.name * extern
 
 and extern =
-  | ExternFunc of funcinst
-  | ExternTable of tableinst
-  | ExternMemory of memoryinst
-  | ExternGlobal of globalinst
   | ExternTag of taginst
+  | ExternGlobal of globalinst
+  | ExternMemory of memoryinst
+  | ExternTable of tableinst
+  | ExternFunc of funcinst
 
 
 (* Reference types *)
@@ -57,25 +57,25 @@ let () =
 
 (* Projections *)
 
-let funcinst_of_extern = function ExternFunc f -> f | _ -> failwith "funcinst_of_extern"
-let tableinst_of_extern = function ExternTable t -> t | _ -> failwith "tableinst_of_extern"
-let memoryinst_of_extern = function ExternMemory m -> m | _ -> failwith "memoryinst_of_extern"
-let globalinst_of_extern = function ExternGlobal g -> g | _ -> failwith "globalinst_of_extern"
 let taginst_of_extern = function ExternTag t -> t | _ -> failwith "taginst_of_extern"
+let globalinst_of_extern = function ExternGlobal g -> g | _ -> failwith "globalinst_of_extern"
+let memoryinst_of_extern = function ExternMemory m -> m | _ -> failwith "memoryinst_of_extern"
+let tableinst_of_extern = function ExternTable t -> t | _ -> failwith "tableinst_of_extern"
+let funcinst_of_extern = function ExternFunc f -> f | _ -> failwith "funcinst_of_extern"
 
 
 (* Auxiliary functions *)
 
 let empty_moduleinst =
-  { types = []; funcs = []; tables = []; memories = []; globals = [];
-    tags = []; elems = []; datas = []; exports = [] }
+  { types = []; tags = []; globals = []; memories = []; tables = []; funcs = [];
+    datas = []; elems = []; exports = [] }
 
 let externtype_of c = function
-  | ExternFunc func -> ExternFuncT (Def (Func.type_of func))
-  | ExternTable tab -> ExternTableT (Table.type_of tab)
-  | ExternMemory mem -> ExternMemoryT (Memory.type_of mem)
-  | ExternGlobal glob -> ExternGlobalT (Global.type_of glob)
   | ExternTag tag -> ExternTagT (Tag.type_of tag)
+  | ExternGlobal glob -> ExternGlobalT (Global.type_of glob)
+  | ExternMemory mem -> ExternMemoryT (Memory.type_of mem)
+  | ExternTable tab -> ExternTableT (Table.type_of tab)
+  | ExternFunc func -> ExternFuncT (Def (Func.type_of func))
 
 let export inst name =
   try Some (List.assoc name inst.exports) with Not_found -> None