Commit 26ab827c authored by Sean Fertile's avatar Sean Fertile
Browse files

[PowerPC][AIX] Add support for lowering int/float/double formal arguments. 

This patch adds LowerFormalArguments_AIX, support is added for lowering
int, float, and double formal arguments into general purpose and
floating point registers only.

The aix calling convention testcase have been redone to test for caller
and callee functionality in the same lit test.

Patch by Zarko Todorovski!

Differential Revision: https://reviews.llvm.org/D69578
parent 76fd58d0

llvm/lib/Target/PowerPC/PPCISelLowering.cpp

+115 −3
Original line number Diff line number Diff line
@@ -3418,15 +3418,16 @@ SDValue PPCTargetLowering::LowerFormalArguments( 
    SDValue Chain, CallingConv::ID CallConv, bool isVarArg,

    const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,

    SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {

  if (Subtarget.isAIXABI())

    return LowerFormalArguments_AIX(Chain, CallConv, isVarArg, Ins, dl, DAG,

                                    InVals);

  if (Subtarget.is64BitELFABI())

    return LowerFormalArguments_64SVR4(Chain, CallConv, isVarArg, Ins, dl, DAG,

                                       InVals);

  else if (Subtarget.is32BitELFABI())

  if (Subtarget.is32BitELFABI())

    return LowerFormalArguments_32SVR4(Chain, CallConv, isVarArg, Ins, dl, DAG,

                                       InVals);













  // FIXME: We are using this for both AIX and Darwin. We should add appropriate













  // AIX testing, and rename it appropriately.















  return LowerFormalArguments_Darwin(Chain, CallConv, isVarArg, Ins, dl, DAG,















                                     InVals);















}










@@ -6808,6 +6809,117 @@ static bool CC_AIX(unsigned ValNo, MVT ValVT, MVT LocVT,













  }















}



























static const TargetRegisterClass *getRegClassForSVT(MVT::SimpleValueType SVT,













                                                    bool IsPPC64) {













  assert((IsPPC64 || SVT != MVT::i64) &&













         "i64 should have been split for 32-bit codegen.");

























  switch (SVT) {













  default:













    report_fatal_error("Unexpected value type for formal argument");













  case MVT::i1:













  case MVT::i32:













  case MVT::i64:













    return IsPPC64 ? &PPC::G8RCRegClass : &PPC::GPRCRegClass;













  case MVT::f32:













    return &PPC::F4RCRegClass;













  case MVT::f64:













    return &PPC::F8RCRegClass;













  }













}

























static SDValue truncateScalarIntegerArg(ISD::ArgFlagsTy Flags, EVT ValVT,













                                        SelectionDAG &DAG, SDValue ArgValue,













                                        MVT LocVT, const SDLoc &dl) {













  assert(ValVT.isScalarInteger() && LocVT.isScalarInteger());













  assert(ValVT.getSizeInBits() < LocVT.getSizeInBits());

























  if (Flags.isSExt())













    ArgValue = DAG.getNode(ISD::AssertSext, dl, LocVT, ArgValue,













                           DAG.getValueType(ValVT));













  else if (Flags.isZExt())













    ArgValue = DAG.getNode(ISD::AssertZext, dl, LocVT, ArgValue,













                           DAG.getValueType(ValVT));

























  return DAG.getNode(ISD::TRUNCATE, dl, ValVT, ArgValue);













}

























