[WebAssembly] Serialize params/results in MachineFunctionInfo

[aheejin]

Summary

This adds support for YAML serialization of Params and Results
fields in WebAssemblyMachineFunctionInfo. Types are printed as MVT's
string representation. This is for writing MIR tests easier.

The tests added are testing simple parsing and printing of params /
results fields under machineFunctionInfo.

[tlively]

llvm/test/CodeGen/WebAssembly/function-info.mir

109

Does MIR use MVTs for its types? I thought it would be using WebAssembly register classes instead. If it uses register classes, then these would all be represented by V128.

[aheejin]

llvm/test/CodeGen/WebAssembly/function-info.mir

109

WebAssemblyMachineFunctionInfo uses them: https://github.com/llvm/llvm-project/blob/007158ac42c785cd59aab8bc4b4b39085b960a58/llvm/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h#L36-L37

So it's not an MIR thing, but how we store the info. Come to think of it, I'm not sure if there is any compelling reason we should store them as MVTs though. We just happen to do that in ISelLowering.

[tlively]

Thanks for the context links! This LGTM 👍

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.h

enum class HeapType : unsigned {
   Funcref = unsigned(wasm::ValType::FUNCREF),
 };
 
 // Convert StringRef to ValType / HealType / BlockType
 
 Optional<wasm::ValType> parseType(StringRef Type);
 HeapType parseHeapType(StringRef Type);
 BlockType parseBlockType(StringRef Type);
+MVT parseMVT(StringRef Type);
 
 // Convert ValType or a list/signature of ValTypes to a string.
 
 // Convert an unsinged integer, which can be among wasm::ValType enum, to its
 // type name string. If the input is not within wasm::ValType, returns
 // "invalid_type".
 const char *anyTypeToString(unsigned Type);
 const char *typeToString(wasm::ValType Type);

llvm/lib/Target/WebAssembly/Utils/WebAssemblyTypeUtilities.cpp

return StringSwitch<WebAssembly::BlockType>(Type)
       .Case("f64", WebAssembly::BlockType::F64)
       .Case("v128", WebAssembly::BlockType::V128)
       .Case("funcref", WebAssembly::BlockType::Funcref)
       .Case("externref", WebAssembly::BlockType::Externref)
       .Case("void", WebAssembly::BlockType::Void)
       .Default(WebAssembly::BlockType::Invalid);
 }
 
