[WebAssembly] Implement multivalue call_indirects

[tlively]

Summary

Unlike normal calls, call_indirects have immediate arguments that
caused a MachineVerifier failure without a small tweak to loosen the
verifier's requirements for variadicOpsAreDefs instructions.

One nice thing about the new call_indirects is that they do not need
to participate in the PCALL_INDIRECT mechanism because their post-isel
hook handles moving the function pointer argument and adding the flags
and typeindex arguments itself.

[aheejin]

It looks this assumes D71484 and D71496 have not been reverted, right?

[tlively]

In D74191#1865981, @aheejin wrote:

It looks this assumes D71484 and D71496 have not been reverted, right?

Correct, I will have to reland those patches.

[aheejin]

llvm/lib/CodeGen/MachineVerifier.cpp

1598

Can we change the line above

unsigned NumDefs = MCID.getNumDefs();

to

unsigned NumDefs = MO->getParent()->getNumDefs();

?

If this works, we don't need to handle this as an exception case. But because this is in target-independent code that affects all targets, some of which can have whatever weird instructions, so I'm not very sure if that will work. How about trying that and see if it works at least, and don't put too much effort on fixing it in case it does not work?

llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td

77

So this does not affect the capability to handle variadic use ops in later passes? (e.g. MachineOperand::isUse() correctly return true for uses?)

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

211

Nit: How about NumVariadicDefs to be a bit more consistent in naming?

233–236

Can we change this condition to I < MI->getNumOperands()?

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

138

Not about this CL, but this actually looks incorrect, doesn't it? I guess this function was never used for call_indirects after all...

141–144

What's the difference between getNumDefs and getNumExplicitDefs? Do we have any implicit defs?

[tlively]

• Address comments

llvm/lib/CodeGen/MachineVerifier.cpp

1598

I got this working using unsigned NumDefs = MO->getParent()->getNumExplicitDefs();, but I'm not sure this would be a good change to make. The MachineVerifier is supposed to be verifying that each machine instruction matches its definition in its MCID. By changing NumDefs to be derived from the machine instruction rather than the MCID, we are changing MachineVerifier so that it instead validates instructions against themselves, which is a much less powerful check.

llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td

77

At the Machine IR layer, each operand individually knows whether it is a use or a def, so MachineOperand::isUse() and friends still work correctly. At the MC layer everything is horribly broken, but that's ok because we don't have registers there except for tests. This accounts for some extra care I had to take with MCOperands in the final patch in this sequence.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

233–236

This doesn't seem to work. I haven't really dug into why, but I could if you'd like.

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

138

Yes, this is very wrong. I believe I ended up fixing it in a later patch in this sequence.

141–144

Yes, one example of an implicit def is ARGUMENTS.

[aheejin]

Nice!

llvm/lib/CodeGen/MachineVerifier.cpp

1598

I think you're right.

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

233–236

Yeah I think that's more general statement that we don't need to subtract NumVariadicDefs separately. (And this is not MachineVerifier so we are not loosening checks) Digging into why sounds OK, but I don't think we need to spend too much time there if it does not work.

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

141–144

Then I wonder how the previous code for CALL worked, because it uses getNumDefs..?

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

233–236

I'll add a new variable unsigned DescIndex = I - NumVariadicDefs; so we at least don't repeat that subexpression.

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

141–144

It looks like this code is only used in analyzing call side effects in WebAssemblyRegStackify. If the retrieved callee op is not a global, the code conservatively assumes it has all kinds of side effects. So we were previously emitting correct but overly-conservative stackifications.

llvm/lib/CodeGen/MachineVerifier.cpp