SDValue PPCTargetLowering::LowerFormalArguments_AIX(













    SDValue Chain, CallingConv::ID CallConv, bool isVarArg,













    const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,













    SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {

























  assert((CallConv == CallingConv::C || CallConv == CallingConv::Cold ||













          CallConv == CallingConv::Fast) &&













         "Unexpected calling convention!");

























  if (isVarArg)













    report_fatal_error("This call type is unimplemented on AIX.");

























  if (getTargetMachine().Options.GuaranteedTailCallOpt)













    report_fatal_error("Tail call support is unimplemented on AIX.");

























  if (useSoftFloat())













    report_fatal_error("Soft float support is unimplemented on AIX.");

























  const PPCSubtarget &Subtarget =













      static_cast<const PPCSubtarget &>(DAG.getSubtarget());













  if (Subtarget.hasQPX())













    report_fatal_error("QPX support is not supported on AIX.");

























  const bool IsPPC64 = Subtarget.isPPC64();













  const unsigned PtrByteSize = IsPPC64 ? 8 : 4;

























  // Assign locations to all of the incoming arguments.













  SmallVector<CCValAssign, 16> ArgLocs;













  MachineFunction &MF = DAG.getMachineFunction();













  CCState CCInfo(CallConv, isVarArg, MF, ArgLocs, *DAG.getContext());

























  // Reserve space for the linkage area on the stack.













  const unsigned LinkageSize = Subtarget.getFrameLowering()->getLinkageSize();













  // On AIX a minimum of 8 words is saved to the parameter save area.













  const unsigned MinParameterSaveArea = 8 * PtrByteSize;













  CCInfo.AllocateStack(LinkageSize + MinParameterSaveArea, PtrByteSize);













  CCInfo.AnalyzeFormalArguments(Ins, CC_AIX);

























  for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i) {













    CCValAssign &VA = ArgLocs[i];













    SDValue ArgValue;













    ISD::ArgFlagsTy Flags = Ins[i].Flags;













    if (VA.isRegLoc()) {













      EVT ValVT = VA.getValVT();













      MVT LocVT = VA.getLocVT();













      MVT::SimpleValueType SVT = ValVT.getSimpleVT().SimpleTy;













      unsigned VReg =













          MF.addLiveIn(VA.getLocReg(), getRegClassForSVT(SVT, IsPPC64));













      ArgValue = DAG.getCopyFromReg(Chain, dl, VReg, LocVT);













      if (ValVT.isScalarInteger() &&













          (ValVT.getSizeInBits() < LocVT.getSizeInBits())) {













        ArgValue =













            truncateScalarIntegerArg(Flags, ValVT, DAG, ArgValue, LocVT, dl);













      }













      InVals.push_back(ArgValue);













    } else {













      report_fatal_error("Handling of formal arguments on the stack is "













                         "unimplemented!");













    }













  }

























  // Area that is at least reserved in the caller of this function.













  unsigned MinReservedArea = CCInfo.getNextStackOffset();

























  // Set the size that is at least reserved in caller of this function. Tail













  // call optimized function's reserved stack space needs to be aligned so













  // that taking the difference between two stack areas will result in an













  // aligned stack.













  MinReservedArea =













      EnsureStackAlignment(Subtarget.getFrameLowering(), MinReservedArea);













  PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();













  FuncInfo->setMinReservedArea(MinReservedArea);

























  return Chain;













}



























