[RISCV][GlobalISel] Add lowerCall for calling convention

[nitinjohnraj]

Summary

This patch implements minimal support for lowering function calls to callees with arguments and/or return values according to the RISC-V calling convention. Integer, pointer and aggregate types are supported.

Feedback is very much appreciated.

[lewis-revill]

Rebase, update test structure. Correct missing defs by adding CallReturnHandler.

[Joe]

If you're supporting a pointer value return type, should there be a test for this?

Other than that, this looks fine to me - although should wait until somebody more experienced looks at it.

Side note: Would it be worth, in the future, to outline the process of finding In/OutputArgs and ArgInfos to something like a computeOutgoingArgs/computeIncomingArgs that fills a list of ISD::In/OutputArg and ArgInfos? Or would this just obfuscate things?

[lewis-revill]

Add test for pointer return type

[lewis-revill]

Bug fix - add target flags to call instruction.

[lewis-revill]

Rebased, and updated where appropriate to continue to build correctly.

[arsenm]

llvm/lib/Target/RISCV/RISCVCallLowering.cpp

311 ↗

(On Diff #399997)

Same comment on the other half of the call lowering patches

[lewis-revill]

Use ValueAssigners to avoid rewriting generic infrastructure and use determineAndHandleAssignments instead.

[arsenm]

llvm/lib/Target/RISCV/RISCVCallLowering.cpp

263 ↗

(On Diff #403214)

Not sure why you're bothering to filter these out. splitToValueTypes should handle near everything (I'm aware of some assertions on weird non-byte element sized vectors)

[nitinjohnraj]

Rebased

[arsenm]

llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calls.ll

266

Use opaque pointers

268

Could use sret/byval tests. Also cases where the argument/return list is too long and needs to go to the stack

[eopXD]

llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp

304

This seems to contradict with the description of this patch, "Simple non-aggregate types are supported."

[nitinjohnraj]

Added tests for aggregate types, sret and byval

[nitinjohnraj]

llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp

304

You're right. I've updated the description and added a test accordingly.

llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calls.ll

266

Updated.

268

Could use sret/byval tests.

I've added these.

Also cases where the argument/return list is too long and needs to go to the stack

Are there other examples of a test like this?

[nitinjohnraj]

As stated in the parent revision, we will correctly handle byval, sret and cases where the number of arguments exceed the number of available registers in a future patch.

[arsenm]

llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp

258

Should add some tail call cases. You should set IsTailCall to false if you aren’t handling them

[nitinjohnraj]

Set IsTailCall to false. We will handle tail calls in a future patch.

llvm/lib/Target/RISCV/GISel/RISCVCallLowering.cpp

struct RISCVIncomingValueHandler : public CallLowering::IncomingValueHandler {
   void assignValueToReg(Register ValVReg, Register PhysReg,
                         CCValAssign VA) override {
     // Copy argument received in physical register to desired VReg.
     MIRBuilder.getMBB().addLiveIn(PhysReg);
     MIRBuilder.buildCopy(ValVReg, PhysReg);
   }
 };
 
+struct RISCVCallReturnHandler : public RISCVIncomingValueHandler {
+  RISCVCallReturnHandler(MachineIRBuilder &B, MachineRegisterInfo &MRI,
+                         MachineInstrBuilder &MIB)
+      : RISCVIncomingValueHandler(B, MRI), MIB(MIB) {}
+
+  MachineInstrBuilder MIB;
+
+  void assignValueToReg(Register ValVReg, Register PhysReg,
+                        CCValAssign VA) override {
+    // Copy argument received in physical register to desired VReg.
+    MIB.addDef(PhysReg, RegState::Implicit);
+    MIRBuilder.buildCopy(ValVReg, PhysReg);
+  }
+};
+
 } // namespace
 
 RISCVCallLowering::RISCVCallLowering(const RISCVTargetLowering &TLI)
     : CallLowering(&TLI) {}
 
 bool RISCVCallLowering::lowerReturnVal(MachineIRBuilder &MIRBuilder,
                                        const Value *Val,
                                        ArrayRef<Register> VRegs,
bool RISCVCallLowering::lowerFormalArguments(MachineIRBuilder &MIRBuilder,
   RISCVIncomingValueHandler Handler(MIRBuilder, MF.getRegInfo());
 
   return determineAndHandleAssignments(Handler, Assigner, SplitArgInfos,
                                        MIRBuilder, CC, F.isVarArg());
 }
 
 bool RISCVCallLowering::lowerCall(MachineIRBuilder &MIRBuilder,
                                   CallLoweringInfo &Info) const {
+  MachineFunction &MF = MIRBuilder.getMF();
+  const DataLayout &DL = MF.getDataLayout();
+  const Function &F = MF.getFunction();
+  CallingConv::ID CC = F.getCallingConv();
+
+  // TODO: Support vararg functions.
+  if (Info.IsVarArg)
     return false;
+
+  // TODO: Support all argument types.
+  for (auto &AInfo : Info.OrigArgs) {
+    if (AInfo.Ty->isIntegerTy())
+      continue;
+    if (AInfo.Ty->isPointerTy())
+      continue;
+    if (AInfo.Ty->isFloatingPointTy())
+      continue;
+    return false;
+  }
+
+  SmallVector<ArgInfo, 32> SplitArgInfos;
+  SmallVector<ISD::OutputArg, 8> Outs;
+  unsigned Index = 0;
+  for (auto &AInfo : Info.OrigArgs) {
+    // Handle any required unmerging of split value types from a given VReg into
+    // physical registers. ArgInfo objects are constructed correspondingly and
+    // appended to SplitArgInfos.
+    splitToValueTypes(AInfo, SplitArgInfos, DL, CC);
+
+    ++Index;
+  }
+
+  // TODO: Support tail calls.
+  Info.IsTailCall = false;
+
+  if (!Info.Callee.isReg())
+    Info.Callee.setTargetFlags(RISCVII::MO_CALL);
+
+  MachineInstrBuilder Call =
+      MIRBuilder
+          .buildInstrNoInsert(Info.Callee.isReg() ? RISCV::PseudoCALLIndirect
+                                                  : RISCV::PseudoCALL)
+          .add(Info.Callee);
+
+  RISCVOutgoingValueAssigner ArgAssigner(
+      CC == CallingConv::Fast ? RISCV::CC_RISCV_FastCC : RISCV::CC_RISCV,
+      /*IsRet=*/false);
+  RISCVOutgoingValueHandler ArgHandler(MIRBuilder, MF.getRegInfo(), Call);
+  if (!determineAndHandleAssignments(ArgHandler, ArgAssigner, SplitArgInfos,
+                                     MIRBuilder, CC, Info.IsVarArg))
+    return false;
+
+  MIRBuilder.insertInstr(Call);
+
+  if (Info.OrigRet.Ty->isVoidTy())
+    return true;
+
+  // TODO: Only integer, pointer and aggregate types are supported now.
+  if (!Info.OrigRet.Ty->isIntOrPtrTy() && !Info.OrigRet.Ty->isAggregateType())
+    return false;
+
+  SmallVector<ArgInfo, 4> SplitRetInfos;
+  splitToValueTypes(Info.OrigRet, SplitRetInfos, DL, CC);
+
+  // Assignments should be handled *before* the merging of values takes place.
+  // To ensure this, the insert point is temporarily adjusted to just after the
+  // call instruction.
+  MachineBasicBlock::iterator CallInsertPt = Call;
+  MIRBuilder.setInsertPt(MIRBuilder.getMBB(), std::next(CallInsertPt));
+
+  RISCVIncomingValueAssigner RetAssigner(
+      CC == CallingConv::Fast ? RISCV::CC_RISCV_FastCC : RISCV::CC_RISCV,
+      /*IsRet=*/true);
+  RISCVCallReturnHandler RetHandler(MIRBuilder, MF.getRegInfo(), Call);
+  if (!determineAndHandleAssignments(RetHandler, RetAssigner, SplitRetInfos,
+                                     MIRBuilder, CC, Info.IsVarArg))
+    return false;
+
+  // Readjust insert point to end of basic block.
+  MIRBuilder.setMBB(MIRBuilder.getMBB());
+
+  return true;
 }

llvm/test/CodeGen/RISCV/GlobalISel/irtranslator/calls.ll

+; NOTE: Assertions have been autogenerated by utils/update_mir_test_checks.py
+; RUN: llc -mtriple=riscv32 -global-isel -stop-after=irtranslator -verify-machineinstrs < %s \
+; RUN:   | FileCheck -check-prefix=RV32I %s
+; RUN: llc -mtriple=riscv64 -global-isel -stop-after=irtranslator -verify-machineinstrs < %s \
+; RUN:   | FileCheck -check-prefix=RV64I %s
+
+declare void @void_noargs()
+
+define void @test_call_void_noargs() {
+
+  ; RV32I-LABEL: name: test_call_void_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_noargs, implicit-def $x1
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_noargs, implicit-def $x1
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_noargs()
+  ret void
+}
+
+declare void @void_args_i8(i8, i8)
+
+define void @test_call_void_args_i8() {
+
+  ; RV32I-LABEL: name: test_call_void_args_i8
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 0
+  ; RV32I-NEXT:   [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
+  ; RV32I-NEXT:   [[ANYEXT:%[0-9]+]]:_(s32) = G_ANYEXT [[C]](s8)
+  ; RV32I-NEXT:   [[ANYEXT1:%[0-9]+]]:_(s32) = G_ANYEXT [[C1]](s8)
+  ; RV32I-NEXT:   $x10 = COPY [[ANYEXT]](s32)
+  ; RV32I-NEXT:   $x11 = COPY [[ANYEXT1]](s32)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i8, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_args_i8
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 0
+  ; RV64I-NEXT:   [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
+  ; RV64I-NEXT:   [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT [[C]](s8)
+  ; RV64I-NEXT:   [[ANYEXT1:%[0-9]+]]:_(s64) = G_ANYEXT [[C1]](s8)
+  ; RV64I-NEXT:   $x10 = COPY [[ANYEXT]](s64)
+  ; RV64I-NEXT:   $x11 = COPY [[ANYEXT1]](s64)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i8, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_args_i8(i8 0, i8 1)
+  ret void
+}
+
+declare void @void_args_i8_zext(i8 zeroext, i8 zeroext)
+
+define void @test_call_void_args_i8_zext() {
+
+  ; RV32I-LABEL: name: test_call_void_args_i8_zext
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 0
+  ; RV32I-NEXT:   [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
+  ; RV32I-NEXT:   [[ZEXT:%[0-9]+]]:_(s32) = G_ZEXT [[C]](s8)
+  ; RV32I-NEXT:   [[ZEXT1:%[0-9]+]]:_(s32) = G_ZEXT [[C1]](s8)
+  ; RV32I-NEXT:   $x10 = COPY [[ZEXT]](s32)
+  ; RV32I-NEXT:   $x11 = COPY [[ZEXT1]](s32)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i8_zext, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_args_i8_zext
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s8) = G_CONSTANT i8 0
+  ; RV64I-NEXT:   [[C1:%[0-9]+]]:_(s8) = G_CONSTANT i8 1
+  ; RV64I-NEXT:   [[ZEXT:%[0-9]+]]:_(s64) = G_ZEXT [[C]](s8)
+  ; RV64I-NEXT:   [[ZEXT1:%[0-9]+]]:_(s64) = G_ZEXT [[C1]](s8)
+  ; RV64I-NEXT:   $x10 = COPY [[ZEXT]](s64)
+  ; RV64I-NEXT:   $x11 = COPY [[ZEXT1]](s64)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i8_zext, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_args_i8_zext(i8 zeroext 0, i8 zeroext 1)
+  ret void
+}
+
+declare void @void_args_i16_sext(i16 signext, i16 signext)
+
+define void @test_call_void_args_i16_sext() {
+
+  ; RV32I-LABEL: name: test_call_void_args_i16_sext
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 0
+  ; RV32I-NEXT:   [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 1
+  ; RV32I-NEXT:   [[SEXT:%[0-9]+]]:_(s32) = G_SEXT [[C]](s16)
+  ; RV32I-NEXT:   [[SEXT1:%[0-9]+]]:_(s32) = G_SEXT [[C1]](s16)
+  ; RV32I-NEXT:   $x10 = COPY [[SEXT]](s32)
+  ; RV32I-NEXT:   $x11 = COPY [[SEXT1]](s32)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i16_sext, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_args_i16_sext
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s16) = G_CONSTANT i16 0
+  ; RV64I-NEXT:   [[C1:%[0-9]+]]:_(s16) = G_CONSTANT i16 1
+  ; RV64I-NEXT:   [[SEXT:%[0-9]+]]:_(s64) = G_SEXT [[C]](s16)
+  ; RV64I-NEXT:   [[SEXT1:%[0-9]+]]:_(s64) = G_SEXT [[C1]](s16)
+  ; RV64I-NEXT:   $x10 = COPY [[SEXT]](s64)
+  ; RV64I-NEXT:   $x11 = COPY [[SEXT1]](s64)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i16_sext, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_args_i16_sext(i16 signext 0, i16 signext 1)
+  ret void
+}
+
+declare void @void_args_i32(i32, i32)
+
+define void @test_call_void_args_i32() {
+
+  ; RV32I-LABEL: name: test_call_void_args_i32
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
+  ; RV32I-NEXT:   [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
+  ; RV32I-NEXT:   $x10 = COPY [[C]](s32)
+  ; RV32I-NEXT:   $x11 = COPY [[C1]](s32)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i32, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_args_i32
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s32) = G_CONSTANT i32 0
+  ; RV64I-NEXT:   [[C1:%[0-9]+]]:_(s32) = G_CONSTANT i32 1
+  ; RV64I-NEXT:   [[ANYEXT:%[0-9]+]]:_(s64) = G_ANYEXT [[C]](s32)
+  ; RV64I-NEXT:   [[ANYEXT1:%[0-9]+]]:_(s64) = G_ANYEXT [[C1]](s32)
+  ; RV64I-NEXT:   $x10 = COPY [[ANYEXT]](s64)
+  ; RV64I-NEXT:   $x11 = COPY [[ANYEXT1]](s64)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i32, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_args_i32(i32 0, i32 1)
+  ret void
+}
+
+declare void @void_args_i64(i64, i64)
+
+define void @test_call_void_args_i64() {
+
+  ; RV32I-LABEL: name: test_call_void_args_i64
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
+  ; RV32I-NEXT:   [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 1
+  ; RV32I-NEXT:   [[UV:%[0-9]+]]:_(s32), [[UV1:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[C]](s64)
+  ; RV32I-NEXT:   [[UV2:%[0-9]+]]:_(s32), [[UV3:%[0-9]+]]:_(s32) = G_UNMERGE_VALUES [[C1]](s64)
+  ; RV32I-NEXT:   $x10 = COPY [[UV]](s32)
+  ; RV32I-NEXT:   $x11 = COPY [[UV1]](s32)
+  ; RV32I-NEXT:   $x12 = COPY [[UV2]](s32)
+  ; RV32I-NEXT:   $x13 = COPY [[UV3]](s32)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i64, implicit-def $x1, implicit $x10, implicit $x11, implicit $x12, implicit $x13
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_void_args_i64
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[C:%[0-9]+]]:_(s64) = G_CONSTANT i64 0
+  ; RV64I-NEXT:   [[C1:%[0-9]+]]:_(s64) = G_CONSTANT i64 1
+  ; RV64I-NEXT:   $x10 = COPY [[C]](s64)
+  ; RV64I-NEXT:   $x11 = COPY [[C1]](s64)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_args_i64, implicit-def $x1, implicit $x10, implicit $x11
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_args_i64(i64 0, i64 1)
+  ret void
+}
+
+declare i8 @i8_noargs()
+
+define void @test_call_i8_noargs() {
+
+  ; RV32I-LABEL: name: test_call_i8_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @i8_noargs, implicit-def $x1, implicit-def $x10
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $x10
+  ; RV32I-NEXT:   [[TRUNC:%[0-9]+]]:_(s8) = G_TRUNC [[COPY]](s32)
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_i8_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @i8_noargs, implicit-def $x1, implicit-def $x10
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(s64) = COPY $x10
+  ; RV64I-NEXT:   [[TRUNC:%[0-9]+]]:_(s8) = G_TRUNC [[COPY]](s64)
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call i8 @i8_noargs()
+  ret void
+}
+
+declare i16 @i16_noargs()
+
+define void @test_call_i16_noargs() {
+
+  ; RV32I-LABEL: name: test_call_i16_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @i16_noargs, implicit-def $x1, implicit-def $x10
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $x10
+  ; RV32I-NEXT:   [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s32)
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_i16_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @i16_noargs, implicit-def $x1, implicit-def $x10
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(s64) = COPY $x10
+  ; RV64I-NEXT:   [[TRUNC:%[0-9]+]]:_(s16) = G_TRUNC [[COPY]](s64)
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call i16 @i16_noargs()
+  ret void
+}
+
+declare i32 @i32_noargs()
+
+define void @test_call_i32_noargs() {
+
+  ; RV32I-LABEL: name: test_call_i32_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @i32_noargs, implicit-def $x1, implicit-def $x10
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $x10
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_i32_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @i32_noargs, implicit-def $x1, implicit-def $x10
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(s64) = COPY $x10
+  ; RV64I-NEXT:   [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call i32 @i32_noargs()
+  ret void
+}
+
+declare i64 @i64_noargs()
+
+define void @test_call_i64_noargs() {
+
+  ; RV32I-LABEL: name: test_call_i64_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @i64_noargs, implicit-def $x1, implicit-def $x10, implicit-def $x11
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $x10
+  ; RV32I-NEXT:   [[COPY1:%[0-9]+]]:_(s32) = COPY $x11
+  ; RV32I-NEXT:   [[MV:%[0-9]+]]:_(s64) = G_MERGE_VALUES [[COPY]](s32), [[COPY1]](s32)
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_i64_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @i64_noargs, implicit-def $x1, implicit-def $x10
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(s64) = COPY $x10
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call i64 @i64_noargs()
+  ret void
+}
+
+declare ptr @ptr_noargs()
+
+define void @test_call_ptr_noargs() {
+  ; RV32I-LABEL: name: test_call_ptr_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @ptr_noargs, implicit-def $x1, implicit-def $x10
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_ptr_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @ptr_noargs, implicit-def $x1, implicit-def $x10
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(p0) = COPY $x10
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call ptr @ptr_noargs()
+  ret void
+}
+
+declare [2 x i32] @i32x2_noargs()
+
+define void @test_call_i32x2_noargs() {
+  ; RV32I-LABEL: name: test_call_i32x2_noargs
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @i32x2_noargs, implicit-def $x1, implicit-def $x10, implicit-def $x11
+  ; RV32I-NEXT:   [[COPY:%[0-9]+]]:_(s32) = COPY $x10
+  ; RV32I-NEXT:   [[COPY1:%[0-9]+]]:_(s32) = COPY $x11
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_call_i32x2_noargs
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @i32x2_noargs, implicit-def $x1, implicit-def $x10, implicit-def $x11
+  ; RV64I-NEXT:   [[COPY:%[0-9]+]]:_(s64) = COPY $x10
+  ; RV64I-NEXT:   [[TRUNC:%[0-9]+]]:_(s32) = G_TRUNC [[COPY]](s64)
+  ; RV64I-NEXT:   [[COPY1:%[0-9]+]]:_(s64) = COPY $x11
+  ; RV64I-NEXT:   [[TRUNC1:%[0-9]+]]:_(s32) = G_TRUNC [[COPY1]](s64)
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  %a = call [2 x i32] @i32x2_noargs()
+  ret void
+}
+
+%struct.Foo = type { i32, i32, i32, i16, i8 }
+@foo = global %struct.Foo { i32 1, i32 2, i32 3, i16 4, i8 5 }, align 4
+
+declare void @void_byval_args(ptr byval(%struct.Foo) %f)
+
+define void @test_void_byval_args() {
+  ; RV32I-LABEL: name: test_void_byval_args
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[GV:%[0-9]+]]:_(p0) = G_GLOBAL_VALUE @foo
+  ; RV32I-NEXT:   $x10 = COPY [[GV]](p0)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_byval_args, implicit-def $x1, implicit $x10
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_void_byval_args
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[GV:%[0-9]+]]:_(p0) = G_GLOBAL_VALUE @foo
+  ; RV64I-NEXT:   $x10 = COPY [[GV]](p0)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_byval_args, implicit-def $x1, implicit $x10
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_byval_args(ptr byval(%struct.Foo) @foo)
+  ret void
+}
+
+declare void @void_sret_args(ptr sret(%struct.Foo) %f)
+
+define void @test_void_sret_args() {
+  ; RV32I-LABEL: name: test_void_sret_args
+  ; RV32I: bb.1.entry:
+  ; RV32I-NEXT:   [[GV:%[0-9]+]]:_(p0) = G_GLOBAL_VALUE @foo
+  ; RV32I-NEXT:   $x10 = COPY [[GV]](p0)
+  ; RV32I-NEXT:   PseudoCALL target-flags(riscv-call) @void_sret_args, implicit-def $x1, implicit $x10
+  ; RV32I-NEXT:   PseudoRET
+  ; RV64I-LABEL: name: test_void_sret_args
+  ; RV64I: bb.1.entry:
+  ; RV64I-NEXT:   [[GV:%[0-9]+]]:_(p0) = G_GLOBAL_VALUE @foo
+  ; RV64I-NEXT:   $x10 = COPY [[GV]](p0)
+  ; RV64I-NEXT:   PseudoCALL target-flags(riscv-call) @void_sret_args, implicit-def $x1, implicit $x10
+  ; RV64I-NEXT:   PseudoRET
+entry:
+  call void @void_sret_args(ptr sret(%struct.Foo) @foo)
+  ret void
+}