Add -mlong-double-64 flag

[tzik]

Summary

Fixes PR21543.
This patch adds -mlong-double-64 flag to cfe to override the size of long double.
GCC supports this flag and uses for Bionic.

[tzik]

Hi, Kostya.
Could you take a look to this?

We are trying to build Bionic with clang, though it get stuck in a issue due to the size mismatch of long double.
Can we add the flag to deal with it?

[kcc]

The patch looks ok, but I am not the person to approve patches in this part of clang.
CC-ed rsmith.

[rnk]

This needs an IRGen test. We should produce the LLVM 'double' type instead of the x86_fp80 type.

[tzik]

Add CodeGen test.
Update LongDoubleFormat.

[tzik]

Drop unrelated whitespace changes

[tzik]

In D6260#8, @rnk wrote:

This needs an IRGen test. We should produce the LLVM 'double' type instead of the x86_fp80 type.

OK, I added a test to the CL.

I think another things to consider is LongDoubleAlign.
LongDoubleAlign is 32 on x86_32 and 64 on x86_64, should I adjust it in TargetInfo::adjust too for each supported arch?

[tzik]

rnk@, rsmith@: Could you take another look?
Is this kind of CL unacceptable by design? Or, it just needs refinement?

[chandlerc]

Ok folks, I know this is a blast from the past, but can we actually review this? I'm willing to commandeer it, rebase it, and get it landed if you all can review this and confirm that it is the right direction.

[hfinkel]

lib/Basic/TargetInfo.cpp

277

This seems wrong for targets in general. Maybe this should be, instead of 32 always, 64 on 64-bit targets?

[rsmith]

What about -mlong-double-128? It seems sensible to me to add support for that at the same time.

It looks like this also needs to affect name mangling. As far as I can tell from some quick testing, on ppc64-linux-gnu GCC uses e for 64-bit long double and g for 128-bit long double. On x86_64, -mlong-double-64 and -mlong-double-128 do not appear to affect the mangling scheme. Someone needs to do some research here to find out what the right mangling scheme to use is for each platform where we want to allow these flags.

lib/Basic/TargetInfo.cpp

277

I'd expect that this should match the alignment of double.

299

What should happen if you try to combine -mlong-double-64 with -x cl? I'd expect the -mlong-double-64 to win (as it's clearly a more specific override).

include/clang/Basic/LangOptions.def

 LANGOPT(FiniteMathOnly    , 1, 0, "__FINITE_MATH_ONLY__ predefined macro")
 
 BENIGN_LANGOPT(ObjCGCBitmapPrint , 1, 0, "printing of GC's bitmap layout for __weak/__strong ivars")
 
 BENIGN_LANGOPT(AccessControl     , 1, 1, "C++ access control")
 LANGOPT(CharIsSigned      , 1, 1, "signed char")
 LANGOPT(ShortWChar        , 1, 0, "unsigned short wchar_t")
 ENUM_LANGOPT(MSPointerToMemberRepresentationMethod, PragmaMSPointersToMembersKind, 2, PPTMK_BestCase, "member-pointer representation method")
+LANGOPT(LongDouble64      , 1, 0, "64-bit long double")
 
 LANGOPT(ShortEnums        , 1, 0, "short enum types")
 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL version")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
 LANGOPT(HalfArgsAndReturns, 1, 0, "half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")

include/clang/Driver/Options.td

 def frtti : Flag<["-"], "frtti">, Group<f_Group>;
 def : Flag<["-"], "fsched-interblock">, Group<clang_ignored_f_Group>;
 def fshort_enums : Flag<["-"], "fshort-enums">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Allocate to an enum type only as many bytes as it needs for the declared range of possible values">;
 def fshort_wchar : Flag<["-"], "fshort-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be a short unsigned int">;
 def fno_short_wchar : Flag<["-"], "fno-short-wchar">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Force wchar_t to be an unsigned int">;
+def mlong_double_64 : Flag<["-"], "mlong-double-64">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Force long double to be 64 bit">;
+def mlong_double_default : Flag<["-"], "mlong-double-default">, Group<f_Group>, Flags<[CC1Option]>,
+  HelpText<"Force long double to be default width">;
 def fshow_overloads_EQ : Joined<["-"], "fshow-overloads=">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Which overload candidates to show when overload resolution fails: "
            "best|all; defaults to all">;
 def fshow_column : Flag<["-"], "fshow-column">, Group<f_Group>, Flags<[CC1Option]>;
 def fshow_source_location : Flag<["-"], "fshow-source-location">, Group<f_Group>;
 def fspell_checking : Flag<["-"], "fspell-checking">, Group<f_Group>;
 def fsigned_bitfields : Flag<["-"], "fsigned-bitfields">, Group<f_Group>;
 def fsigned_char : Flag<["-"], "fsigned-char">, Group<f_Group>;

