[WebAssembly] Add a new wasm_multivalue calling convention

This is an implementation of WebAssembly/tool-conventions#268 here in
LLVM. This adds a new calling convention to Clang, named
`wasm_multivalue`, which is intended to be used on WebAssembly targets
to configure multiple return values and slightly tweak the ABI. Changes
here are:

* Parsing/validation of `__attribute__((wasm_multivalue))`. Note that
  validation here means that it's not only well-formed but on wasm
  targets the `multivalue` target feature is additionally enabled.
* Clang-level ABI adjustments for the `wasm_multivalue` calling
  convention. These are defined by WebAssembly/tool-conventions#268 and
  notably includes expanding structs with exactly 2 scalar fields in
  parameter-position and directly returning structs with any number of
  scalar fields in return-position.
* A new `wasm_multivaluecc` keyword/calling convention for LLVM IR. This
  is what Clang lowers to when using the `wasm_multivalue` calling
  convention.
* Adjustments at the LLVM ABI layer to support returning multiple values
  with the `wasm_multivaluecc` calling convention.

My goal after this would be to start integrating this into Rust next,
under and unstable feature, and then further continue
testing/vetting/etc for component model usage.

Author: alexcrichton

clang/include/clang-c/Index.h

@@ -3086,6 +3086,7 @@ enum CXCallingConv {
   CXCallingConv_RISCVVLSCall_16384 = 31,
   CXCallingConv_RISCVVLSCall_32768 = 32,
   CXCallingConv_RISCVVLSCall_65536 = 33,
+  CXCallingConv_WasmMultivalue = 34,
 
   CXCallingConv_Invalid = 100,
   CXCallingConv_Unexposed = 200

clang/include/clang/Basic/Attr.td

@@ -3555,6 +3555,12 @@ def M68kRTD: DeclOrTypeAttr {
   let Documentation = [M68kRTDDocs];
 }
 
+def WasmMultivalue : DeclOrTypeAttr,
+                     TargetSpecificAttr<TargetWebAssembly> {
+  let Spellings = [Clang<"wasm_multivalue">];
+  let Documentation = [WasmMultivalueDocs];
+}
+
 def PreserveNone : DeclOrTypeAttr,
                    TargetSpecificAttr<TargetArch<!listconcat(TargetAArch64.Arches, TargetAnyX86.Arches)>> {
   let Spellings = [Clang<"preserve_none">];

clang/include/clang/Basic/AttrDocs.td

@@ -3732,6 +3732,21 @@ using the `rtd` instruction.
   }];
 }
 