SDValue PPCTargetLowering::LowerCall_AIX(















    SDValue Chain, SDValue Callee, CallingConv::ID CallConv, bool isVarArg,















    bool isTailCall, bool isPatchPoint,

































llvm/lib/Target/PowerPC/PPCISelLowering.h



+4
−0






























Original line number
Diff line number
Diff line








@@ -1121,6 +1121,10 @@ namespace llvm {













                              SelectionDAG &DAG, SDValue ArgVal,















                              const SDLoc &dl) const;





























    SDValue LowerFormalArguments_AIX(













        SDValue Chain, CallingConv::ID CallConv, bool isVarArg,













        const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,













        SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const;















    SDValue LowerFormalArguments_Darwin(















        SDValue Chain, CallingConv::ID CallConv, bool isVarArg,















        const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,

































llvm/test/CodeGen/PowerPC/aix_cc_abi.ll
0 → 100644



+614
−0




























File added.
Preview size limit exceeded, changes collapsed.
























llvm/test/CodeGen/PowerPC/aix_fpr_param.ll
deleted100644 → 0



+0
−150






























Original line number
Diff line number
Diff line













; RUN: llc -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp < %s | \













; RUN: FileCheck --check-prefix=32BIT %s



























; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp < %s | \













; RUN: FileCheck --check-prefix=64BIT %s



























@f1 = global float 0.000000e+00, align 4













@d1 = global double 0.000000e+00, align 8



























define void @call_test_float() {













entry:













; 32BIT: renamable $r3 = LWZtoc @f1, $r2 :: (load 4 from got)













; 32BIT: renamable $f1 = LFS 0, killed renamable $r3 :: (dereferenceable load 4 from @f1)













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: BL_NOP <mcsymbol .test_float>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: renamable $x3 = LDtoc @f1, $x2 :: (load 8 from got)













; 64BIT: renamable $f1 = LFS 0, killed renamable $x3 :: (dereferenceable load 4 from @f1)













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: BL8_NOP <mcsymbol .test_float>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  %0 = load float, float* @f1, align 4













  call void @test_float(float %0)













  ret void













}



























declare void @test_float(float)



























define void @call_test_floats() {













entry:













; 32BIT: renamable $r3 = LWZtoc @f1, $r2 :: (load 4 from got)













; 32BIT: renamable $f1 = LFS 0, killed renamable $r3 :: (dereferenceable load 4 from @f1)













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $f2 = COPY renamable $f1













; 32BIT: $f3 = COPY renamable $f1













; 32BIT: BL_NOP <mcsymbol .test_floats>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: renamable $x3 = LDtoc @f1, $x2 :: (load 8 from got)













; 64BIT: renamable $f1 = LFS 0, killed renamable $x3 :: (dereferenceable load 4 from @f1)













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $f2 = COPY renamable $f1













; 64BIT: $f3 = COPY renamable $f1













; 64BIT: BL8_NOP <mcsymbol .test_floats>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  %0 = load float, float* @f1, align 4













  call void @test_floats(float %0, float %0, float %0)













  ret void













}



























declare void @test_floats(float, float, float)



























define void @call_test_double() {













entry:













; 32BIT: renamable $r3 = LWZtoc @d1, $r2 :: (load 4 from got)













; 32BIT: renamable $f1 = LFD 0, killed renamable $r3 :: (dereferenceable load 8 from @d1)













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: BL_NOP <mcsymbol .test_double>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: renamable $x3 = LDtoc @d1, $x2 :: (load 8 from got)













; 64BIT: renamable $f1 = LFD 0, killed renamable $x3 :: (dereferenceable load 8 from @d1)













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: BL8_NOP <mcsymbol .test_double>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  %0 = load double, double* @d1, align 8













  call void @test_double(double %0)













  ret void













}



























declare void @test_double(double)



























define void @call_test_fpr_max() {













entry:













; 32BIT: renamable $r3 = LWZtoc @d1, $r2 :: (load 4 from got)













; 32BIT: renamable $f1 = LFD 0, killed renamable $r3 :: (dereferenceable load 8 from @d1)













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $f2 = COPY renamable $f1













; 32BIT: $f3 = COPY renamable $f1













; 32BIT: $f4 = COPY renamable $f1













; 32BIT: $f5 = COPY renamable $f1













; 32BIT: $f6 = COPY renamable $f1













; 32BIT: $f7 = COPY renamable $f1













; 32BIT: $f8 = COPY renamable $f1













; 32BIT: $f9 = COPY renamable $f1













; 32BIT: $f10 = COPY renamable $f1













; 32BIT: $f11 = COPY renamable $f1













; 32BIT: $f12 = COPY renamable $f1













; 32BIT: $f13 = COPY renamable $f1













; 32BIT: BL_NOP <mcsymbol .test_fpr_max>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit killed $f4, implicit killed $f5, implicit killed $f6, implicit killed $f7, implicit killed $f8, implicit killed $f9, implicit killed $f10, implicit killed $f11, implicit killed $f12, implicit killed $f13, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: renamable $x3 = LDtoc @d1, $x2 :: (load 8 from got)













; 64BIT: renamable $f1 = LFD 0, killed renamable $x3 :: (dereferenceable load 8 from @d1)













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $f2 = COPY renamable $f1













; 64BIT: $f3 = COPY renamable $f1













; 64BIT: $f4 = COPY renamable $f1













; 64BIT: $f5 = COPY renamable $f1













; 64BIT: $f6 = COPY renamable $f1













; 64BIT: $f7 = COPY renamable $f1













; 64BIT: $f8 = COPY renamable $f1













; 64BIT: $f9 = COPY renamable $f1













; 64BIT: $f10 = COPY renamable $f1













; 64BIT: $f11 = COPY renamable $f1













; 64BIT: $f12 = COPY renamable $f1













; 64BIT: $f13 = COPY renamable $f1













; 64BIT: BL8_NOP <mcsymbol .test_fpr_max>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit killed $f2, implicit killed $f3, implicit killed $f4, implicit killed $f5, implicit killed $f6, implicit killed $f7, implicit killed $f8, implicit killed $f9, implicit killed $f10, implicit killed $f11, implicit killed $f12, implicit killed $f13, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  %0 = load double, double* @d1, align 8













  call void @test_fpr_max(double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0, double %0)













  ret void













}



























declare void @test_fpr_max(double, double, double, double, double, double, double, double, double, double, double, double, double)



























define void @call_test_mix() {













entry:













; 32BIT: renamable $r3 = LWZtoc @f1, $r2 :: (load 4 from got)













; 32BIT: renamable $r4 = LWZtoc @d1, $r2 :: (load 4 from got)













; 32BIT: renamable $f1 = LFS 0, killed renamable $r3 :: (dereferenceable load 4 from @f1)













; 32BIT: renamable $f2 = LFD 0, killed renamable $r4 :: (dereferenceable load 8 from @d1)













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r4 = LI 1













; 32BIT: $r7 = LI 97













; 32BIT: BL_NOP <mcsymbol .test_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $f1, implicit $r4, implicit $f2, implicit killed $r7, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: renamable $x3 = LDtoc @f1, $x2 :: (load 8 from got)













; 64BIT: renamable $x4 = LDtoc @d1, $x2 :: (load 8 from got)













; 64BIT: renamable $f1 = LFS 0, killed renamable $x3 :: (dereferenceable load 4 from @f1)













; 64BIT: renamable $f2 = LFD 0, killed renamable $x4 :: (dereferenceable load 8 from @d1)













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x4 = LI8 1













; 64BIT: $x6 = LI8 97













; 64BIT: BL8_NOP <mcsymbol .test_mix>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $f1, implicit $x4, implicit $f2, implicit killed $x6, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  %0 = load float, float* @f1, align 4













  %1 = load double, double* @d1, align 8













  call void @test_mix(float %0, i32 1, double %1, i8 signext 97)













  ret void













}



























declare void @test_mix(float, i32, double, i8 signext)
























llvm/test/CodeGen/PowerPC/aix_gpr_param.ll
deleted100644 → 0



+0
−199






























Original line number
Diff line number
Diff line













; RUN: llc -mtriple powerpc-ibm-aix-xcoff -stop-after=machine-cp < %s | \













; RUN: FileCheck --check-prefix=32BIT %s



























; RUN: llc -mtriple powerpc64-ibm-aix-xcoff -stop-after=machine-cp < %s | \













; RUN: FileCheck --check-prefix=64BIT %s



























define void @call_test_char() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 97













; 32BIT: BL_NOP <mcsymbol .test_char>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 97













; 64BIT: BL8_NOP <mcsymbol .test_char>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_char(i8 signext 97)













  ret void













}



























define void @call_test_chars() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 97













; 32BIT: $r4 = LI 97













; 32BIT: $r5 = LI 97













; 32BIT: $r6 = LI 97













; 32BIT: BL_NOP <mcsymbol .test_chars>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 97













; 64BIT: $x4 = LI8 97













; 64BIT: $x5 = LI8 97













; 64BIT: $x6 = LI8 97













; 64BIT: BL8_NOP <mcsymbol .test_chars>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_chars(i8 signext 97, i8 signext 97, i8 signext 97, i8 signext 97)













  ret void













}



























define void @call_test_chars_mix() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 97













; 32BIT: $r4 = LI 225













; 32BIT: $r5 = LI 97













; 32BIT: $r6 = LI -31













; 32BIT: BL_NOP <mcsymbol .test_chars_mix>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 97













; 64BIT: $x4 = LI8 225













; 64BIT: $x5 = LI8 97













; 64BIT: $x6 = LI8 -31













; 64BIT: BL8_NOP <mcsymbol .test_chars_mix>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_chars_mix(i8 signext 97, i8 zeroext -31, i8 zeroext 97, i8 signext -31)













  ret void













}



























