chh updated this revision to Diff 31268.
chh marked an inline comment as done.
chh added a comment.
New svn diff after svn update.
http://reviews.llvm.org/D11437
Files:
lib/CodeGen/TargetInfo.cpp
test/CodeGen/x86_64-fp128.c
Index: test/CodeGen/x86_64-fp128.c
===================================================================
--- test/CodeGen/x86_64-fp128.c
+++ test/CodeGen/x86_64-fp128.c
@@ -0,0 +1,116 @@
+// RUN: %clang_cc1 -triple x86_64-linux-android -emit-llvm -O -o - %s \
+// RUN: | FileCheck %s --check-prefix=ANDROID --check-prefix=CHECK
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -emit-llvm -O -o - %s \
+// RUN: | FileCheck %s --check-prefix=GNU --check-prefix=CHECK
+// RUN: %clang_cc1 -triple x86_64 -emit-llvm -O -o - %s \
+// RUN: | FileCheck %s --check-prefix=GNU --check-prefix=CHECK
+
+// Android uses fp128 for long double but other x86_64 targets use x86_fp80.
+
+long double dataLD = 1.0L;
+// ANDROID: @dataLD = global fp128 0xL00000000000000003FFF000000000000, align 16
+// GNU: @dataLD = global x86_fp80 0xK3FFF8000000000000000, align 16
+
+long double _Complex dataLDC = {1.0L, 1.0L};
+// ANDROID: @dataLDC = global { fp128, fp128 } { fp128 0xL00000000000000003FFF000000000000, fp128 0xL00000000000000003FFF000000000000 }, align 16
+// GNU: @dataLDC = global { x86_fp80, x86_fp80 } { x86_fp80 0xK3FFF8000000000000000, x86_fp80 0xK3FFF8000000000000000 }, align 16
+
+long double TestLD(long double x) {
+ return x * x;
+// ANDROID: define fp128 @TestLD(fp128 %x)
+// GNU: define x86_fp80 @TestLD(x86_fp80 %x)
+}
+
+long double _Complex TestLDC(long double _Complex x) {
+ return x * x;
+// ANDROID: define void @TestLDC({ fp128, fp128 }* {{.*}}, { fp128, fp128 }* {{.*}} %x)
+// GNU: define { x86_fp80, x86_fp80 } @TestLDC({ x86_fp80, x86_fp80 }* {{.*}} %x)
+}
+
+typedef __builtin_va_list va_list;
+
+int TestGetVarInt(va_list ap) {
+ return __builtin_va_arg(ap, int);
+// Since int can be passed in memory or in register there is a branch and a phi.
+// CHECK: define i32 @TestGetVarInt(
+// CHECK: br
+// CHECK: load {{.*}} %overflow_arg_area_p
+// CHECK: = phi
+// CHECK: ret i32
+}
+
+double TestGetVarDouble(va_list ap) {
+ return __builtin_va_arg(ap, double);
+// Since double can be passed in memory or in register there is a branch and a phi.
+// CHECK: define double @TestGetVarDouble(
+// CHECK: br
+// CHECK: load {{.*}} %overflow_arg_area_p
+// CHECK: = phi
+// CHECK: ret double
+}
+
+long double TestGetVarLD(va_list ap) {
+ return __builtin_va_arg(ap, long double);
+// fp128 can be passed in memory or in register, but x86_fp80 is in memory.
+// ANDROID: define fp128 @TestGetVarLD(
+// GNU: define x86_fp80 @TestGetVarLD(
+// ANDROID: br
+// GNU-NOT: br
+// CHECK: load {{.*}} %overflow_arg_area_p
+// ANDROID: = phi
+// GNU-NOT: = phi
+// ANDROID: ret fp128
+// GNU: ret x86_fp80
+}
+
+long double _Complex TestGetVarLDC(va_list ap) {
+ return __builtin_va_arg(ap, long double _Complex);
+// Pair of fp128 or x86_fp80 are passed as struct in memory.
+// ANDROID: define void @TestGetVarLDC({ fp128, fp128 }* {{.*}}, %struct.__va_list_tag*
+// GNU: define { x86_fp80, x86_fp80 } @TestGetVarLDC(
+// CHECK-NOT: br
+// CHECK: load {{.*}} %overflow_arg_area_p
+// CHECK-NOT: phi
+// ANDROID: ret void
+// GNU: ret { x86_fp80, x86_fp80 }
+}
+
+void TestVarArg(const char *s, ...);
+
+void TestPassVarInt(int x) {
+ TestVarArg("A", x);
+// CHECK: define void @TestPassVarInt(i32 %x)
+// CHECK: call {{.*}} @TestVarArg(i8* {{.*}}, i32 %x)
+}
+
+void TestPassVarFloat(float x) {
+ TestVarArg("A", x);
+// CHECK: define void @TestPassVarFloat(float %x)
+// CHECK: call {{.*}} @TestVarArg(i8* {{.*}}, double %
+}
+
+void TestPassVarDouble(double x) {
+ TestVarArg("A", x);
+// CHECK: define void @TestPassVarDouble(double %x)
+// CHECK: call {{.*}} @TestVarArg(i8* {{.*}}, double %x
+}
+
+void TestPassVarLD(long double x) {
+ TestVarArg("A", x);
+// ANDROID: define void @TestPassVarLD(fp128 %x)
+// ANDROID: call {{.*}} @TestVarArg(i8* {{.*}}, fp128 %x
+// GNU: define void @TestPassVarLD(x86_fp80 %x)
+// GNU: call {{.*}} @TestVarArg(i8* {{.*}}, x86_fp80 %x
+}
+
+void TestPassVarLDC(long double _Complex x) {
+ TestVarArg("A", x);
+// ANDROID: define void @TestPassVarLDC({ fp128, fp128 }* {{.*}} %x)
+// ANDROID: store fp128 %x.{{.*}}, fp128* %
+// ANDROID-NEXT: store fp128 %x.{{.*}}, fp128* %
+// ANDROID-NEXT: call {{.*}} @TestVarArg(i8* {{.*}}, { fp128, fp128 }* {{.*}} %
+// GNU: define void @TestPassVarLDC({ x86_fp80, x86_fp80 }* {{.*}} %x)
+// GNU: store x86_fp80 %x.{{.*}}, x86_fp80* %
+// GNU-NEXT: store x86_fp80 %x.{{.*}}, x86_fp80* %
+// GNGNU-NEXT: call {{.*}} @TestVarArg(i8* {{.*}}, { x86_fp80, x86_fp80 }* {{.*}} %
+}
Index: lib/CodeGen/TargetInfo.cpp
===================================================================
--- lib/CodeGen/TargetInfo.cpp
+++ lib/CodeGen/TargetInfo.cpp
@@ -1973,14 +1973,21 @@
Current = Integer;
else if (Size <= 128)
Lo = Hi = Integer;
- } else if (ET == getContext().FloatTy)
+ } else if (ET == getContext().FloatTy) {
Current = SSE;
- else if (ET == getContext().DoubleTy ||
- (ET == getContext().LongDoubleTy &&
- getTarget().getTriple().isOSNaCl()))
+ } else if (ET == getContext().DoubleTy) {
Lo = Hi = SSE;
- else if (ET == getContext().LongDoubleTy)
- Current = ComplexX87;
+ } else if (ET == getContext().LongDoubleTy) {
+ const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
+ if (LDF == &llvm::APFloat::IEEEquad)
+ Current = Memory;
+ else if (LDF == &llvm::APFloat::x87DoubleExtended)
+ Current = ComplexX87;
+ else if (LDF == &llvm::APFloat::IEEEdouble)
+ Lo = Hi = SSE;
+ else
+ llvm_unreachable("unexpected long double representation!");
+ }
// If this complex type crosses an eightbyte boundary then it
// should be split.
@@ -2522,6 +2529,13 @@
ABIArgInfo X86_64ABIInfo::
classifyReturnType(QualType RetTy) const {
+ // TODO: Simplify classify to handle f128 according to AMD64 ABI.
+ if (const BuiltinType *BT = RetTy->getAs<BuiltinType>()) {
+ if (BT->getKind() == BuiltinType::LongDouble &&
+ &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad)
+ return ABIArgInfo::getDirect(CGT.ConvertType(RetTy));
+ }
+
// AMD64-ABI 3.2.3p4: Rule 1. Classify the return type with the
// classification algorithm.
X86_64ABIInfo::Class Lo, Hi;
@@ -2654,6 +2668,16 @@
bool isNamedArg)
const
{
+ // TODO: Simplify classifyArgumentType to handle f128 according to AMD64 ABI.
+ if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
+ if (BT->getKind() == BuiltinType::LongDouble &&
+ &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad) {
+ neededInt = 0;
+ neededSSE = 1;
+ return ABIArgInfo::getDirect(CGT.ConvertType(Ty));
+ }
+ }
+
Ty = useFirstFieldIfTransparentUnion(Ty);
X86_64ABIInfo::Class Lo, Hi;
_______________________________________________
cfe-commits mailing list
cfe-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
