[llvm] r299761 - [ARM] GlobalISel: Test hard float properly

[Diana Picus via llvm-commits]

Author: rovka
Date: Fri Apr  7 07:04:24 2017
New Revision: 299761

URL: http://llvm.org/viewvc/llvm-project?rev=299761&view=rev
Log:
[ARM] GlobalISel: Test hard float properly

It turns out -float-abi=hard doesn't set the hard float calling
convention for libcalls. We need to use a hard float triple instead
(e.g. gnueabihf).

Modified:
    llvm/trunk/test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir

Modified: llvm/trunk/test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir?rev=299761&r1=299760&r2=299761&view=diff
==============================================================================
--- llvm/trunk/test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir (original)
+++ llvm/trunk/test/CodeGen/ARM/GlobalISel/arm-legalize-fp.mir Fri Apr  7 07:04:24 2017
@@ -1,6 +1,6 @@
-# RUN: llc -mtriple arm-- -mattr=+vfp2 -float-abi=hard -global-isel -run-pass=legalizer %s -o - | FileCheck %s
-# RUN: llc -mtriple arm-- -mattr=+vfp2 -float-abi=soft -global-isel -run-pass=legalizer %s -o - | FileCheck %s
-# RUN: llc -mtriple arm-- -float-abi=soft -global-isel -run-pass=legalizer %s -o - | FileCheck %s
+# RUN: llc -mtriple arm-gnueabihf -mattr=+vfp2 -float-abi=hard -global-isel -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix HARD
+# RUN: llc -mtriple arm-- -mattr=+vfp2 -float-abi=soft -global-isel -run-pass=legalizer %s -o - | FileCheck %s -check-prefix CHECK -check-prefix SOFT
+# RUN: llc -mtriple arm-- -float-abi=soft -global-isel -run-pass=legalizer %s -o - | FileCheck %s  -check-prefix CHECK -check-prefix SOFT
 --- |
   define void @test_frem_float() { ret void }
   define void @test_frem_double() { ret void }
@@ -26,10 +26,14 @@ body:             |
     %0(s32) = COPY %r0
     %1(s32) = COPY %r1
     ; CHECK: ADJCALLSTACKDOWN
-    ; CHECK-DAG: %r0 = COPY [[X]]
-    ; CHECK-DAG: %r1 = COPY [[Y]]
-    ; CHECK: BLX $fmodf, {{.*}}, implicit %r0, implicit %r1, implicit-def %r0
-    ; CHECK: [[R:%[0-9]+]](s32) = COPY %r0
+    ; SOFT-DAG: %r0 = COPY [[X]]
+    ; SOFT-DAG: %r1 = COPY [[Y]]
+    ; HARD-DAG: %s0 = COPY [[X]]
+    ; HARD-DAG: %s1 = COPY [[Y]]
+    ; SOFT: BLX $fmodf, {{.*}}, implicit %r0, implicit %r1, implicit-def %r0
+    ; HARD: BLX $fmodf, {{.*}}, implicit %s0, implicit %s1, implicit-def %s0
+    ; SOFT: [[R:%[0-9]+]](s32) = COPY %r0
+    ; HARD: [[R:%[0-9]+]](s32) = COPY %s0
     ; CHECK: ADJCALLSTACKUP
     %2(s32) = G_FREM %0, %1
     ; CHECK: %r0 = COPY [[R]]
@@ -59,10 +63,11 @@ body:             |
     liveins: %r0, %r1, %r2, %r3
 
     ; The inputs may be in the wrong order (depending on the target's
-    ; endianness), but that's orthogonal to what we're trying to test here. We
-    ; only need to check that the first value, received through R0-R1, ends up
-    ; in R0-R1 or R1-R0, and the second value, received through R2-R3, ends up
-    ; in R2-R3 or R3-R2, when passed to fmod.
+    ; endianness), but that's orthogonal to what we're trying to test here.
+    ; For soft float, we only need to check that the first value, received
+    ; through R0-R1, ends up in R0-R1 or R1-R0, and the second value, received
+    ; through R2-R3, ends up in R2-R3 or R3-R2, when passed to fmod.
+    ; For hard float, the values need to end up in D0 and D1.
     ; CHECK-DAG: [[X0:%[0-9]+]](s32) = COPY %r0
     ; CHECK-DAG: [[X1:%[0-9]+]](s32) = COPY %r1
     ; CHECK-DAG: [[Y0:%[0-9]+]](s32) = COPY %r2
@@ -71,14 +76,19 @@ body:             |
     %1(s32) = COPY %r1
     %2(s32) = COPY %r2
     %3(s32) = COPY %r3
+    ; HARD-DAG: [[X:%[0-9]+]](s64) = G_SEQUENCE [[X0]]
+    ; HARD-DAG: [[Y:%[0-9]+]](s64) = G_SEQUENCE [[Y0]]
     %4(s64) = G_SEQUENCE %0(s32), 0, %1(s32), 32
     %5(s64) = G_SEQUENCE %2(s32), 0, %3(s32), 32
     ; CHECK: ADJCALLSTACKDOWN
-    ; CHECK-DAG: %r{{[0-1]}} = COPY [[X0]]
-    ; CHECK-DAG: %r{{[0-1]}} = COPY [[X1]]
-    ; CHECK-DAG: %r{{[2-3]}} = COPY [[Y0]]
-    ; CHECK-DAG: %r{{[2-3]}} = COPY [[Y1]]
-    ; CHECK: BLX $fmod, {{.*}}, implicit %r0, implicit %r1, implicit %r2, implicit %r3, implicit-def %r0, implicit-def %r1
+    ; SOFT-DAG: %r{{[0-1]}} = COPY [[X0]]
+    ; SOFT-DAG: %r{{[0-1]}} = COPY [[X1]]
+    ; SOFT-DAG: %r{{[2-3]}} = COPY [[Y0]]
+    ; SOFT-DAG: %r{{[2-3]}} = COPY [[Y1]]
+    ; HARD-DAG: %d0 = COPY [[X]]
+    ; HARD-DAG: %d1 = COPY [[Y]]
+    ; SOFT: BLX $fmod, {{.*}}, implicit %r0, implicit %r1, implicit %r2, implicit %r3, implicit-def %r0, implicit-def %r1
+    ; HARD: BLX $fmod, {{.*}}, implicit %d0, implicit %d1, implicit-def %d0
     ; CHECK: ADJCALLSTACKUP
     %6(s64) = G_FREM %4, %5
     %7(s32) = G_EXTRACT %6(s64), 0