lib/Basic/TargetInfo.cpp

 /// adjust - Set forced language options.
 /// Apply changes to the target information with respect to certain
 /// language options which change the target configuration.
 void TargetInfo::adjust(const LangOptions &Opts) {
   if (Opts.NoBitFieldTypeAlign)
     UseBitFieldTypeAlignment = false;
   if (Opts.ShortWChar)
     WCharType = UnsignedShort;
+  if (Opts.LongDouble64) {
+    LongDoubleWidth = 64;
+    LongDoubleAlign = 32;
+    LongDoubleFormat = &llvm::APFloat::IEEEdouble;
+  }
 
   if (Opts.OpenCL) {
     // OpenCL C requires specific widths for types, irrespective of
     // what these normally are for the target.
     // We also define long long and long double here, although the
     // OpenCL standard only mentions these as "reserved".
     IntWidth = IntAlign = 32;
     LongWidth = LongAlign = 64;
     LongLongWidth = LongLongAlign = 128;
     HalfWidth = HalfAlign = 16;
     FloatWidth = FloatAlign = 32;
     
     // Embedded 32-bit targets (OpenCL EP) might have double C type 
     // defined as float. Let's not override this as it might lead 
     // to generating illegal code that uses 64bit doubles.
     if (DoubleWidth != FloatWidth) {
       DoubleWidth = DoubleAlign = 64;
       DoubleFormat = &llvm::APFloat::IEEEdouble;
     }
     LongDoubleWidth = LongDoubleAlign = 128;
 
     assert(PointerWidth == 32 || PointerWidth == 64);
     bool Is32BitArch = PointerWidth == 32;
     SizeType = Is32BitArch ? UnsignedInt : UnsignedLong;
     PtrDiffType = Is32BitArch ? SignedInt : SignedLong;
     IntPtrType = Is32BitArch ? SignedInt : SignedLong;
 
     IntMaxType = SignedLongLong;

lib/Driver/Tools.cpp

if (!Args.hasFlag(options::OPT_fconstant_cfstrings,
     CmdArgs.push_back("-fno-constant-cfstrings");
 
   // -fshort-wchar default varies depending on platform; only
   // pass if specified.
   if (Arg *A = Args.getLastArg(options::OPT_fshort_wchar,
                                options::OPT_fno_short_wchar))
     A->render(Args, CmdArgs);
 
+  // -mlong-double-default is default, only pass non-default.
+  if (Arg *A = Args.getLastArg(options::OPT_mlong_double_64,
+                               options::OPT_mlong_double_default)) {
+    A->claim();
+    if (!A->getOption().matches(options::OPT_mlong_double_default))
+      A->render(Args, CmdArgs);
+  }
+
   // -fno-pascal-strings is default, only pass non-default.
   if (Args.hasFlag(options::OPT_fpascal_strings,
                    options::OPT_fno_pascal_strings,
                    false))
     CmdArgs.push_back("-fpascal-strings");
 
   // Honor -fpack-struct= and -fpack-struct, if given. Note that
   // -fno-pack-struct doesn't apply to -fpack-struct=.

lib/Frontend/CompilerInvocation.cpp

#include "clang/Frontend/LangStandards.def"
   Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
   Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
   Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
   Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name);
   Opts.ImplementationOfModule =
       Args.getLastArgValue(OPT_fmodule_implementation_of);
   Opts.NativeHalfType = Opts.NativeHalfType;
   Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns);
+  Opts.LongDouble64 = Args.hasArg(OPT_mlong_double_64);
 
   if (!Opts.CurrentModule.empty() && !Opts.ImplementationOfModule.empty() &&
       Opts.CurrentModule != Opts.ImplementationOfModule) {
     Diags.Report(diag::err_conflicting_module_names)
         << Opts.CurrentModule << Opts.ImplementationOfModule;
   }
 
   if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {

test/CodeGen/long-double-64-x86.c

+// RUN: %clang_cc1 -mlong-double-64 %s -emit-llvm -o - -triple=i686-unknown-unknown | FileCheck %s
+// RUN: %clang_cc1 -mlong-double-64 %s -emit-llvm -o - -triple=x86_64-unknown-unknown | FileCheck %s
+
+long double x = 0;
+// CHECK: double
+// CHECK-NOT: x86_fp80

test/Driver/clang_f_opts.c

 
 
 // RUN: %clang -### -fshort-wchar -fno-short-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR1 %s
 // RUN: %clang -### -fno-short-wchar -fshort-wchar %s 2>&1 | FileCheck -check-prefix=CHECK-WCHAR2 %s
 // CHECK-WCHAR1: -fno-short-wchar
 // CHECK-WCHAR1-NOT: -fshort-wchar
 // CHECK-WCHAR2: -fshort-wchar
 // CHECK-WCHAR2-NOT: -fno-short-wchar
+
+// RUN: %clang -### -mlong-double-64 -mlong-double-default %s 2>&1 | FileCheck -check-prefix=CHECK-LONG-DOUBLE-64-1 %s
+// RUN: %clang -### -mlong-double-default -mlong-double-64 %s 2>&1 | FileCheck -check-prefix=CHECK-LONG-DOUBLE-64-2 %s
+// CHECK-LONG-DOUBLE-64-1-NOT: -mlong-double-64
+// CHECK-LONG-DOUBLE-64-2: -mlong-double-64

test/Sema/long-double-64.c

+// RUN: %clang_cc1 %s -fsyntax-only -mlong-double-64 -verify
+// expected-no-diagnostics
+
+int check_long_double_size[sizeof(long double) == 8 ? 1 : -1];