[ItaniumMangle] Refactor long double/__float128 mangling and fix the mangled code

[MaskRay]

Summary

In gcc PowerPC, long double has 3 mangling schemes:

-mlong-double-64: e
-mlong-double-128 -mabi=ibmlongdouble: g
-mlong-double-128 -mabi=ieeelongdouble: u9__ieee128 (gcc <= 8.1: U10__float128)

The current useFloat128ManglingForLongDouble() bisection is not suitable
when we support -mlong-double-128 in clang (D64277). Replace
useFloat128ManglingForLongDouble() with getLongDoubleMangling() and
getFloat128Mangling() to allow 3 mangling schemes.

I also deleted the getTriple().isOSBinFormatELF() check (the Darwin
support has gone: https://reviews.llvm.org/D50988).

For x86, change the mangled code of __float128 from U10__float128 to g. U10__float128 was wrongly copied from PowerPC.
The test will be added to test/CodeGen/x86-long-double.cpp in D64277.

[MaskRay]

Simplify x86_64 Android. Since it doesn't use -mlong-double-64 or -mlong-double-128, just use "g" for it.
In the next -mlong-double-128 patch, we move its getManglingForLongDouble() overload to X86TargetInfo

[MaskRay]

"U10float128" -> "u9ieee128"

This is the new mangled type in gcc>8.1

[MaskRay]

Fix mangled code of __float128 on x86

[erichkeane]

I think the function names are awkward, but otherwise I think this should be acceptable. I'll accept, but give 24 hrs for the other reviewers to get through their mondays.

include/clang/Basic/TargetInfo.h

603

getLongDoubleMangling/getFloat128Mangling seems to make more sense for these names.

[MaskRay]

getMangledTypeOfLongDouble -> getLongDoubleMangling
as erichkeane suggested.

include/clang/Basic/TargetInfo.h

public:
   /// getFloat128Width/Align/Format - Return the size/align/format of
   /// '__float128'.
   unsigned getFloat128Width() const { return 128; }
   unsigned getFloat128Align() const { return Float128Align; }
   const llvm::fltSemantics &getFloat128Format() const {
     return *Float128Format;
   }
 
-  /// Return true if the 'long double' type should be mangled like
-  /// __float128.
-  virtual bool useFloat128ManglingForLongDouble() const { return false; }
+  /// Return the mangled type of long double.
+  virtual const char *getManglingForLongDouble() const { return "e"; }
+
+  /// Return the mangled type of __float128.
+  virtual const char *getManglingForFloat128() const { return "g"; }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual unsigned getFloatEvalMethod() const { return 0; }
 
   // getLargeArrayMinWidth/Align - Return the minimum array size that is
   // 'large' and its alignment.
   unsigned getLargeArrayMinWidth() const { return LargeArrayMinWidth; }
   unsigned getLargeArrayAlign() const { return LargeArrayAlign; }

lib/AST/ItaniumMangle.cpp

case BuiltinType::Half:
     break;
   case BuiltinType::Float:
     Out << 'f';
     break;
   case BuiltinType::Double:
     Out << 'd';
     break;
   case BuiltinType::LongDouble: {
-    bool UseFloat128Mangling =
-        getASTContext().getTargetInfo().useFloat128ManglingForLongDouble();
-    if (getASTContext().getLangOpts().OpenMP &&
-        getASTContext().getLangOpts().OpenMPIsDevice) {
-      UseFloat128Mangling = getASTContext()
-                                .getAuxTargetInfo()
-                                ->useFloat128ManglingForLongDouble();
-    }
-    Out << (UseFloat128Mangling ? 'g' : 'e');
+    const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
+                                   getASTContext().getLangOpts().OpenMPIsDevice
+                               ? getASTContext().getAuxTargetInfo()
+                               : &getASTContext().getTargetInfo();
+    Out << TI->getManglingForLongDouble();
     break;
   }
   case BuiltinType::Float128: {
-    bool UseFloat128Mangling =
-        getASTContext().getTargetInfo().useFloat128ManglingForLongDouble();
-    if (getASTContext().getLangOpts().OpenMP &&
-        getASTContext().getLangOpts().OpenMPIsDevice) {
-      UseFloat128Mangling = getASTContext()
-                                .getAuxTargetInfo()
-                                ->useFloat128ManglingForLongDouble();
-    }
-    if (UseFloat128Mangling)
-      Out << "U10__float128"; // Match the GCC mangling
-    else
-      Out << 'g';
+    const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
+                                   getASTContext().getLangOpts().OpenMPIsDevice
+                               ? getASTContext().getAuxTargetInfo()
+                               : &getASTContext().getTargetInfo();
+    Out << TI->getManglingForFloat128();
     break;
   }
   case BuiltinType::NullPtr:
     Out << "Dn";
     break;
 
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \

lib/Basic/Targets/PPC.h

if (RegNo == 0)
       return 3;
     if (RegNo == 1)
       return 4;
     return -1;
   }
 
   bool hasSjLjLowering() const override { return true; }
 
-  bool useFloat128ManglingForLongDouble() const override {
-    return LongDoubleWidth == 128 &&
-           LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble() &&
-           getTriple().isOSBinFormatELF();
+  const char *getManglingForLongDouble() const override {
+    if (LongDoubleWidth == 64)
+      return "e";
+    return LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble()
+               ? "g"
+               : "U10__float128";
+  }
+  const char *getManglingForFloat128() const override {
+    return "U10__float128";
   }
 };
 
 class LLVM_LIBRARY_VISIBILITY PPC32TargetInfo : public PPCTargetInfo {
 public:
   PPC32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : PPCTargetInfo(Triple, Opts) {
     resetDataLayout("E-m:e-p:32:32-i64:64-n32");

lib/Basic/Targets/SystemZ.h

public:
   }
 
   StringRef getABI() const override {
     if (HasVector)
       return "vector";
     return "";
   }
 
-  bool useFloat128ManglingForLongDouble() const override { return true; }
+  const char *getManglingForLongDouble() const override { return "g"; }
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_SYSTEMZ_H

lib/Basic/Targets/X86.h

 class LLVM_LIBRARY_VISIBILITY AndroidX86_64TargetInfo
     : public LinuxTargetInfo<X86_64TargetInfo> {
 public:
   AndroidX86_64TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : LinuxTargetInfo<X86_64TargetInfo>(Triple, Opts) {
     LongDoubleFormat = &llvm::APFloat::IEEEquad();
   }
 
-  bool useFloat128ManglingForLongDouble() const override { return true; }
+  const char *getManglingForLongDouble() const override {
+    return LongDoubleWidth == 128 ? "g" : "e";
+  }
+  const char *getManglingForFloat128() const override {
+    return "U10__float128";
+  }
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_X86_H