define void @call_test_int() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 1













; 32BIT: BL_NOP <mcsymbol .test_int>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 1













; 64BIT: BL8_NOP <mcsymbol .test_int>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_int(i32 1)













  ret void













}



























define void @call_test_ints() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 1













; 32BIT: $r4 = LI 1













; 32BIT: $r5 = LI 1













; 32BIT: $r6 = LI 1













; 32BIT: $r7 = LI 1













; 32BIT: $r8 = LI 1













; 32BIT: $r9 = LI 1













; 32BIT: $r10 = LI 1













; 32BIT: BL_NOP <mcsymbol .test_ints>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit killed $r5, implicit killed $r6, implicit killed $r7, implicit killed $r8, implicit killed $r9, implicit killed $r10, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 1













; 64BIT: $x4 = LI8 1













; 64BIT: $x5 = LI8 1













; 64BIT: $x6 = LI8 1













; 64BIT: $x7 = LI8 1













; 64BIT: $x8 = LI8 1













; 64BIT: $x9 = LI8 1













; 64BIT: $x10 = LI8 1













; 64BIT: BL8_NOP <mcsymbol .test_ints>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit killed $x4, implicit killed $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_ints(i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1)













  ret void













}



























define void @call_test_ints_64bit() {













entry:













; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: renamable $x3 = LI8 1













; 64BIT: renamable $x5 = RLDICR killed renamable $x3, 31, 32













; 64BIT: $x3 = LI8 1













; 64BIT: $x4 = LI8 1













; 64BIT: $x6 = LIS8 32768













; 64BIT: $x7 = LI8 1













; 64BIT: $x8 = LI8 1













; 64BIT: $x9 = LI8 1













; 64BIT: $x10 = LI8 1













; 64BIT: BL8_NOP <mcsymbol .test_ints_64bit>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit killed $x4, implicit $x5, implicit killed $x6, implicit killed $x7, implicit killed $x8, implicit killed $x9, implicit killed $x10, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_ints_64bit(i32 signext 1, i32 zeroext 1, i32 zeroext 2147483648, i32 signext -2147483648, i32 signext 1, i32 signext 1, i32 signext 1, i32 signext 1)













  ret void













}



