+MVT WebAssembly::parseMVT(StringRef Type) {
+  return StringSwitch<MVT>(Type)
+      .Case("i32", MVT::i32)
+      .Case("i64", MVT::i64)
+      .Case("f32", MVT::f32)
+      .Case("f64", MVT::f64)
+      .Case("i64", MVT::i64)
+      .Case("v16i8", MVT::v16i8)
+      .Case("v8i16", MVT::v8i16)
+      .Case("v4i32", MVT::v4i32)
+      .Case("v2i64", MVT::v2i64)
+      .Case("funcref", MVT::funcref)
+      .Case("externref", MVT::externref)
+      .Default(MVT::INVALID_SIMPLE_VALUE_TYPE);
+}
+
 // We have various enums representing a subset of these types, use this
 // function to convert any of them to text.
 const char *WebAssembly::anyTypeToString(unsigned Type) {
   switch (Type) {
   case wasm::WASM_TYPE_I32:
     return "i32";
   case wasm::WASM_TYPE_I64:
     return "i64";

llvm/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h

 signatureFromMVTs(const SmallVectorImpl<MVT> &Results,
                   const SmallVectorImpl<MVT> &Params);
 
 namespace yaml {
 
 using BBNumberMap = DenseMap<int, int>;
 
 struct WebAssemblyFunctionInfo final : public yaml::MachineFunctionInfo {
+  std::vector<FlowStringValue> Params;
+  std::vector<FlowStringValue> Results;
   bool CFGStackified = false;
   // The same as WasmEHFuncInfo's SrcToUnwindDest, but stored in the mapping of
   // BB numbers
   BBNumberMap SrcToUnwindDest;
 
   WebAssemblyFunctionInfo() = default;
   WebAssemblyFunctionInfo(const llvm::WebAssemblyFunctionInfo &MFI);
 
   void mappingImpl(yaml::IO &YamlIO) override;
   ~WebAssemblyFunctionInfo() = default;
 };
 
 template <> struct MappingTraits<WebAssemblyFunctionInfo> {
   static void mapping(IO &YamlIO, WebAssemblyFunctionInfo &MFI) {
+    YamlIO.mapOptional("params", MFI.Params, std::vector<FlowStringValue>());
+    YamlIO.mapOptional("results", MFI.Results, std::vector<FlowStringValue>());
     YamlIO.mapOptional("isCFGStackified", MFI.CFGStackified, false);
     YamlIO.mapOptional("wasmEHFuncInfo", MFI.SrcToUnwindDest);
   }
 };
 
 template <> struct CustomMappingTraits<BBNumberMap> {
   static void inputOne(IO &YamlIO, StringRef Key,
                        BBNumberMap &SrcToUnwindDest) {

llvm/lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp

 //=- WebAssemblyMachineFunctionInfo.cpp - WebAssembly Machine Function Info -=//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements WebAssembly-specific per-machine-function
 /// information.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "WebAssemblyMachineFunctionInfo.h"
+#include "MCTargetDesc/WebAssemblyInstPrinter.h"
 #include "Utils/WebAssemblyTypeUtilities.h"
 #include "WebAssemblyISelLowering.h"
 #include "WebAssemblySubtarget.h"
 #include "llvm/CodeGen/Analysis.h"
 #include "llvm/CodeGen/WasmEHFuncInfo.h"
 #include "llvm/Target/TargetMachine.h"
 using namespace llvm;
 
llvm::signatureFromMVTs(const SmallVectorImpl<MVT> &Results,
   return Sig;
 }
 
 yaml::WebAssemblyFunctionInfo::WebAssemblyFunctionInfo(
     const llvm::WebAssemblyFunctionInfo &MFI)
     : CFGStackified(MFI.isCFGStackified()) {
   auto *EHInfo = MFI.getWasmEHFuncInfo();
   const llvm::MachineFunction &MF = MFI.getMachineFunction();
+
+  for (auto VT : MFI.getParams())
+    Params.push_back(EVT(VT).getEVTString());
+  for (auto VT : MFI.getResults())
+    Results.push_back(EVT(VT).getEVTString());
+
   //  MFI.getWasmEHFuncInfo() is non-null only for functions with the
   //  personality function.
   if (EHInfo) {
     // SrcToUnwindDest can contain stale mappings in case BBs are removed in
     // optimizations, in case, for example, they are unreachable. We should not
     // include their info.
     SmallPtrSet<const MachineBasicBlock *, 16> MBBs;
     for (const auto &MBB : MF)

 
 void yaml::WebAssemblyFunctionInfo::mappingImpl(yaml::IO &YamlIO) {
   MappingTraits<WebAssemblyFunctionInfo>::mapping(YamlIO, *this);
 }
 
 void WebAssemblyFunctionInfo::initializeBaseYamlFields(
     const yaml::WebAssemblyFunctionInfo &YamlMFI) {
   CFGStackified = YamlMFI.CFGStackified;
+  for (auto VT : YamlMFI.Params)
+    addParam(WebAssembly::parseMVT(VT.Value));
+  for (auto VT : YamlMFI.Results)
+    addResult(WebAssembly::parseMVT(VT.Value));
   if (WasmEHInfo) {
     for (auto KV : YamlMFI.SrcToUnwindDest)
       WasmEHInfo->setUnwindDest(MF.getBlockNumbered(KV.first),
                                 MF.getBlockNumbered(KV.second));
   }
 }

llvm/test/CodeGen/WebAssembly/function-info.mir

-# RUN: llc -mtriple=wasm32-unknown-unknown -exception-model=wasm -mattr=+exception-handling -run-pass wasm-cfg-sort -run-pass wasm-cfg-stackify %s -o - | FileCheck %s
+# RUN: llc -mtriple=wasm32-unknown-unknown -exception-model=wasm -mattr=+exception-handling,+multivalue,+simd128 -run-pass wasm-cfg-sort -run-pass wasm-cfg-stackify %s -o - | FileCheck %s
 
 --- |
   target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
   target triple = "wasm32-unknown-unknown"
 
   declare i32 @__gxx_wasm_personality_v0(...)
   declare void @foo()
   define void @function_property_test() {
     ret void
   }
   define void @wasm_eh_info_test() personality i8* bitcast (i32 (...)* @__gxx_wasm_personality_v0 to i8*) {
     ret void
   }
+
+  ;; Param / results tests
+  define i32 @i32__i64(i64) {
+    ret i32 0
+  }
+  define void @void__i32_i64_f32_f64() {
+    ret void
+  }
+  define void @void__v16i8_v8i16_v4i32_v2i64(<16 x i8>, <8 x i16>, <4 x i32>, <2 x i64>) {
+    ret void
+  }
+  %pair = type { i32, i64 }
+  define %pair @i32_i64__i32_i64(%pair %p) {
+    ret %pair %p
+  }
 ...
 
 # CHECK-LABEL: name: function_property_test
 # CHECK: machineFunctionInfo:
 # CHECK:   isCFGStackified:   true
 name: function_property_test
 liveins:
   - { reg: '$arguments' }
bb.2 (landing-pad):
     %0:i32 = CATCH &__cpp_exception, implicit-def dead $arguments
     CALL @foo, implicit-def dead $arguments, implicit $sp32, implicit $sp64, implicit-def dead $arguments, implicit $sp32, implicit $sp64
     BR %bb.1, implicit-def $arguments
 
   bb.3 (landing-pad):
     CATCH_ALL implicit-def $arguments
     RETHROW 0, implicit-def $arguments
 ...
+
+# Param / results tests
+---
+# CHECK-LABEL: name: i32__i64
+# CHECK:    machineFunctionInfo:
+# CHECK:      params:          [ i64 ]
+# CHECK-NEXT: results:         [ i32 ]
+name: i32__i64
+liveins:
+  - { reg: '$arguments' }
+machineFunctionInfo:
+  params:          [ i64 ]
+  results:         [ i32 ]
+body: |
+  bb.0:
+    %0:i32 = CONST_I32 3, implicit-def dead $arguments
+    RETURN %0:i32, implicit-def dead $arguments
+...
+---
+# CHECK-LABEL: name: void__i32_i64_f32_f64
+# CHECK:    machineFunctionInfo:
+# CHECK:      params:          [ i32, i64, f32, f64 ]
+# CHECK-NEXT: results:         [  ]
+name: void__i32_i64_f32_f64
+liveins:
+  - { reg: '$arguments' }
+machineFunctionInfo:
+  params:          [ i32, i64, f32, f64 ]
+  results:         [  ]
+body: |
+  bb.0:
+    RETURN implicit-def dead $arguments
+...
+---
+# CHECK-LABEL: name: void__v16i8_v8i16_v4i32_v2i64
+# CHECK:    machineFunctionInfo:
+# CHECK:      params:          [ v16i8, v8i16, v4i32, v2i64 ]
+# CHECK-NEXT: results:         [  ]
+name: void__v16i8_v8i16_v4i32_v2i64
+liveins:
+  - { reg: '$arguments' }
+machineFunctionInfo:
+  params:          [ v16i8, v8i16, v4i32, v2i64 ]
+  results:         [  ]
+body: |
+  bb.0:
+    RETURN implicit-def dead $arguments
+...
+---
+# CHECK-LABEL: name: i32_i64__i32_i64
+# CHECK:    machineFunctionInfo:
+# CHECK:      params:          [ i32, i64 ]
+# CHECK-NEXT: results:         [ i32, i64 ]
+name: i32_i64__i32_i64
+liveins:
+  - { reg: '$arguments' }
+machineFunctionInfo:
+  params:          [ i32, i64 ]
+  results:         [ i32, i64 ]
+body: |
+  bb.0:
+    %0:i32 = ARGUMENT_i32 0, implicit $arguments
+    %1:i64 = ARGUMENT_i64 1, implicit $arguments
+    RETURN %0, %1, implicit-def dead $arguments
+...