[Sparc] Get sret arg size from CallLoweringInfo.getArgs()

[dcederman]

Summary

Looking at the callee argument list, as is done now, might not work if the function has been typecasted into one that is expected to return a struct. This change also simplifies the code.

The isFP128ABICall() function can be removed as it is no longer needed. The test in fp128.ll has been updated to verify this.

[jyknight]

Nice simplification.

lib/Target/Sparc/SparcISelLowering.cpp

828 ↗

(On Diff #151110)

Please change this to cast instead of dyn_cast, since we can't handle a NULL return value anyhow.

I suspect this probably should be getArgs()[Outs[realArgIdx].OrigArgIndex] instead of [i]?

[dcederman]

Changed dyn_cast to cast. SRet is only allowed on the first argument, checked by LowerFormalArguments_32 at line 406, so I replaced [i] with [0].

llvm/trunk/lib/Target/Sparc/SparcISelLowering.h

public:
     SDValue LowerConstantPool(SDValue Op, SelectionDAG &DAG) const;
     SDValue LowerBlockAddress(SDValue Op, SelectionDAG &DAG) const;
 
     SDValue LowerEH_SJLJ_SETJMP(SDValue Op, SelectionDAG &DAG,
                                 const SparcTargetLowering &TLI) const ;
     SDValue LowerEH_SJLJ_LONGJMP(SDValue Op, SelectionDAG &DAG,
                                  const SparcTargetLowering &TLI) const ;
 
-    unsigned getSRetArgSize(SelectionDAG &DAG, SDValue Callee) const;
     SDValue withTargetFlags(SDValue Op, unsigned TF, SelectionDAG &DAG) const;
     SDValue makeHiLoPair(SDValue Op, unsigned HiTF, unsigned LoTF,
                          SelectionDAG &DAG) const;
     SDValue makeAddress(SDValue Op, SelectionDAG &DAG) const;
 
     SDValue LowerF128_LibCallArg(SDValue Chain, ArgListTy &Args, SDValue Arg,
                                  const SDLoc &DL, SelectionDAG &DAG) const;
     SDValue LowerF128Op(SDValue Op, SelectionDAG &DAG,

llvm/trunk/lib/Target/Sparc/SparcISelLowering.cpp

SparcTargetLowering::LowerCall_32(TargetLowering::CallLoweringInfo &CLI,
 
   Chain = DAG.getCALLSEQ_START(Chain, ArgsSize, 0, dl);
 
   SmallVector<std::pair<unsigned, SDValue>, 8> RegsToPass;
   SmallVector<SDValue, 8> MemOpChains;
 
   const unsigned StackOffset = 92;
   bool hasStructRetAttr = false;
+  unsigned SRetArgSize = 0;
   // Walk the register/memloc assignments, inserting copies/loads.
   for (unsigned i = 0, realArgIdx = 0, byvalArgIdx = 0, e = ArgLocs.size();
        i != e;
        ++i, ++realArgIdx) {
     CCValAssign &VA = ArgLocs[i];
     SDValue Arg = OutVals[realArgIdx];
 
     ISD::ArgFlagsTy Flags = Outs[realArgIdx].Flags;
if (Flags.isSRet()) {
       assert(VA.needsCustom());
       // store SRet argument in %sp+64
       SDValue StackPtr = DAG.getRegister(SP::O6, MVT::i32);
       SDValue PtrOff = DAG.getIntPtrConstant(64, dl);
       PtrOff = DAG.getNode(ISD::ADD, dl, MVT::i32, StackPtr, PtrOff);
       MemOpChains.push_back(
           DAG.getStore(Chain, dl, Arg, PtrOff, MachinePointerInfo()));
       hasStructRetAttr = true;
+      // sret only allowed on first argument
+      assert(Outs[realArgIdx].OrigArgIndex == 0);
+      PointerType *Ty = cast<PointerType>(CLI.getArgs()[0].Ty);
+      Type *ElementTy = Ty->getElementType();
+      SRetArgSize = DAG.getDataLayout().getTypeAllocSize(ElementTy);
       continue;
     }
 
     if (VA.needsCustom()) {
       assert(VA.getLocVT() == MVT::f64 || VA.getLocVT() == MVT::v2i32);
 
       if (VA.isMemLoc()) {
         unsigned Offset = VA.getLocMemOffset() + StackOffset;
SparcTargetLowering::LowerCall_32(TargetLowering::CallLoweringInfo &CLI,
   // stuck together.
   SDValue InFlag;
   for (unsigned i = 0, e = RegsToPass.size(); i != e; ++i) {
     unsigned Reg = toCallerWindow(RegsToPass[i].first);
     Chain = DAG.getCopyToReg(Chain, dl, Reg, RegsToPass[i].second, InFlag);
     InFlag = Chain.getValue(1);
   }
 
-  unsigned SRetArgSize = (hasStructRetAttr)? getSRetArgSize(DAG, Callee):0;
   bool hasReturnsTwice = hasReturnsTwiceAttr(DAG, Callee, CLI.CS);
 
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   // Likewise ExternalSymbol -> TargetExternalSymbol.
   unsigned TF = isPositionIndependent() ? SparcMCExpr::VK_Sparc_WPLT30 : 0;
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
     Callee = DAG.getTargetGlobalAddress(G->getGlobal(), dl, MVT::i32, 0, TF);
unsigned Reg = StringSwitch<unsigned>(RegName)
     .Default(0);
 
   if (Reg)
     return Reg;
 
   report_fatal_error("Invalid register name global variable");
 }
 
-// This functions returns true if CalleeName is a ABI function that returns
-// a long double (fp128).
-static bool isFP128ABICall(const char *CalleeName)
-{
-  static const char *const ABICalls[] =
-    {  "_Q_add", "_Q_sub", "_Q_mul", "_Q_div",
-       "_Q_sqrt", "_Q_neg",
-       "_Q_itoq", "_Q_stoq", "_Q_dtoq", "_Q_utoq",
-       "_Q_lltoq", "_Q_ulltoq",
-       nullptr
-    };
-  for (const char * const *I = ABICalls; *I != nullptr; ++I)
-    if (strcmp(CalleeName, *I) == 0)
-      return true;
-  return false;
-}
-
-unsigned
-SparcTargetLowering::getSRetArgSize(SelectionDAG &DAG, SDValue Callee) const
-{
-  const Function *CalleeFn = nullptr;
-  if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
-    CalleeFn = dyn_cast<Function>(G->getGlobal());
-  } else if (ExternalSymbolSDNode *E =
-             dyn_cast<ExternalSymbolSDNode>(Callee)) {
-    const Function &F = DAG.getMachineFunction().getFunction();
-    const Module *M = F.getParent();
-    const char *CalleeName = E->getSymbol();
-    CalleeFn = M->getFunction(CalleeName);
-    if (!CalleeFn && isFP128ABICall(CalleeName))
-      return 16; // Return sizeof(fp128)
-  }
-
-  if (!CalleeFn)
-    return 0;
-
-  // It would be nice to check for the sret attribute on CalleeFn here,
-  // but since it is not part of the function type, any check will misfire.
-
-  PointerType *Ty = cast<PointerType>(CalleeFn->arg_begin()->getType());
-  Type *ElementTy = Ty->getElementType();
-  return DAG.getDataLayout().getTypeAllocSize(ElementTy);
-}
-
-
 // Fixup floating point arguments in the ... part of a varargs call.
 //
 // The SPARC v9 ABI requires that floating point arguments are treated the same
 // as integers when calling a varargs function. This does not apply to the
 // fixed arguments that are part of the function's prototype.
 //
 // This function post-processes a CCValAssign array created by
 // AnalyzeCallOperands().

llvm/trunk/test/CodeGen/SPARC/cast-sret-func.ll

+; RUN: llc < %s -march=sparc
+
+; CHECK: call func
+; CHECK: st %i0, [%sp+64]
+; CHECK: unimp 8
+
+%struct = type { i32, i32 }
+
+define void @test() nounwind {
+entry:
+  %tmp = alloca %struct, align 4
+  call void bitcast (void ()* @func to void (%struct*)*)
+    (%struct* nonnull sret %tmp)
+  ret void
+}
+
+declare void @func()

llvm/trunk/test/CodeGen/SPARC/fp128.ll

 ; RUN: llc < %s -march=sparc -mattr=hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=HARD --check-prefix=BE
 ; RUN: llc < %s -march=sparcel -mattr=hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=HARD --check-prefix=EL
 ; RUN: llc < %s -march=sparc -mattr=-hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=SOFT --check-prefix=BE
 ; RUN: llc < %s -march=sparcel -mattr=-hard-quad-float | FileCheck %s --check-prefix=CHECK --check-prefix=SOFT --check-prefix=EL
 
 
 ; CHECK-LABEL: f128_ops:
 ; CHECK:      ldd
 ; CHECK:      ldd
 ; CHECK:      ldd
 ; CHECK:      ldd
 ; HARD:       faddq [[R0:.+]],  [[R1:.+]],  [[R2:.+]]
 ; HARD:       fsubq [[R2]], [[R3:.+]], [[R4:.+]]
 ; HARD:       fmulq [[R4]], [[R5:.+]], [[R6:.+]]
 ; HARD:       fdivq [[R6]], [[R2]]
 ; SOFT:       call _Q_add
+; SOFT:       unimp 16
 ; SOFT:       call _Q_sub
+; SOFT:       unimp 16
 ; SOFT:       call _Q_mul
+; SOFT:       unimp 16
 ; SOFT:       call _Q_div
+; SOFT:       unimp 16
 ; CHECK:      std
 ; CHECK:      std
 
 define void @f128_ops(fp128* noalias sret %scalar.result, fp128* byval %a, fp128* byval %b, fp128* byval %c, fp128* byval %d) {
 entry:
   %0 = load fp128, fp128* %a, align 8
   %1 = load fp128, fp128* %b, align 8
   %2 = load fp128, fp128* %c, align 8
entry:
   ret void
 }
 
 declare fp128 @llvm.fabs.f128(fp128) nounwind readonly
 
 ; CHECK-LABEL: int_to_f128:
 ; HARD:       fitoq
 ; SOFT:       _Q_itoq
+; SOFT:       unimp 16
 
 define void @int_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
 entry:
   %0 = sitofp i32 %i to fp128
   store fp128 %0, fp128* %scalar.result, align 8
   ret void
 }
 
 ; CHECK-LABEL: fp128_unaligned:
 ; CHECK:       ldub
 ; HARD:        faddq
 ; SOFT:       call _Q_add
+; SOFT:       unimp 16
 ; CHECK:       stb
 ; CHECK:       ret
 
 define void @fp128_unaligned(fp128* %a, fp128* %b, fp128* %c) {
 entry:
   %0 = load fp128, fp128* %a, align 1
   %1 = load fp128, fp128* %b, align 1
   %2 = fadd fp128 %0, %1
   store fp128 %2, fp128* %c, align 1
   ret void
 }
 
 ; CHECK-LABEL: uint_to_f128:
 ; HARD:       fdtoq
 ; SOFT:       _Q_utoq
+; SOFT:       unimp 16
 
 define void @uint_to_f128(fp128* noalias sret %scalar.result, i32 %i) {
 entry:
   %0 = uitofp i32 %i to fp128
   store fp128 %0, fp128* %scalar.result, align 8
   ret void
 }
 

 }
 
 ; CHECK-LABEL:   test_itoq_qtoi
 ; HARD-DAG:      call _Q_lltoq
 ; HARD-DAG:      call _Q_qtoll
 ; HARD-DAG:      fitoq
 ; HARD-DAG:      fqtoi
 ; SOFT-DAG:      call _Q_lltoq
+; SOFT-DAG:      unimp 16
 ; SOFT-DAG:      call _Q_qtoll
 ; SOFT-DAG:      call _Q_itoq
+; SOFT-DAG:      unimp 16
 ; SOFT-DAG:      call _Q_qtoi
 
 define void @test_itoq_qtoi(i64 %a, i32 %b, fp128* %c, fp128* %d, i64* %ptr0, fp128* %ptr1) {
 entry:
   %0 = sitofp i64 %a to fp128
   store  fp128 %0, fp128* %ptr1, align 8
   %cval = load fp128, fp128* %c, align 8
   %1 = fptosi fp128 %cval to i64
   store  i64 %1, i64* %ptr0, align 8
   %2 = sitofp i32 %b to fp128
   store  fp128 %2, fp128* %ptr1, align 8
   %dval = load fp128, fp128* %d, align 8
   %3 = fptosi fp128 %dval to i32
   %4 = bitcast i64* %ptr0 to i32*
   store  i32 %3, i32* %4, align 8
   ret void
 }
 
 ; CHECK-LABEL:   test_utoq_qtou:
 ; CHECK-DAG:     call _Q_ulltoq
 ; CHECK-DAG:     call _Q_qtoull
 ; HARD-DAG:      fdtoq
 ; HARD-DAG:      fqtoi
 ; SOFT-DAG:      call _Q_utoq
+; SOFT-DAG:      unimp 16
 ; SOFT-DAG:      call _Q_qtou
 
 define void @test_utoq_qtou(i64 %a, i32 %b, fp128* %c, fp128* %d, i64* %ptr0, fp128* %ptr1) {
 entry:
   %0 = uitofp i64 %a to fp128
   store  fp128 %0, fp128* %ptr1, align 8
   %cval = load fp128, fp128* %c, align 8
   %1 = fptoui fp128 %cval to i64