define void @call_test_i1() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 1













; 32BIT: BL_NOP <mcsymbol .test_i1>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 1













; 64BIT: BL8_NOP <mcsymbol .test_i1>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_i1(i1 1)













  ret void













}



























define void @call_test_i64() {













entry:













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: $r3 = LI 0













; 32BIT: $r4 = LI 1













; 32BIT: BL_NOP <mcsymbol .test_i64>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit killed $r3, implicit killed $r4, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: $x3 = LI8 1













; 64BIT: BL8_NOP <mcsymbol .test_i64>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit killed $x3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  call void @test_i64(i64 1)













  ret void













}



























define void @call_test_int_ptr() {













entry:













  %b = alloca i32, align 4













; 32BIT: ADJCALLSTACKDOWN 56, 0, implicit-def dead $r1, implicit $r1













; 32BIT: renamable $r3 = ADDI %stack.0.b, 0













; 32BIT: BL_NOP <mcsymbol .test_int_ptr>, csr_aix32, implicit-def dead $lr, implicit $rm, implicit $r3, implicit $r2, implicit-def $r1













; 32BIT: ADJCALLSTACKUP 56, 0, implicit-def dead $r1, implicit $r1



























; 64BIT: ADJCALLSTACKDOWN 112, 0, implicit-def dead $r1, implicit $r1













; 64BIT: renamable $x3 = ADDI8 %stack.0.b, 0













; 64BIT: BL8_NOP <mcsymbol .test_int_ptr>, csr_aix64, implicit-def dead $lr8, implicit $rm, implicit $x3, implicit $x2, implicit-def $r1













; 64BIT: ADJCALLSTACKUP 112, 0, implicit-def dead $r1, implicit $r1



























  store i32 0, i32* %b, align 4













  call void @test_int_ptr(i32* %b)













  ret void













}



























declare void @test_char(i8 signext)



























declare void @test_chars(i8 signext, i8 signext, i8 signext, i8 signext)



























declare void @test_chars_mix(i8 signext, i8 zeroext, i8 zeroext, i8 signext)



























declare void @test_int(i32)



























declare void @test_ints(i32, i32, i32, i32, i32, i32, i32, i32)



























declare void @test_ints_64bit(i32 signext, i32 zeroext, i32 zeroext, i32 signext, i32 signext, i32 signext, i32 signext, i32 signext)



























declare void @test_i1(i1)



























declare void @test_i64(i64)



























declare void @test_int_ptr(i32*)