[WIP][Sparc] Fix long double on 32-bit Solaris/SPARC

[ro]

Summary

The SysVr4 SPARC psABI prescribes 128-bit long double on 32-bit Sparc, and Solaris follows that as do some other OSes. However, clang doesn't support that.

This is not yet complete, but I need guidance in some points and believe it's easier to do so here than in the corresponding Bug 42493

There are several noteworthy issues:

• long double is 128-bit IEEEquad format, but with 64-bit alignment unlike SPARC V9 which uses 128-bit alignment.
• long double is passed and returned by reference, just like structures and unions.
• long double _Complex, a Sun extension not in the psABI, is always returned in registers.
• compiler-rt uses __uint128_t for long double support which isn't available for 32-bit compilations by default. It's currently enabled with -fforce-enable-int128 which gcc doesn't support.

Right now the basic long double support seems to work (need to double-check with GCC's gcc.dg/compat testsuite), but compiling compiler-rt/lib/builtins/divtc3.c fails:

Assertion failed: isRegLoc(), file /vol/llvm/src/llvm-project/local/llvm/include/llvm/CodeGen/CallingConvLower.h, line 150

11 libc.so.1 0xffffffff7edfb158 _assert + 104
12 clang-12  0x00000001038fdf90 llvm::SparcTargetLowering::LowerCall_32(llvm::TargetLowering::CallLoweringInfo&, llvm::SmallVectorImpl<llvm::SDValue>&) const + 11888
13 clang-12  0x00000001038f9010 llvm::SparcTargetLowering::LowerCall(llvm::TargetLowering::CallLoweringInfo&, llvm::SmallVectorImpl<llvm::SDValue>&) const + 60
14 clang-12  0x0000000106062f54 llvm::TargetLowering::LowerCallTo(llvm::TargetLowering::CallLoweringInfo&) const + 7724
15 clang-12  0x0000000106039704 (anonymous namespace)::SelectionDAGLegalize::ExpandLibCall(llvm::RTLIB::Libcall, llvm::SDNode*, bool) + 1896

Besides, something will have to be done about the __uint128_t requirement on 32-bit targets, probably using a union with uint64_t members.

I'm currently lost here and will need some guidance how to proceed.

[efriedma]

SparcTargetLowering::LowerCall_32 is Sparc-specific code. Maybe you can take a look at where it's crashing, and ask some more specific question?

The compiler-rt requirement for __uint128_t is a bit inconvenient, I guess; maybe it could be changed, but that's probably an invasive patch.

Please split the compiler-rt changes into a separate patch; whether compiler-rt provides long double routines is separate from whether the compiler can generate calls to them. (For example, you might use clang and link against libgcc.)

llvm/lib/Target/Sparc/SparcCallingConv.td

30

Maybe worth adding code to use CCPassIndirect for f128? Might allow you to simplify the clang handling.

38

CCAssignToStack is used to pass values directly on the stack; I have no idea what it would mean on a return value. Are you sure you don't want to just fall back to the default handling, which returns the value indirectly?

clang/lib/Basic/Targets/Sparc.h

default:
       break;
     case llvm::Triple::NetBSD:
     case llvm::Triple::OpenBSD:
       SizeType = UnsignedLong;
       IntPtrType = SignedLong;
       PtrDiffType = SignedLong;
       break;
     }
+
+    if (getTriple().isOSSolaris()) {
+      // The SPARCv8 System V ABI has long double 128-bits in size, but 64-bit
+      // aligned.
+      LongDoubleWidth = 128;
+      LongDoubleAlign = 64;
+      LongDoubleFormat = &llvm::APFloat::IEEEquad();
+    }
+
     // Up to 32 bits (V8) or 64 bits (V9) are lock-free atomic, but we're
     // willing to do atomic ops on up to 64 bits.
     MaxAtomicPromoteWidth = 64;
     if (getCPUGeneration(CPU) == CG_V9)
       MaxAtomicInlineWidth = 64;
     else
       // FIXME: This isn't correct for plain V8 which lacks CAS,
       // only for LEON 3+ and Myriad.