+def WasmMultivalueDocs : Documentation {
+  let Category = DocCatCallingConvs;
+  let Content = [{
+On WebAssembly targets, this attribute selects the ``wasm-multivalue`` calling
+convention as defined in the WebAssembly/tool-conventions repository. Relative
+to the default calling convention this takes advantage of the multi-value
+proposal in its ABI definition.
+
+This calling convention requires the ``multivalue`` target feature. Using the
+attribute without this feature enabled is a compile-time error. Enabling
+``multivalue`` does not change the default calling convention; this attribute
+must be used to opt in to the new behavior on a per-function basis.
+  }];
+}
+
 def DocCatConsumed : DocumentationCategory<"Consumed Annotation Checking"> {
   let Content = [{
 Clang supports additional attributes for checking basic resource management

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -13832,7 +13832,7 @@ def err_builtin_pass_in_regs_non_class : Error<
   "argument %0 is not an unqualified class type">;
 
 
-// WebAssembly reference type and table diagnostics.
+// WebAssembly-related diagnostics.
 def err_wasm_reference_pr : Error<
   "%select{pointer|reference}0 to WebAssembly reference type is not allowed">;
 def err_wasm_ca_reference : Error<
@@ -13875,6 +13875,9 @@ def err_wasm_builtin_test_fp_sig_cannot_include_struct_or_union
     : Error<"not supported with the multivalue ABI for "
             "function pointers with a struct/union as %select{return "
             "value|parameter}0">;
+def err_wasm_multivalue_requires_feature : Error<
+  "the 'wasm_multivalue' calling convention requires the 'multivalue' target "
+  "feature to be enabled">;
 
 // OpenACC diagnostics.
 def warn_acc_routine_unimplemented

clang/include/clang/Basic/Specifiers.h

@@ -316,6 +316,7 @@ namespace clang {
     CC_RISCVVLSCall_16384, // __attribute__((riscv_vls_cc(16384)))
     CC_RISCVVLSCall_32768, // __attribute__((riscv_vls_cc(32768)))
     CC_RISCVVLSCall_65536, // __attribute__((riscv_vls_cc(65536)))
+    CC_WasmMultivalue,     // __attribute__((wasm_multivalue))
   };
 
   /// Checks whether the given calling convention supports variadic

clang/lib/AST/ItaniumMangle.cpp

@@ -3534,6 +3534,7 @@ StringRef CXXNameMangler::getCallingConvQualifierName(CallingConv CC) {
   case CC_PreserveMost:
   case CC_PreserveAll:
   case CC_M68kRTD:
+  case CC_WasmMultivalue:
   case CC_PreserveNone:
   case CC_RISCVVectorCall:
 #define CC_VLS_CASE(ABI_VLEN) case CC_RISCVVLSCall_##ABI_VLEN:

clang/lib/AST/Type.cpp

@@ -3741,6 +3741,8 @@ StringRef FunctionType::getNameForCallConv(CallingConv CC) {
     return "preserve_all";
   case CC_M68kRTD:
     return "m68k_rtd";
+  case CC_WasmMultivalue:
+    return "wasm_multivalue";
   case CC_PreserveNone:
     return "preserve_none";
     // clang-format off
@@ -4552,6 +4554,7 @@ bool AttributedType::isCallingConv() const {
   case attr::PreserveMost:
   case attr::PreserveAll:
   case attr::M68kRTD:
+  case attr::WasmMultivalue:
   case attr::PreserveNone:
   case attr::RISCVVectorCC:
   case attr::RISCVVLSCC:

clang/lib/AST/TypePrinter.cpp

@@ -1173,6 +1173,9 @@ void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info,
     case CC_M68kRTD:
       OS << " __attribute__((m68k_rtd))";
       break;
+    case CC_WasmMultivalue:
+      OS << " __attribute__((wasm_multivalue))";
+      break;
     case CC_PreserveNone:
       OS << " __attribute__((preserve_none))";
       break;
@@ -2088,6 +2091,9 @@ void TypePrinter::printAttributedAfter(const AttributedType *T,
   case attr::M68kRTD:
     OS << "m68k_rtd";
     break;
+  case attr::WasmMultivalue:
+    OS << "wasm_multivalue";
+    break;
   case attr::RISCVVectorCC:
     OS << "riscv_vector_cc";
     break;

clang/lib/Basic/Targets/WebAssembly.h

@@ -184,6 +184,7 @@ class LLVM_LIBRARY_VISIBILITY WebAssemblyTargetInfo : public TargetInfo {
     switch (CC) {
     case CC_C:
     case CC_Swift:
+    case CC_WasmMultivalue:
       return CCCR_OK;
     case CC_SwiftAsync:
       return CCCR_Error;

clang/lib/CodeGen/CGCall.cpp

@@ -103,6 +103,8 @@ unsigned CodeGenTypes::ClangCallConvToLLVMCallConv(CallingConv CC) {
     return llvm::CallingConv::SwiftTail;
   case CC_M68kRTD:
     return llvm::CallingConv::M68k_RTD;
+  case CC_WasmMultivalue:
+    return llvm::CallingConv::WASM_Multivalue;
   case CC_PreserveNone:
     return llvm::CallingConv::PreserveNone;
     // clang-format off