Create android x86_32 and x86_64 target info

[tberghammer]

Summary

Create android x86_32 and x86_64 target info

On android x86_32 the long double is only 64 bits (compared to 80 bits
on linux x86_32) and on android x86_64 the long double is IEEEquad
(compared to x87DoubleExtended on linux x86_64). This CL creates new
TargetInfo classes for this targets to represent these differences.

[• rafael]

It should be possible to test this, no?

[tberghammer]

I don't have too much knowledge about clang so I am not sure, but if I compile an executable with clang for android-x86 (from android ndk r10d) then the DWARF info will contain the right size for long double (8 byte).
I run into this issue from LLDB in a case where we create a clang AST context based on a module and a triple and we ended up with wrong size for long double.

[• rafael]

Sounds like you should be able to put a test in clang/test/CodeGen.

[danalbert]

IIRC we don't get this right for x86_64 either. Currently uses 80-bit long double, should be 128-bit.

[tberghammer]

In D8357#141685, @rafael wrote:

Sounds like you should be able to put a test in clang/test/CodeGen.

I think this code isn't used during codegen because clang generates the correct DWARF description for long double (64 bit) for android-x86 but I might be wrong. I would appreciate if you can give me some hint about what type of tests should I add and how.

In D8357#141687, @danalbert wrote:

IIRC we don't get this right for x86_64 either. Currently uses 80-bit long double, should be 128-bit.

In this file we specify 128 bit for long double on x86_64 but I am not sure what android-x86_64 use. I will check it tomorrow and update the patch if necessary.

[chh]

With my partial comparison with current Android prebuilt gcc x86 configuration, I think the following additional changes maybe needed in AndroidX86_32TargetInfo.

SuitableAlign = 32;
LongDoubleFormat = &llvm::APFloat::IEEEdouble;

[tberghammer]

Added missing settings pointed out by @chh.

Checked android-x86_64 and based on my understanding it uses 128 bit long double what match with the configuration specified in Targets.cpp for X86_64TargetInfo.

[chh]

For 64-bit mode, the long double size is correct but format is not compatible with current Android gcc configuration.
I am testing the following configuration, which seems to work with Android x86_64-eng target.

namespace {
// x86_64 Android target
class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> {
public:

AndroidX86_64TargetInfo(const llvm::Triple &Triple)
    : LinuxTargetInfo<X86_64TargetInfo>(Triple) {
  LongDoubleFormat = &llvm::APFloat::IEEEquad;
}

};
} // end anonymous namespace

....

case llvm::Triple::x86_64:

if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
  return new DarwinX86_64TargetInfo(Triple);

switch (os) {
case llvm::Triple::Linux:
  if (Triple.getEnvironment() == llvm::Triple::Android)
    return new AndroidX86_64TargetInfo(Triple);
  else
    return new LinuxTargetInfo<X86_64TargetInfo>(Triple);

[tberghammer]

Add android x86_64 target info

[tberghammer]

Based on my experiments the current configuration is correct about the specification of long doubles on android as LLDB manage to read and write long double values in both effected configurations based on these values (after a few independent changes in LLDB).

[• rafael]

needs testcase.

[tberghammer]

In D8357#142662, @rafael wrote:

needs testcase.

Can you give me some information about what type of test case should I write and how?
(I don't know too much about how clang and the clang tests are working. Run into this issue while working on LLDB.)

[• rafael]

I assume you started this with a .c file that produces different
output with this patch, no?

In any case, this patch should change the value of (for example)
sizeof(long double), no? If so you should be able to add a test to
clang/test/Sema

[tberghammer]

Add tests

[tberghammer]

In D8357#142667, @rafael wrote:

I assume you started this with a .c file that produces different
output with this patch, no?

Actually I started with a test failure in LLDB what lead me to a wrong value in ASTContext::LongDoubleTy. I investigated that issue when ended up with this CL.

[danalbert]

LGTM.

cfe/trunk/lib/Basic/Targets.cpp

 const Builtin::Info XCoreTargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS) { #ID, TYPE, ATTRS, 0, ALL_LANGUAGES },
 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) { #ID, TYPE, ATTRS, HEADER,\
                                               ALL_LANGUAGES },
 #include "clang/Basic/BuiltinsXCore.def"
 };
 } // end anonymous namespace.
 