else if (MO->isImplicit())
       report("Explicit definition marked as implicit", MO, MONum);
   } else if (MONum < MCID.getNumOperands()) {
     const MCOperandInfo &MCOI = MCID.OpInfo[MONum];
     // Don't check if it's the last operand in a variadic instruction. See,
     // e.g., LDM_RET in the arm back end. Check non-variadic operands only.
     bool IsOptional = MI->isVariadic() && MONum == MCID.getNumOperands() - 1;
     if (!IsOptional) {
       if (MO->isReg()) {
-        if (MO->isDef() && !MCOI.isOptionalDef())
+        if (MO->isDef() && !MCOI.isOptionalDef() && !MCID.variadicOpsAreDefs())
           report("Explicit operand marked as def", MO, MONum);
         if (MO->isImplicit())
           report("Explicit operand marked as implicit", MO, MONum);
       }
 
       // Check that an instruction has register operands only as expected.
       if (MCOI.OperandType == MCOI::OPERAND_REGISTER &&
           !MO->isReg() && !MO->isFI())

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

inline bool isCallDirect(unsigned Opc) {
   case WebAssembly::CALL_v2i64:
   case WebAssembly::CALL_v2i64_S:
   case WebAssembly::CALL_v4f32:
   case WebAssembly::CALL_v4f32_S:
   case WebAssembly::CALL_v2f64:
   case WebAssembly::CALL_v2f64_S:
   case WebAssembly::CALL_exnref:
   case WebAssembly::CALL_exnref_S:
+  case WebAssembly::CALL:
+  case WebAssembly::CALL_S:
   case WebAssembly::RET_CALL:
   case WebAssembly::RET_CALL_S:
     return true;
   default:
     return false;
   }
 }
 
inline bool isCallIndirect(unsigned Opc) {
   case WebAssembly::CALL_INDIRECT_v2i64:
   case WebAssembly::CALL_INDIRECT_v2i64_S:
   case WebAssembly::CALL_INDIRECT_v4f32:
   case WebAssembly::CALL_INDIRECT_v4f32_S:
   case WebAssembly::CALL_INDIRECT_v2f64:
   case WebAssembly::CALL_INDIRECT_v2f64_S:
   case WebAssembly::CALL_INDIRECT_exnref:
   case WebAssembly::CALL_INDIRECT_exnref_S:
+  case WebAssembly::CALL_INDIRECT:
+  case WebAssembly::CALL_INDIRECT_S:
   case WebAssembly::RET_CALL_INDIRECT:
   case WebAssembly::RET_CALL_INDIRECT_S:
     return true;
   default:
     return false;
   }
 }
 
