multivalue result types

[sammax]

Summary

Emit all result types of a multivalue func type

[sbc100]

Do we not have any test for this @tlively? I guess we should add one if now.

Also for @tlively: where should we be doing feature checking for this kind of thing? Should we check as we write the output? Or as we read the inputs?

[tlively]

Nope, I guess we don't have any tests for this yet. @sammax, could you add a test in lld/test/wasm?

For feature testing, it would probably be cleanest to check all the input functions in Writer::populateTargetFeatures, since that's where all the other feature checking happens. @sammax, would you want to add that functionality as well? If not, it would be fine to leave that to a separate patch, I think.

[sammax]

added test

[sammax]

@tlively regarding the feature testing, I don't quite understand what happens in Writer::populateTargetFeatures yet, I'll have to look into it a bit more.

[tlively]

@sammax Yeah there's a lot of stuff going on there. Thinking about it more, I'm not sure we should be feature checking type signatures in the linker. We certainly aren't feature checking the contents of the linked functions. This patch LGTM, so I'll go ahead and land it as-is.

lld/test/wasm/multivalue-return-func-types.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+# RUN: wasm-ld %t.o -o %t.wasm
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+.globl _start
+.globl fn_i32
+.globl fn_i32_i32
+.globl fn_i32_i64
+.globl fn_i64_f64_i32_f32
+
+
+_start:
+  .functype _start () -> ()
+  call fn_i32
+  drop
+  call fn_i32_i32
+  drop
+  drop
+  call fn_i32_i64
+  drop
+  drop
+  call fn_i64_f64_i32_f32
+  drop
+  drop
+  drop
+  drop
+  end_function
+
+fn_i32:
+  .functype fn_i32 () -> (i32)
+  i32.const 1
+  end_function
+
+fn_i32_i32:
+  .functype fn_i32_i32 () -> (i32, i32)
+  i32.const 1
+  i32.const 1
+  end_function
+
+fn_i32_i64:
+  .functype fn_i32_i64 () -> (i32, i64)
+  i32.const 1
+  i64.const 1
+  end_function
+
+fn_i64_f64_i32_f32:
+  .functype fn_i64_f64_i32_f32 () -> (i64, f64, i32, f32)
+  i64.const 1
+  f64.const 1.0
+  i32.const 1
+  f32.const 1.0
+  end_function
+
+
+# CHECK:       - Type:            TYPE
+# CHECK-NEXT:    Signatures:
+# CHECK-NEXT:      - Index:           0
+# CHECK-NEXT:        ParamTypes:      []
+# CHECK-NEXT:        ReturnTypes:     []
+# CHECK-NEXT:      - Index:           1
+# CHECK-NEXT:        ParamTypes:      []
+# CHECK-NEXT:        ReturnTypes:
+# CHECK-NEXT:           - I32
+# CHECK-NEXT:      - Index:           2
+# CHECK-NEXT:        ParamTypes:      []
+# CHECK-NEXT:        ReturnTypes:
+# CHECK-NEXT:           - I32
+# CHECK-NEXT:           - I32
+# CHECK-NEXT:      - Index:           3
+# CHECK-NEXT:        ParamTypes:      []
+# CHECK-NEXT:        ReturnTypes:
+# CHECK-NEXT:           - I32
+# CHECK-NEXT:           - I64
+# CHECK-NEXT:      - Index:           4
+# CHECK-NEXT:        ParamTypes:      []
+# CHECK-NEXT:        ReturnTypes:
+# CHECK-NEXT:           - I64
+# CHECK-NEXT:           - F64
+# CHECK-NEXT:           - I32
+# CHECK-NEXT:           - F32

lld/wasm/WriterUtils.cpp

 
 void writeSig(raw_ostream &os, const WasmSignature &sig) {
   writeU8(os, WASM_TYPE_FUNC, "signature type");
   writeUleb128(os, sig.Params.size(), "param Count");
   for (ValType paramType : sig.Params) {
     writeValueType(os, paramType, "param type");
   }
   writeUleb128(os, sig.Returns.size(), "result Count");
-  if (sig.Returns.size()) {
-    writeValueType(os, sig.Returns[0], "result type");
+  for (ValType returnType : sig.Returns) {
+    writeValueType(os, returnType, "result type");
   }
 }
 
 void writeI32Const(raw_ostream &os, int32_t number, const Twine &msg) {
   writeU8(os, WASM_OPCODE_I32_CONST, "i32.const");
   writeSleb128(os, number, msg);
 }