+namespace {
+// x86_32 Android target
+class AndroidX86_32TargetInfo : public LinuxTargetInfo<X86_32TargetInfo> {
+public:
+  AndroidX86_32TargetInfo(const llvm::Triple &Triple)
+      : LinuxTargetInfo<X86_32TargetInfo>(Triple) {
+    SuitableAlign = 32;
+    LongDoubleWidth = 64;
+    LongDoubleFormat = &llvm::APFloat::IEEEdouble;
+  }
+};
+} // end anonymous namespace
+
+namespace {
+// x86_64 Android target
+class AndroidX86_64TargetInfo : public LinuxTargetInfo<X86_64TargetInfo> {
+public:
+  AndroidX86_64TargetInfo(const llvm::Triple &Triple)
+      : LinuxTargetInfo<X86_64TargetInfo>(Triple) {
+    LongDoubleFormat = &llvm::APFloat::IEEEquad;
+  }
+};
+} // end anonymous namespace
+
 
 //===----------------------------------------------------------------------===//
 // Driver code
 //===----------------------------------------------------------------------===//
 
 static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
   llvm::Triple::OSType os = Triple.getOS();
 
static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
   case llvm::Triple::tce:
     return new TCETargetInfo(Triple);
 
   case llvm::Triple::x86:
     if (Triple.isOSDarwin())
       return new DarwinI386TargetInfo(Triple);
 
     switch (os) {
-    case llvm::Triple::Linux:
+    case llvm::Triple::Linux: {
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
+      case llvm::Triple::Android:
+        return new AndroidX86_32TargetInfo(Triple);
+      }
+    }
     case llvm::Triple::DragonFly:
       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::NetBSD:
       return new NetBSDI386TargetInfo(Triple);
     case llvm::Triple::OpenBSD:
       return new OpenBSDI386TargetInfo(Triple);
     case llvm::Triple::Bitrig:
       return new BitrigI386TargetInfo(Triple);
static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
 
   case llvm::Triple::x86_64:
     if (Triple.isOSDarwin() || Triple.isOSBinFormatMachO())
       return new DarwinX86_64TargetInfo(Triple);
 
     switch (os) {
     case llvm::Triple::CloudABI:
       return new CloudABITargetInfo<X86_64TargetInfo>(Triple);
-    case llvm::Triple::Linux:
+    case llvm::Triple::Linux: {
+      switch (Triple.getEnvironment()) {
+      default:
         return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
+      case llvm::Triple::Android:
+        return new AndroidX86_64TargetInfo(Triple);
+      }
+    }
     case llvm::Triple::DragonFly:
       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::OpenBSD:
       return new OpenBSDX86_64TargetInfo(Triple);
     case llvm::Triple::Bitrig:
       return new BitrigX86_64TargetInfo(Triple);

cfe/trunk/test/Sema/i386-linux-android.c

+// RUN: %clang_cc1 -triple i386-linux-android -fsyntax-only -verify %s
+// expected-no-diagnostics
+
+extern int a1_0[sizeof(long double) == 8 ? 1 : -1];
+extern int a1_i[__alignof(long double) == 4 ? 1 : -1];
+

cfe/trunk/test/Sema/x86_64-linux-android.c

+// RUN: %clang_cc1 -triple x86_64-linux-android -emit-pch -o %t %s
+// RUN: %clang_cc1 -x ast -ast-print %t | FileCheck %s
+
+extern int a1_0[sizeof(long double) == 16 ? 1 : -1];
+extern int a1_i[__alignof(long double) == 16 ? 1 : -1];
+
+// Verify that long double is 128 bit IEEEquad
+
+long double foo = 1.0E4000L;
+// CHECK: long double foo = 1.00000000000000000000000000000000004E+4000L;