-/// Returns the operand number of a callee, assuming the argument is a call
-/// instruction.
-inline const MachineOperand &getCalleeOp(const MachineInstr &MI) {
-  switch (MI.getOpcode()) {
-  case WebAssembly::CALL_VOID:
-  case WebAssembly::CALL_VOID_S:
-  case WebAssembly::CALL_INDIRECT_VOID:
-  case WebAssembly::CALL_INDIRECT_VOID_S:
-  case WebAssembly::RET_CALL:
-  case WebAssembly::RET_CALL_S:
-  case WebAssembly::RET_CALL_INDIRECT:
-  case WebAssembly::RET_CALL_INDIRECT_S:
-    return MI.getOperand(0);
-  case WebAssembly::CALL_i32:
-  case WebAssembly::CALL_i32_S:
-  case WebAssembly::CALL_i64:
-  case WebAssembly::CALL_i64_S:
-  case WebAssembly::CALL_f32:
-  case WebAssembly::CALL_f32_S:
-  case WebAssembly::CALL_f64:
-  case WebAssembly::CALL_f64_S:
-  case WebAssembly::CALL_v16i8:
-  case WebAssembly::CALL_v16i8_S:
-  case WebAssembly::CALL_v8i16:
-  case WebAssembly::CALL_v8i16_S:
-  case WebAssembly::CALL_v4i32:
-  case WebAssembly::CALL_v4i32_S:
-  case WebAssembly::CALL_v2i64:
-  case WebAssembly::CALL_v2i64_S:
-  case WebAssembly::CALL_v4f32:
-  case WebAssembly::CALL_v4f32_S:
-  case WebAssembly::CALL_v2f64:
-  case WebAssembly::CALL_v2f64_S:
-  case WebAssembly::CALL_exnref:
-  case WebAssembly::CALL_exnref_S:
-  case WebAssembly::CALL_INDIRECT_i32:
-  case WebAssembly::CALL_INDIRECT_i32_S:
-  case WebAssembly::CALL_INDIRECT_i64:
-  case WebAssembly::CALL_INDIRECT_i64_S:
-  case WebAssembly::CALL_INDIRECT_f32:
-  case WebAssembly::CALL_INDIRECT_f32_S:
-  case WebAssembly::CALL_INDIRECT_f64:
-  case WebAssembly::CALL_INDIRECT_f64_S:
-  case WebAssembly::CALL_INDIRECT_v16i8:
-  case WebAssembly::CALL_INDIRECT_v16i8_S:
-  case WebAssembly::CALL_INDIRECT_v8i16:
-  case WebAssembly::CALL_INDIRECT_v8i16_S:
-  case WebAssembly::CALL_INDIRECT_v4i32:
-  case WebAssembly::CALL_INDIRECT_v4i32_S:
-  case WebAssembly::CALL_INDIRECT_v2i64:
-  case WebAssembly::CALL_INDIRECT_v2i64_S:
-  case WebAssembly::CALL_INDIRECT_v4f32:
-  case WebAssembly::CALL_INDIRECT_v4f32_S:
-  case WebAssembly::CALL_INDIRECT_v2f64:
-  case WebAssembly::CALL_INDIRECT_v2f64_S:
-  case WebAssembly::CALL_INDIRECT_exnref:
-  case WebAssembly::CALL_INDIRECT_exnref_S:
-    return MI.getOperand(1);
-  case WebAssembly::CALL:
-  case WebAssembly::CALL_S:
-    return MI.getOperand(MI.getNumDefs());
-  default:
-    llvm_unreachable("Not a call instruction");
-  }
-}
-
 inline bool isMarker(unsigned Opc) {
   switch (Opc) {
   case WebAssembly::BLOCK:
   case WebAssembly::BLOCK_S:
   case WebAssembly::END_BLOCK:
   case WebAssembly::END_BLOCK_S:
   case WebAssembly::LOOP:
   case WebAssembly::LOOP_S:

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

 
 static MachineBasicBlock *LowerCallResults(MachineInstr &CallResults,
                                            DebugLoc DL, MachineBasicBlock *BB,
                                            const TargetInstrInfo &TII) {
   MachineInstr &CallParams = *CallResults.getPrevNode();
   assert(CallParams.getOpcode() == WebAssembly::CALL_PARAMS);
   assert(CallResults.getOpcode() == WebAssembly::CALL_RESULTS);
 
+  bool IsIndirect = CallParams.getOperand(0).isReg();
+  unsigned CallOp = IsIndirect ? WebAssembly::CALL_INDIRECT : WebAssembly::CALL;
+
   MachineFunction &MF = *BB->getParent();
-  const MCInstrDesc &MCID = TII.get(WebAssembly::CALL);
+  const MCInstrDesc &MCID = TII.get(CallOp);
   MachineInstrBuilder MIB(MF, MF.CreateMachineInstr(MCID, DL));
 
+  // Move the function pointer to the end of the arguments for indirect calls
+  if (IsIndirect) {
+    auto FnPtr = CallParams.getOperand(0);
+    CallParams.RemoveOperand(0);
+    CallParams.addOperand(FnPtr);
+  }
+
   for (auto Def : CallResults.defs())
     MIB.add(Def);
+
+  // Add placeholders for the type index and immediate flags
+  if (IsIndirect) {
+    MIB.addImm(0);
+    MIB.addImm(0);
+  }
+
   for (auto Use : CallParams.uses())
     MIB.add(Use);
 
   BB->insert(CallResults.getIterator(), MIB);
   CallParams.eraseFromParent();
   CallResults.eraseFromParent();
 
   return BB;

llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td

 
 let variadicOpsAreDefs = 1, usesCustomInserter = 1, isPseudo = 1 in
 defm CALL_RESULTS :
   I<(outs), (ins variable_ops), (outs), (ins), [],
      "call_results", "call_results", -1>;
 
 let Uses = [SP32, SP64], isCall = 1 in {
 
-// TODO: Add an indirect version of the variadic call, delete CALL_*
+// TODO: delete CALL_*
+let variadicOpsAreDefs = 1 in
 defm CALL :
   I<(outs), (ins function32_op:$callee, variable_ops),
     (outs), (ins function32_op:$callee), [],
     "call\t$callee", "call\t$callee", 0x10>;
 
+let variadicOpsAreDefs = 1 in
+defm CALL_INDIRECT :
+ I<(outs), (ins TypeIndex:$type, i32imm:$flags, variable_ops),
+   (outs), (ins TypeIndex:$type, i32imm:$flags), [],
+   "call_indirect", "call_indirect\t$type", 0x11>;
+
 defm "" : CALL<i32, I32, "i32.">;
 defm "" : CALL<i64, I64, "i64.">;
 defm "" : CALL<f32, F32, "f32.">;
 defm "" : CALL<f64, F64, "f64.">;
 defm "" : CALL<exnref, EXNREF, "exnref.", [HasExceptionHandling]>;
 defm "" : CALL<v16i8, V128, "v128.", [HasSIMD128]>;
 defm "" : CALL<v8i16, V128, "v128.", [HasSIMD128]>;
 defm "" : CALL<v4i32, V128, "v128.", [HasSIMD128]>;

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

static void getFunctionReturns(const MachineInstr *MI,
   valTypesFromMVTs(CallerRetTys, Returns);
 }
 
 void WebAssemblyMCInstLower::lower(const MachineInstr *MI,
                                    MCInst &OutMI) const {
   OutMI.setOpcode(MI->getOpcode());
 
   const MCInstrDesc &Desc = MI->getDesc();
+  unsigned NumVariadicDefs = MI->getNumExplicitDefs() - Desc.getNumDefs();
   for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
     const MachineOperand &MO = MI->getOperand(I);
 
     MCOperand MCOp;
     switch (MO.getType()) {
     default:
       MI->print(errs());
       llvm_unreachable("unknown operand type");
     case MachineOperand::MO_MachineBasicBlock:
       MI->print(errs());
       llvm_unreachable("MachineBasicBlock operand should have been rewritten");
     case MachineOperand::MO_Register: {
       // Ignore all implicit register operands.
       if (MO.isImplicit())
         continue;
       const WebAssemblyFunctionInfo &MFI =
           *MI->getParent()->getParent()->getInfo<WebAssemblyFunctionInfo>();
       unsigned WAReg = MFI.getWAReg(MO.getReg());
       MCOp = MCOperand::createReg(WAReg);
       break;
     }
-    case MachineOperand::MO_Immediate:
-      if (I < Desc.NumOperands) {
-        const MCOperandInfo &Info = Desc.OpInfo[I];
+    case MachineOperand::MO_Immediate: {
+      unsigned DescIndex = I - NumVariadicDefs;
+      if (DescIndex < Desc.NumOperands) {
+        const MCOperandInfo &Info = Desc.OpInfo[DescIndex];
         if (Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) {
           SmallVector<wasm::ValType, 4> Returns;
           SmallVector<wasm::ValType, 4> Params;
 
           const MachineRegisterInfo &MRI =
               MI->getParent()->getParent()->getRegInfo();
           for (const MachineOperand &MO : MI->defs())
             Returns.push_back(getType(MRI.getRegClass(MO.getReg())));
case MachineOperand::MO_Immediate: {
             MCOp = lowerTypeIndexOperand(std::move(Returns),
                                          SmallVector<wasm::ValType, 4>());
             break;
           }
         }
       }
       MCOp = MCOperand::createImm(MO.getImm());
       break;
+    }
     case MachineOperand::MO_FPImmediate: {
       // TODO: MC converts all floating point immediate operands to double.
       // This is fine for numeric values, but may cause NaNs to change bits.
       const ConstantFP *Imm = MO.getFPImm();
       if (Imm->getType()->isFloatTy())
         MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToFloat());
       else if (Imm->getType()->isDoubleTy())
         MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToDouble());

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

if (F->getName() == CxaBeginCatchFn || F->getName() == PersonalityWrapperFn ||
       F->getName() == ClangCallTerminateFn || F->getName() == StdTerminateFn)
     return false;
 
   // TODO Can we exclude call instructions that are marked as 'nounwind' in the
   // original LLVm IR? (Even when the callee may throw)
   return true;
 }
 
-inline const MachineOperand &getCalleeOp(const MachineInstr &MI) {
+const MachineOperand &WebAssembly::getCalleeOp(const MachineInstr &MI) {
   switch (MI.getOpcode()) {
   case WebAssembly::CALL_VOID:
   case WebAssembly::CALL_VOID_S:
   case WebAssembly::CALL_INDIRECT_VOID:
   case WebAssembly::CALL_INDIRECT_VOID_S:
   case WebAssembly::RET_CALL:
   case WebAssembly::RET_CALL_S:
   case WebAssembly::RET_CALL_INDIRECT:
const MachineOperand &WebAssembly::getCalleeOp(const MachineInstr &MI) {
   case WebAssembly::CALL_INDIRECT_v2i64:
   case WebAssembly::CALL_INDIRECT_v2i64_S:
   case WebAssembly::CALL_INDIRECT_v4f32:
   case WebAssembly::CALL_INDIRECT_v4f32_S:
   case WebAssembly::CALL_INDIRECT_v2f64:
   case WebAssembly::CALL_INDIRECT_v2f64_S:
   case WebAssembly::CALL_INDIRECT_exnref:
   case WebAssembly::CALL_INDIRECT_exnref_S:
     return MI.getOperand(1);
   case WebAssembly::CALL:
   case WebAssembly::CALL_S:
-    return MI.getOperand(MI.getNumDefs());
+    return MI.getOperand(MI.getNumExplicitDefs());
+  case WebAssembly::CALL_INDIRECT:
+  case WebAssembly::CALL_INDIRECT_S:
+    return MI.getOperand(MI.getNumOperands() - 1);
   default:
     llvm_unreachable("Not a call instruction");
   }
 }

llvm/test/CodeGen/WebAssembly/multivalue.ll

-; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+multivalue,+tail-call | FileCheck %s
+; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -mattr=+multivalue,+tail-call | FileCheck %s
 ; RUN: llc < %s --filetype=obj -mattr=+multivalue,+tail-call | obj2yaml | FileCheck %s --check-prefix OBJ
 
 ; Test that the multivalue calls, returns, function types, and block
 ; types work as expected.
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 %pair = type { i32, i64 }
-%packed_pair = type <{ i32, i64 }>
-
 
 ; CHECK-LABEL: pair_const:
 ; CHECK-NEXT: .functype pair_const () -> (i32, i64)
-; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 42{{$}}
-; CHECK-NEXT: i64.const $push[[L1:[0-9]+]]=, 42{{$}}
-; CHECK-NEXT: return $pop[[L0]], $pop[[L1]]{{$}}
+; CHECK-NEXT: i32.const 42{{$}}
+; CHECK-NEXT: i64.const 42{{$}}
+; CHECK-NEXT: end_function{{$}}
 define %pair @pair_const() {
   ret %pair { i32 42, i64 42 }
 }
 
-; CHECK-LABEL: packed_pair_const:
-; CHECK-NEXT: .functype packed_pair_const () -> (i32, i64)
-; CHECK-NEXT: i32.const $push[[L0:[0-9]+]]=, 42{{$}}
-; CHECK-NEXT: i64.const $push[[L1:[0-9]+]]=, 42{{$}}
-; CHECK-NEXT: return $pop[[L0]], $pop[[L1]]{{$}}
-define %packed_pair @packed_pair_const() {
-  ret %packed_pair <{ i32 42, i64 42 }>
-}
-
 ; CHECK-LABEL: pair_ident:
 ; CHECK-NEXT: .functype pair_ident (i32, i64) -> (i32, i64)
-; CHECK-NEXT: return $0, $1{{$}}
+; CHECK-NEXT: local.get 0{{$}}
+; CHECK-NEXT: local.get 1{{$}}
+; CHECK-NEXT: end_function{{$}}
 define %pair @pair_ident(%pair %p) {
   ret %pair %p
 }
 
-; CHECK-LABEL: packed_pair_ident:
-; CHECK-NEXT: .functype packed_pair_ident (i32, i64) -> (i32, i64)
-; CHECK-NEXT: return $0, $1{{$}}
-define %packed_pair @packed_pair_ident(%packed_pair %p) {
-  ret %packed_pair %p
-}
-
-;; TODO: Multivalue calls are a WIP and do not necessarily produce
-;; correct output. For now, just check that they don't cause any
-;; crashes.
+;; TODO: Multivalue calls are a WIP and the following test cases do
+;; not necessarily produce correct output. For now just check that
+;; they do not crash.
 
+; CHECK-LABEL: pair_call:
+; CHECK-NEXT: .functype pair_call () -> ()
 define void @pair_call() {
   %p = call %pair @pair_const()
   ret void
 }
 
-define void @packed_pair_call() {
-  %p = call %packed_pair @packed_pair_const()
-  ret void
-}
-
+; CHECK-LABEL: pair_call_return:
+; CHECK-NEXT: .functype pair_call_return () -> (i32, i64)
 define %pair @pair_call_return() {
   %p = call %pair @pair_const()
   ret %pair %p
 }
 
-define %packed_pair @packed_pair_call_return() {
-  %p = call %packed_pair @packed_pair_const()
-  ret %packed_pair %p
+; CHECK-LABEL: pair_call_indirect:
+; CHECK-NEXT: .functype pair_call_indirect (i32) -> (i32, i64)
+; CHECK: call_indirect () -> (i32, i64){{$}}
+define %pair @pair_call_indirect(%pair()* %f) {
+  %p = call %pair %f()
+  ret %pair %p
 }
 
+; CHECK-LABEL: pair_tail_call:
+; CHECK-NEXT: .functype pair_tail_call () -> (i32, i64)
 define %pair @pair_tail_call() {
   %p = musttail call %pair @pair_const()
   ret %pair %p
 }
 
-define %packed_pair @packed_pair_tail_call() {
-  %p = musttail call %packed_pair @packed_pair_const()
-  ret %packed_pair %p
-}
-
+; CHECK-LABEL: pair_call_return_first:
+; CHECK-NEXT: .functype pair_call_return_first () -> (i32)
 define i32 @pair_call_return_first() {
   %p = call %pair @pair_const()
   %v = extractvalue %pair %p, 0
   ret i32 %v
 }
 
-define i32 @packed_pair_call_return_first() {
-  %p = call %packed_pair @packed_pair_const()
-  %v = extractvalue %packed_pair %p, 0
-  ret i32 %v
-}
-
+; CHECK-LABEL: pair_call_return_second:
+; CHECK-NEXT: .functype pair_call_return_second () -> (i64)
 define i64 @pair_call_return_second() {
   %p = call %pair @pair_const()
   %v = extractvalue %pair %p, 1
   ret i64 %v
 }
 
-define i64 @packed_pair_call_return_second() {
-  %p = call %packed_pair @packed_pair_const()
-  %v = extractvalue %packed_pair %p, 1
-  ret i64 %v
-}
 
+; CHECK-LABEL: pair_pass_through:
+; CHECK-NEXT: .functype pair_pass_through (i32, i64) -> (i32, i64)
 define %pair @pair_pass_through(%pair %p) {
   %r = call %pair @pair_ident(%pair %p)
   ret %pair %r
 }
 
-define %packed_pair @packed_pair_pass_through(%packed_pair %p) {
-  %r = call %packed_pair @packed_pair_ident(%packed_pair %p)
-  ret %packed_pair %r
-}
-
 ; CHECK-LABEL: minimal_loop:
 ; CHECK-NEXT: .functype minimal_loop (i32) -> (i32, i64)
 ; CHECK-NEXT: .LBB{{[0-9]+}}_1:
 ; CHECK-NEXT: loop () -> (i32, i64)
 ; CHECK-NEXT: br 0{{$}}
 ; CHECK-NEXT: .LBB{{[0-9]+}}_2:
 ; CHECK-NEXT: end_loop{{$}}
 define %pair @minimal_loop(i32* %p) {

 ; OBJ-NEXT:           - I64
 ; OBJ-NEXT:         ReturnTypes:
 ; OBJ-NEXT:           - I32
 ; OBJ-NEXT:           - I64
 ; OBJ-NEXT:       - Index:           2
 ; OBJ-NEXT:         ParamTypes:      []
 ; OBJ-NEXT:         ReturnTypes:     []
 ; OBJ-NEXT:       - Index:           3
-; OBJ-NEXT:         ParamTypes:      []
+; OBJ-NEXT:         ParamTypes:
+; OBJ-NEXT:           - I32
 ; OBJ-NEXT:         ReturnTypes:
 ; OBJ-NEXT:           - I32
+; OBJ-NEXT:           - I64
 ; OBJ-NEXT:       - Index:           4
 ; OBJ-NEXT:         ParamTypes:      []
 ; OBJ-NEXT:         ReturnTypes:
-; OBJ-NEXT:           - I64
-; OBJ-NEXT:       - Index:           5
-; OBJ-NEXT:         ParamTypes:
 ; OBJ-NEXT:           - I32
+; OBJ-NEXT:       - Index:           5
+; OBJ-NEXT:         ParamTypes:      []
 ; OBJ-NEXT:         ReturnTypes:
-; OBJ-NEXT:           - I32
 ; OBJ-NEXT:           - I64