clang/lib/CodeGen/TargetInfo.cpp

 //
 namespace {
 class SparcV8ABIInfo : public DefaultABIInfo {
 public:
   SparcV8ABIInfo(CodeGenTypes &CGT) : DefaultABIInfo(CGT) {}
 
 private:
   ABIArgInfo classifyReturnType(QualType RetTy) const;
+  ABIArgInfo classifyArgumentType(QualType Ty) const;
   void computeInfo(CGFunctionInfo &FI) const override;
 };
 } // end anonymous namespace
 
 
 ABIArgInfo
 SparcV8ABIInfo::classifyReturnType(QualType Ty) const {
+  if (Ty->isRealFloatingType() && getContext().getTypeSize(Ty) == 128)
+    return getNaturalAlignIndirect(Ty);
+
   if (Ty->isAnyComplexType()) {
-    return ABIArgInfo::getDirect();
+    auto AI = ABIArgInfo::getDirect();
+    AI.setInReg(true);
+    return AI;
   }
-  else {
-    return DefaultABIInfo::classifyReturnType(Ty);
-  }
+
+
+ABIArgInfo
+SparcV8ABIInfo::classifyArgumentType(QualType Ty) const {
+  // FIXME: Need to check for BuiltinType::LongDouble, too?
+  if (Ty->isRealFloatingType() && getContext().getTypeSize(Ty) == 128)
+    return getNaturalAlignIndirect(Ty);
+
+  return DefaultABIInfo::classifyArgumentType(Ty);
 }
 
 void SparcV8ABIInfo::computeInfo(CGFunctionInfo &FI) const {
 
   FI.getReturnInfo() = classifyReturnType(FI.getReturnType());
   for (auto &Arg : FI.arguments())
     Arg.info = classifyArgumentType(Arg.type);
 }

compiler-rt/lib/builtins/CMakeLists.txt

if (CAN_TARGET_${arch})
       filter_builtin_sources(${arch}_SOURCES ${arch})
 
       # Needed for clear_cache on debug mode, due to r7's usage in inline asm.
       # Release mode already sets it via -O2/3, Debug mode doesn't.
       if (${arch} STREQUAL "armhf")
         list(APPEND BUILTIN_CFLAGS -fomit-frame-pointer -DCOMPILER_RT_ARMHF_TARGET)
       endif()
 
-      # For RISCV32, we must force enable int128 for compiling long
-      # double routines.
-      if("${arch}" STREQUAL "riscv32")
+      # For RISCV32 and 32-bit SPARC, we must force enable int128 for compiling
+      # long double routines.
+      if("${arch}" MATCHES "riscv32|sparc$" AND NOT CMAKE_COMPILER_IS_GNUCC)
         list(APPEND BUILTIN_CFLAGS -fforce-enable-int128)
       endif()
 
       add_compiler_rt_runtime(clang_rt.builtins
                               STATIC
                               ARCHS ${arch}
                               SOURCES ${${arch}_SOURCES}
                               DEFS ${BUILTIN_DEFS}
                               CFLAGS ${BUILTIN_CFLAGS}
                               PARENT_TARGET builtins)
     endif ()
   endforeach ()
 endif ()
 
 add_dependencies(compiler-rt builtins)

compiler-rt/lib/builtins/int_types.h

 #define INT_TYPES_H
 
 #include "int_endianness.h"
 
 // si_int is defined in Linux sysroot's asm-generic/siginfo.h
 #ifdef si_int
 #undef si_int
 #endif
 typedef int32_t si_int;
 typedef uint32_t su_int;
 #if UINT_MAX == 0xFFFFFFFF
 #define clzsi __builtin_clz
 #define ctzsi __builtin_ctz
 #elif ULONG_MAX == 0xFFFFFFFF
 #define clzsi __builtin_clzl
 #define ctzsi __builtin_ctzl
 #else
 #error could not determine appropriate clzsi macro for this system
 #endif
 
 typedef int64_t di_int;
 typedef uint64_t du_int;
 
 typedef union {
   di_int all;
   struct {
 #if _YUGA_LITTLE_ENDIAN
     su_int low;
     si_int high;
 #else

 #else
     su_int high;
     su_int low;
 #endif // _YUGA_LITTLE_ENDIAN
   } s;
 } udwords;
 
 #if defined(__LP64__) || defined(__wasm__) || defined(__mips64) ||             \
-    defined(__riscv) || defined(_WIN64)
+    defined(__riscv) || defined(__sparc) || defined(_WIN64)
 #define CRT_HAS_128BIT
 #endif
 
 // MSVC doesn't have a working 128bit integer type. Users should really compile
 // compiler-rt with clang, but if they happen to be doing a standalone build for
 // asan or something else, disable the 128 bit parts so things sort of work.
 #if defined(_MSC_VER) && !defined(__clang__)
 #undef CRT_HAS_128BIT

compiler-rt/test/builtins/CMakeLists.txt

foreach(arch ${BUILTIN_TEST_ARCH})
   set(BUILTINS_TEST_TARGET_ARCH ${arch})
   string(TOLOWER "-${arch}-${OS_NAME}" BUILTINS_TEST_CONFIG_SUFFIX)
   get_test_cc_for_arch(${arch} BUILTINS_TEST_TARGET_CC BUILTINS_TEST_TARGET_CFLAGS)
   if (${arch} STREQUAL "armhf")
     list(APPEND BUILTINS_TEST_TARGET_CFLAGS -fomit-frame-pointer -DCOMPILER_RT_ARMHF_TARGET)
     string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
   endif()
 
-  if (${arch} STREQUAL "riscv32")
+  if("${arch}" MATCHES "riscv32|sparc$" AND NOT CMAKE_COMPILER_IS_GNUCC)
     list(APPEND BUILTINS_TEST_TARGET_CFLAGS -fforce-enable-int128)
     string(REPLACE ";" " " BUILTINS_TEST_TARGET_CFLAGS "${BUILTINS_TEST_TARGET_CFLAGS}")
   endif()
 
   # Compute builtins available in library and add them as lit features.
   if(APPLE)
     # TODO: Support other Apple platforms.
     set(BUILTIN_LIB_TARGET_NAME "clang_rt.builtins_${arch}_osx")

compiler-rt/test/builtins/Unit/divtc3_test.c

 // RUN: %clang_builtins %s %librt -lm -o %t && %run %t
 // REQUIRES: librt_has_divtc3
 // REQUIRES: c99-complex
 
-//
-// Bug 42493
-// XFAIL: sparc-target-arch
-//
 #include <stdio.h>
 
 #include "int_lib.h"
 #include <math.h>
 #include <complex.h>
 
 
 // Returns: the quotient of (a + ib) / (c + id)

llvm/lib/Target/Sparc/SparcCallingConv.td

def CC_Sparc32 : CallingConv<[
   // f64 arguments are split and passed through registers or through stack.
   CCIfType<[f64], CCCustom<"CC_Sparc_Assign_Split_64">>,
   // As are v2i32 arguments (this would be the default behavior for
   // v2i32 if it wasn't allocated to the IntPair register-class)
   CCIfType<[v2i32], CCCustom<"CC_Sparc_Assign_Split_64">>,
 
 
   // Alternatively, they are assigned to the stack in 4-byte aligned units.
   CCAssignToStack<4, 4>
 ]>;
 
 def RetCC_Sparc32 : CallingConv<[
   CCIfType<[i32], CCAssignToReg<[I0, I1, I2, I3, I4, I5]>>,
   CCIfType<[f32], CCAssignToReg<[F0, F1, F2, F3]>>,
   CCIfType<[f64], CCAssignToReg<[D0, D1]>>,
+  CCIfInReg<CCIfType<[f128] , CCAssignToReg<[Q0, Q1]>>>,
+  CCIfType<[f128], CCAssignToStack<16, 8>>,
   CCIfType<[v2i32], CCCustom<"CC_Sparc_Assign_Ret_Split_64">>
 ]>;
 
 
 //===----------------------------------------------------------------------===//
 // SPARC v9 64-bit.
 //===----------------------------------------------------------------------===//
 //

llvm/lib/Target/Sparc/SparcISelLowering.cpp

for (unsigned i = 0, e = ArgLocs.size(); i != e; ++i, ++InIdx) {
 
     int FI = MF.getFrameInfo().CreateFixedObject(4,
                                                  Offset,
                                                  true);
     SDValue FIPtr = DAG.getFrameIndex(FI, PtrVT);
     SDValue Load ;
     if (VA.getValVT() == MVT::i32 || VA.getValVT() == MVT::f32) {
       Load = DAG.getLoad(VA.getValVT(), dl, Chain, FIPtr, MachinePointerInfo());
-    } else if (VA.getValVT() == MVT::f128) {
-      report_fatal_error("SPARCv8 does not handle f128 in calls; "
-                         "pass indirectly");
     } else {
       // We shouldn't see any other value types here.
       llvm_unreachable("Unexpected ValVT encountered in frame lowering.");
     }
     InVals.push_back(Load);
   }
 
   if (MF.getFunction().hasStructRetAttr()) {