add link-dl-openable component test and make output deterministic

dicej · dicej · commit 7681a9354740 · 2023-08-08T09:52:14.000-06:00
Signed-off-by: Joel Dice &lt;joel.dice@fermyon.com&gt;
diff --git a/crates/wit-component/src/linking.rs b/crates/wit-component/src/linking.rs
@@ -28,7 +28,7 @@ use {
     indexmap::IndexSet,
     metadata::{Export, FunctionType, GlobalType, Metadata, Type, ValueType},
     std::{
-        collections::{hash_map::Entry, BTreeMap, BTreeSet, HashMap, HashSet},
+        collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},
         iter,
     },
     wasm_encoder::{
@@ -1249,27 +1249,20 @@ impl Linker {
                         name: format!("{name}:table_base"),
                     },
                 ])
-                .chain(
-                    metadata
-                        .env_imports
-                        .iter()
-                        .collect::<BTreeSet<_>>()
-                        .into_iter()
-                        .map(|(name, ty)| {
-                            let exporter = find_function_exporter(name, ty, &exporters).unwrap();
-
-                            Item {
-                                alias: (*name).into(),
-                                kind: ExportKind::Func,
-                                which: if seen.contains(exporter) {
-                                    MainOrAdapter::Adapter(exporter.to_owned())
-                                } else {
-                                    MainOrAdapter::Main
-                                },
-                                name: (*name).into(),
-                            }
-                        }),
-                )
+                .chain(metadata.env_imports.iter().map(|(name, ty)| {
+                    let exporter = find_function_exporter(name, ty, &exporters).unwrap();
+
+                    Item {
+                        alias: (*name).into(),
+                        kind: ExportKind::Func,
+                        which: if seen.contains(exporter) {
+                            MainOrAdapter::Adapter(exporter.to_owned())
+                        } else {
+                            MainOrAdapter::Main
+                        },
+                        name: (*name).into(),
+                    }
+                }))
                 .collect();
 
             let global_item = |address_name: &str| Item {
@@ -1282,8 +1275,6 @@ impl Linker {
             let mem_items = metadata
                 .memory_address_imports
                 .iter()
-                .collect::<BTreeSet<_>>()
-                .into_iter()
                 .copied()
                 .map(global_item)
                 .chain(["__heap_base", "__heap_end"].into_iter().map(|name| Item {
@@ -1297,8 +1288,6 @@ impl Linker {
             let func_items = metadata
                 .table_address_imports
                 .iter()
-                .collect::<BTreeSet<_>>()
-                .into_iter()
                 .copied()
                 .map(global_item)
                 .collect();
diff --git a/crates/wit-component/src/linking/metadata.rs b/crates/wit-component/src/linking/metadata.rs
@@ -3,7 +3,7 @@
 
 use {
     anyhow::{bail, Context, Error, Result},
-    std::collections::HashSet,
+    std::collections::{BTreeSet, HashSet},
     wasmparser::{
         BinaryReader, BinaryReaderError, ExternalKind, FuncType, Parser, Payload, RefType,
         StructuralType, Subsection, Subsections, TableType, TypeRef, ValType,
@@ -76,14 +76,14 @@ impl TryFrom<&FuncType> for FunctionType {
 }
 
 /// Represents a core Wasm global variable type
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct GlobalType {
     pub ty: ValueType,
     pub mutable: bool,
 }
 
 /// Represents a core Wasm export or import type
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub enum Type {
     Function(FunctionType),
     Global(GlobalType),
@@ -99,15 +99,15 @@ impl From<&Type> for wasm_encoder::ExportKind {
 }
 
 /// Represents a core Wasm import
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Import<'a> {
     pub module: &'a str,
     pub name: &'a str,
     pub ty: Type,
 }
 
 /// Represents a core Wasm export
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct Export<'a> {
     pub name: &'a str,
     pub ty: Type,
@@ -165,19 +165,19 @@ pub struct Metadata<'a> {
     pub has_component_exports: bool,
 
     /// The functions imported from the `env` module, if any
-    pub env_imports: HashSet<(&'a str, FunctionType)>,
+    pub env_imports: BTreeSet<(&'a str, FunctionType)>,
 
     /// The memory addresses imported from `GOT.mem`, if any
-    pub memory_address_imports: HashSet<&'a str>,
+    pub memory_address_imports: BTreeSet<&'a str>,
 
     /// The table addresses imported from `GOT.func`, if any
-    pub table_address_imports: HashSet<&'a str>,
+    pub table_address_imports: BTreeSet<&'a str>,
 
     /// The symbols exported by this module, if any
-    pub exports: HashSet<Export<'a>>,
+    pub exports: BTreeSet<Export<'a>>,
 
     /// The symbols imported by this module (and not accounted for in the above fields), if any
-    pub imports: HashSet<Import<'a>>,
+    pub imports: BTreeSet<Import<'a>>,
 }
 
 #[allow(dead_code)]
@@ -266,11 +266,11 @@ impl<'a> Metadata<'a> {
             has_ctors: false,
             has_set_libraries: false,
             has_component_exports,
-            env_imports: HashSet::new(),
-            memory_address_imports: HashSet::new(),
-            table_address_imports: HashSet::new(),
-            exports: HashSet::new(),
-            imports: HashSet::new(),
+            env_imports: BTreeSet::new(),
+            memory_address_imports: BTreeSet::new(),
+            table_address_imports: BTreeSet::new(),
+            exports: BTreeSet::new(),
+            imports: BTreeSet::new(),
         };
         let mut types = Vec::new();
         let mut function_types = Vec::new();
diff --git a/crates/wit-component/tests/components/link-dl-openable/component.wat b/crates/wit-component/tests/components/link-dl-openable/component.wat
@@ -0,0 +1,126 @@
+(component
+  (type (;0;)
+    (instance
+      (type (;0;) (func (param "v" s32) (result s32)))
+      (export (;0;) "foo" (func (type 0)))
+    )
+  )
+  (import (interface "test:test/test") (instance (;0;) (type 0)))
+  (core module (;0;)
+    (table (;0;) 3 funcref)
+    (memory (;0;) 17)
+    (global (;0;) (mut i32) i32.const 1048576)
+    (global (;1;) i32 i32.const 1048688)
+    (global (;2;) i32 i32.const 3)
+    (global (;3;) (mut i32) i32.const 1048688)
+    (global (;4;) (mut i32) i32.const 1114112)
+    (export "__stack_pointer" (global 0))
+    (export "foo:memory_base" (global 1))
+    (export "foo:table_base" (global 2))
+    (export "__heap_base" (global 3))
+    (export "__heap_end" (global 4))
+    (export "__indirect_function_table" (table 0))
+    (export "memory" (memory 0))
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core module (;1;)
+    (@dylink.0
+      (mem-info (memory 0 4))
+    )
+    (type (;0;) (func (param i32) (result i32)))
+    (import "test:test/test" "foo" (func $import_foo (;0;) (type 0)))
+    (func $foo (;1;) (type 0) (param i32) (result i32)
+      unreachable
+    )
+    (global $what (;0;) i32 i32.const 42)
+    (export "test:test/test#foo" (func $foo))
+    (export "bar" (func $foo))
+    (export "baz" (func $foo))
+    (export "what" (global $what))
+  )
+  (core module (;2;)
+    (type (;0;) (func))
+    (type (;1;) (func (param i32)))
+    (type (;2;) (func (param i32) (result i32)))
+    (type (;3;) (func (param i32) (result i32)))
+    (type (;4;) (func (param i32) (result i32)))
+    (import "env" "memory" (memory (;0;) 0))
+    (import "env" "__indirect_function_table" (table (;0;) 0 funcref))
+    (import "env" "foo:memory_base" (global (;0;) i32))
+    (import "foo" "what" (global (;1;) i32))
+    (import "foo" "bar" (func (;0;) (type 2)))
+    (import "foo" "baz" (func (;1;) (type 3)))
+    (import "foo" "test:test/test#foo" (func (;2;) (type 4)))
+    (func (;3;) (type 0)
+      i32.const 1048656
+      global.get 0
+      global.get 1
+      i32.add
+      i32.store
+    )
+    (start 3)
+    (elem (;0;) (i32.const 0) func 0 1 2)
+    (elem (;1;) (i32.const 3) func)
+    (data (;0;) (i32.const 1048576) "foo\00bar\00baz\00test:test/test#foo\00\00what\03\00\00\00\04\00\10\00\00\00\00\00\03\00\00\00\08\00\10\00\01\00\00\00\12\00\00\00\0c\00\10\00\02\00\00\00\04\00\00\00 \00\10\00\00\00\00\00\03\00\00\00\00\00\10\00\04\00\00\00$\00\10\00\01\00\00\00T\00\10\00")
+    (@producers
+      (processed-by "wit-component" "$CARGO_PKG_VERSION")
+    )
+  )
+  (core instance (;0;) (instantiate 0))
+  (alias core export 0 "memory" (core memory (;0;)))
+  (alias core export 0 "__heap_base" (core global (;0;)))
+  (alias core export 0 "__heap_end" (core global (;1;)))
+  (core instance (;1;)
+    (export "__heap_base" (global 0))
+    (export "__heap_end" (global 1))
+  )
+  (core instance (;2;))
+  (alias core export 0 "memory" (core memory (;1;)))
+  (alias core export 0 "__indirect_function_table" (core table (;0;)))
+  (alias core export 0 "__stack_pointer" (core global (;2;)))
+  (alias core export 0 "foo:memory_base" (core global (;3;)))
+  (alias core export 0 "foo:table_base" (core global (;4;)))
+  (core instance (;3;)
+    (export "memory" (memory 1))
+    (export "__indirect_function_table" (table 0))
+    (export "__stack_pointer" (global 2))
+    (export "__memory_base" (global 3))
+    (export "__table_base" (global 4))
+  )
+  (alias export 0 "foo" (func (;0;)))
+  (core func (;0;) (canon lower (func 0)))
+  (core instance (;4;)
+    (export "foo" (func 0))
+  )
+  (core instance (;5;) (instantiate 1
+      (with "GOT.mem" (instance 1))
+      (with "GOT.func" (instance 2))
+      (with "env" (instance 3))
+      (with "test:test/test" (instance 4))
+    )
+  )
+  (core instance (;6;) (instantiate 2
+      (with "env" (instance 0))
+      (with "foo" (instance 5))
+    )
+  )
+  (type (;1;) (func (param "v" s32) (result s32)))
+  (alias core export 5 "test:test/test#foo" (core func (;1;)))
+  (func (;1;) (type 1) (canon lift (core func 1)))
+  (component (;0;)
+    (type (;0;) (func (param "v" s32) (result s32)))
+    (import "import-func-foo" (func (;0;) (type 0)))
+    (type (;1;) (func (param "v" s32) (result s32)))
+    (export (;1;) "foo" (func 0) (func (type 1)))
+  )
+  (instance (;1;) (instantiate 0
+      (with "import-func-foo" (func 1))
+    )
+  )
+  (export (;2;) (interface "test:test/test") (instance 1))
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)
diff --git a/crates/wit-component/tests/components/link-dl-openable/component.wit.print b/crates/wit-component/tests/components/link-dl-openable/component.wit.print
@@ -0,0 +1,7 @@
+package root:component
+
+world root {
+  import test:test/test
+
+  export test:test/test
+}
diff --git a/crates/wit-component/tests/components/link-dl-openable/dlopen-lib-foo.wat b/crates/wit-component/tests/components/link-dl-openable/dlopen-lib-foo.wat
@@ -0,0 +1,15 @@
+(module
+  (@dylink.0
+    (mem-info (memory 0 4))
+  )
+  (type (func (param i32) (result i32)))
+  (import "test:test/test" "foo" (func $import_foo (type 0)))
+  (func $foo (type 0) (param i32) (result i32)
+    unreachable
+  )
+  (global $what i32 i32.const 42)
+  (export "test:test/test#foo" (func $foo))
+  (export "bar" (func $foo))
+  (export "baz" (func $foo))
+  (export "what" (global $what))
+)
diff --git a/crates/wit-component/tests/components/link-dl-openable/dlopen-lib-foo.wit b/crates/wit-component/tests/components/link-dl-openable/dlopen-lib-foo.wit
@@ -0,0 +1,10 @@
+package test:test
+
+interface test {
+   foo: func(v: s32) -> s32
+}
+
+world dlopen-lib-foo {
+    import test
+    export test
+}
diff --git a/crates/wit-component/tests/components/link/lib-unused.wat b/crates/wit-component/tests/components/link/lib-unused.wat
@@ -0,0 +1,55 @@
+(module
+  (@dylink.0
+    (mem-info (memory 4 4))
+    (needed "c")
+  )
+  (type (func))
+  (type (func (param i32) (result i32)))
+  (import "env" "memory" (memory 1))
+  (import "env" "__indirect_function_table" (table 0 funcref))
+  (import "env" "__stack_pointer" (global $__stack_pointer (mut i32)))
+  (import "env" "__memory_base" (global $__memory_base i32))
+  (import "env" "__table_base" (global $__table_base i32))
+  (import "env" "malloc" (func $malloc (type 1)))
+  (import "env" "abort" (func $abort (type 0)))
+  (import "GOT.mem" "um" (global $um (mut i32)))
+  (import "test:test/test" "bar" (func $bar (type 1)))
+  (func $__wasm_call_ctors (type 0))
+  (func $__wasm_apply_data_relocs (type 0))
+  (func $foo (type 1) (param i32) (result i32)
+    global.get $__stack_pointer
+    i32.const 16
+    i32.sub
+    global.set $__stack_pointer
+
+    i32.const 4
+    call $malloc
+
+    i32.const 0
+    i32.eq
+    if
+      call $abort
+      unreachable
+    end
+
+    local.get 0
+    global.get $um
+    i32.load offset=16
+    i32.add
+    i32.const 42
+    i32.add
+
+    call $bar
+
+    global.get $__stack_pointer
+    i32.const 16
+    i32.add
+    global.set $__stack_pointer
+  )
+  (global i32 i32.const 0)
+  (export "__wasm_call_ctors" (func $__wasm_call_ctors))
+  (export "__wasm_apply_data_relocs" (func $__wasm_apply_data_relocs))
+  (export "foo2" (func $foo))
+  (export "well2" (global 4))
+  (data $.data (global.get $__memory_base) "\04\00\00\00")
+)
diff --git a/crates/wit-component/tests/components/link/lib-unused.wit b/crates/wit-component/tests/components/link/lib-unused.wit
@@ -0,0 +1,3 @@
+package test:test
+
+world lib-unused { }

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+package test:test`
	`2`	`+`
	`3`	`+world lib-unused { }`