OLD | NEW |
1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/globals.h" | 5 #include "vm/globals.h" |
6 #if defined(TARGET_ARCH_ARM) | 6 #if defined(TARGET_ARCH_ARM) |
7 | 7 |
8 #include "vm/assembler.h" | 8 #include "vm/assembler.h" |
9 #include "vm/cpu.h" | 9 #include "vm/cpu.h" |
10 #include "vm/os.h" | 10 #include "vm/os.h" |
11 #include "vm/unit_test.h" | 11 #include "vm/unit_test.h" |
12 #include "vm/virtual_memory.h" | 12 #include "vm/virtual_memory.h" |
13 | 13 |
14 namespace dart { | 14 namespace dart { |
15 | 15 |
16 #define __ assembler-> | 16 #define __ assembler-> |
17 | 17 |
18 | |
19 ASSEMBLER_TEST_GENERATE(Simple, assembler) { | 18 ASSEMBLER_TEST_GENERATE(Simple, assembler) { |
20 __ mov(R0, Operand(42)); | 19 __ mov(R0, Operand(42)); |
21 __ bx(LR); | 20 __ bx(LR); |
22 } | 21 } |
23 | 22 |
24 | |
25 ASSEMBLER_TEST_RUN(Simple, test) { | 23 ASSEMBLER_TEST_RUN(Simple, test) { |
26 typedef int (*SimpleCode)() DART_UNUSED; | 24 typedef int (*SimpleCode)() DART_UNUSED; |
27 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(SimpleCode, test->entry())); | 25 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(SimpleCode, test->entry())); |
28 } | 26 } |
29 | 27 |
30 | |
31 ASSEMBLER_TEST_GENERATE(MoveNegated, assembler) { | 28 ASSEMBLER_TEST_GENERATE(MoveNegated, assembler) { |
32 __ mvn(R0, Operand(42)); | 29 __ mvn(R0, Operand(42)); |
33 __ bx(LR); | 30 __ bx(LR); |
34 } | 31 } |
35 | 32 |
36 | |
37 ASSEMBLER_TEST_RUN(MoveNegated, test) { | 33 ASSEMBLER_TEST_RUN(MoveNegated, test) { |
38 EXPECT(test != NULL); | 34 EXPECT(test != NULL); |
39 typedef int (*MoveNegated)() DART_UNUSED; | 35 typedef int (*MoveNegated)() DART_UNUSED; |
40 EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT32(MoveNegated, test->entry())); | 36 EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT32(MoveNegated, test->entry())); |
41 } | 37 } |
42 | 38 |
43 | |
44 ASSEMBLER_TEST_GENERATE(MoveRotImm, assembler) { | 39 ASSEMBLER_TEST_GENERATE(MoveRotImm, assembler) { |
45 Operand o; | 40 Operand o; |
46 EXPECT(Operand::CanHold(0x00550000, &o)); | 41 EXPECT(Operand::CanHold(0x00550000, &o)); |
47 __ mov(R0, o); | 42 __ mov(R0, o); |
48 EXPECT(Operand::CanHold(0x30000003, &o)); | 43 EXPECT(Operand::CanHold(0x30000003, &o)); |
49 __ add(R0, R0, o); | 44 __ add(R0, R0, o); |
50 __ bx(LR); | 45 __ bx(LR); |
51 } | 46 } |
52 | 47 |
53 | |
54 ASSEMBLER_TEST_RUN(MoveRotImm, test) { | 48 ASSEMBLER_TEST_RUN(MoveRotImm, test) { |
55 EXPECT(test != NULL); | 49 EXPECT(test != NULL); |
56 typedef int (*MoveRotImm)() DART_UNUSED; | 50 typedef int (*MoveRotImm)() DART_UNUSED; |
57 EXPECT_EQ(0x30550003, EXECUTE_TEST_CODE_INT32(MoveRotImm, test->entry())); | 51 EXPECT_EQ(0x30550003, EXECUTE_TEST_CODE_INT32(MoveRotImm, test->entry())); |
58 } | 52 } |
59 | 53 |
60 | |
61 ASSEMBLER_TEST_GENERATE(MovImm16, assembler) { | 54 ASSEMBLER_TEST_GENERATE(MovImm16, assembler) { |
62 #if defined(USING_SIMULATOR) | 55 #if defined(USING_SIMULATOR) |
63 // ARMv7 is the default. | 56 // ARMv7 is the default. |
64 HostCPUFeatures::set_arm_version(ARMv6); | 57 HostCPUFeatures::set_arm_version(ARMv6); |
65 __ LoadPatchableImmediate(R0, 0x12345678 << 1); | 58 __ LoadPatchableImmediate(R0, 0x12345678 << 1); |
66 HostCPUFeatures::set_arm_version(ARMv7); | 59 HostCPUFeatures::set_arm_version(ARMv7); |
67 __ LoadPatchableImmediate(R1, 0x12345678); | 60 __ LoadPatchableImmediate(R1, 0x12345678); |
68 __ sub(R0, R0, Operand(R1)); | 61 __ sub(R0, R0, Operand(R1)); |
69 __ bx(LR); | 62 __ bx(LR); |
70 #else | 63 #else |
71 __ LoadPatchableImmediate(R0, 0x12345678); | 64 __ LoadPatchableImmediate(R0, 0x12345678); |
72 __ bx(LR); | 65 __ bx(LR); |
73 #endif | 66 #endif |
74 } | 67 } |
75 | 68 |
76 | |
77 ASSEMBLER_TEST_RUN(MovImm16, test) { | 69 ASSEMBLER_TEST_RUN(MovImm16, test) { |
78 EXPECT(test != NULL); | 70 EXPECT(test != NULL); |
79 typedef int (*MovImm16)() DART_UNUSED; | 71 typedef int (*MovImm16)() DART_UNUSED; |
80 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INT32(MovImm16, test->entry())); | 72 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INT32(MovImm16, test->entry())); |
81 } | 73 } |
82 | 74 |
83 | |
84 ASSEMBLER_TEST_GENERATE(LoadImmediate, assembler) { | 75 ASSEMBLER_TEST_GENERATE(LoadImmediate, assembler) { |
85 __ mov(R0, Operand(0)); | 76 __ mov(R0, Operand(0)); |
86 __ cmp(R0, Operand(0)); | 77 __ cmp(R0, Operand(0)); |
87 __ LoadImmediate(R0, 0x12345678, EQ); | 78 __ LoadImmediate(R0, 0x12345678, EQ); |
88 __ LoadImmediate(R0, 0x87654321, NE); | 79 __ LoadImmediate(R0, 0x87654321, NE); |
89 __ bx(LR); | 80 __ bx(LR); |
90 } | 81 } |
91 | 82 |
92 | |
93 ASSEMBLER_TEST_RUN(LoadImmediate, test) { | 83 ASSEMBLER_TEST_RUN(LoadImmediate, test) { |
94 EXPECT(test != NULL); | 84 EXPECT(test != NULL); |
95 typedef int (*LoadImmediate)() DART_UNUSED; | 85 typedef int (*LoadImmediate)() DART_UNUSED; |
96 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INT32(LoadImmediate, test->entry())); | 86 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INT32(LoadImmediate, test->entry())); |
97 } | 87 } |
98 | 88 |
99 | |
100 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) { | 89 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) { |
101 __ LoadHalfWordUnaligned(R1, R0, TMP); | 90 __ LoadHalfWordUnaligned(R1, R0, TMP); |
102 __ mov(R0, Operand(R1)); | 91 __ mov(R0, Operand(R1)); |
103 __ bx(LR); | 92 __ bx(LR); |
104 } | 93 } |
105 | 94 |
106 | |
107 ASSEMBLER_TEST_RUN(LoadHalfWordUnaligned, test) { | 95 ASSEMBLER_TEST_RUN(LoadHalfWordUnaligned, test) { |
108 EXPECT(test != NULL); | 96 EXPECT(test != NULL); |
109 typedef intptr_t (*LoadHalfWordUnaligned)(intptr_t) DART_UNUSED; | 97 typedef intptr_t (*LoadHalfWordUnaligned)(intptr_t) DART_UNUSED; |
110 uint8_t buffer[4] = { | 98 uint8_t buffer[4] = { |
111 0x89, 0xAB, 0xCD, 0xEF, | 99 0x89, 0xAB, 0xCD, 0xEF, |
112 }; | 100 }; |
113 | 101 |
114 EXPECT_EQ( | 102 EXPECT_EQ( |
115 static_cast<int16_t>(static_cast<uint16_t>(0xAB89)), | 103 static_cast<int16_t>(static_cast<uint16_t>(0xAB89)), |
116 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), | 104 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), |
117 reinterpret_cast<intptr_t>(&buffer[0]))); | 105 reinterpret_cast<intptr_t>(&buffer[0]))); |
118 EXPECT_EQ( | 106 EXPECT_EQ( |
119 static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)), | 107 static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)), |
120 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), | 108 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), |
121 reinterpret_cast<intptr_t>(&buffer[1]))); | 109 reinterpret_cast<intptr_t>(&buffer[1]))); |
122 } | 110 } |
123 | 111 |
124 | |
125 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) { | 112 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) { |
126 __ LoadHalfWordUnsignedUnaligned(R1, R0, TMP); | 113 __ LoadHalfWordUnsignedUnaligned(R1, R0, TMP); |
127 __ mov(R0, Operand(R1)); | 114 __ mov(R0, Operand(R1)); |
128 __ bx(LR); | 115 __ bx(LR); |
129 } | 116 } |
130 | 117 |
131 | |
132 ASSEMBLER_TEST_RUN(LoadHalfWordUnsignedUnaligned, test) { | 118 ASSEMBLER_TEST_RUN(LoadHalfWordUnsignedUnaligned, test) { |
133 EXPECT(test != NULL); | 119 EXPECT(test != NULL); |
134 typedef intptr_t (*LoadHalfWordUnsignedUnaligned)(intptr_t) DART_UNUSED; | 120 typedef intptr_t (*LoadHalfWordUnsignedUnaligned)(intptr_t) DART_UNUSED; |
135 uint8_t buffer[4] = { | 121 uint8_t buffer[4] = { |
136 0x89, 0xAB, 0xCD, 0xEF, | 122 0x89, 0xAB, 0xCD, 0xEF, |
137 }; | 123 }; |
138 | 124 |
139 EXPECT_EQ(0xAB89, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 125 EXPECT_EQ(0xAB89, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
140 LoadHalfWordUnsignedUnaligned, test->entry(), | 126 LoadHalfWordUnsignedUnaligned, test->entry(), |
141 reinterpret_cast<intptr_t>(&buffer[0]))); | 127 reinterpret_cast<intptr_t>(&buffer[0]))); |
142 EXPECT_EQ(0xCDAB, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 128 EXPECT_EQ(0xCDAB, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
143 LoadHalfWordUnsignedUnaligned, test->entry(), | 129 LoadHalfWordUnsignedUnaligned, test->entry(), |
144 reinterpret_cast<intptr_t>(&buffer[1]))); | 130 reinterpret_cast<intptr_t>(&buffer[1]))); |
145 } | 131 } |
146 | 132 |
147 | |
148 ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) { | 133 ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) { |
149 __ LoadImmediate(R1, 0xABCD); | 134 __ LoadImmediate(R1, 0xABCD); |
150 __ StoreWordUnaligned(R1, R0, TMP); | 135 __ StoreWordUnaligned(R1, R0, TMP); |
151 __ mov(R0, Operand(R1)); | 136 __ mov(R0, Operand(R1)); |
152 __ bx(LR); | 137 __ bx(LR); |
153 } | 138 } |
154 | 139 |
155 | |
156 ASSEMBLER_TEST_RUN(StoreHalfWordUnaligned, test) { | 140 ASSEMBLER_TEST_RUN(StoreHalfWordUnaligned, test) { |
157 EXPECT(test != NULL); | 141 EXPECT(test != NULL); |
158 typedef intptr_t (*StoreHalfWordUnaligned)(intptr_t) DART_UNUSED; | 142 typedef intptr_t (*StoreHalfWordUnaligned)(intptr_t) DART_UNUSED; |
159 uint8_t buffer[4] = { | 143 uint8_t buffer[4] = { |
160 0, 0, 0, 0, | 144 0, 0, 0, 0, |
161 }; | 145 }; |
162 | 146 |
163 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 147 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
164 StoreHalfWordUnaligned, test->entry(), | 148 StoreHalfWordUnaligned, test->entry(), |
165 reinterpret_cast<intptr_t>(&buffer[0]))); | 149 reinterpret_cast<intptr_t>(&buffer[0]))); |
166 EXPECT_EQ(0xCD, buffer[0]); | 150 EXPECT_EQ(0xCD, buffer[0]); |
167 EXPECT_EQ(0xAB, buffer[1]); | 151 EXPECT_EQ(0xAB, buffer[1]); |
168 EXPECT_EQ(0, buffer[2]); | 152 EXPECT_EQ(0, buffer[2]); |
169 | 153 |
170 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 154 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
171 StoreHalfWordUnaligned, test->entry(), | 155 StoreHalfWordUnaligned, test->entry(), |
172 reinterpret_cast<intptr_t>(&buffer[1]))); | 156 reinterpret_cast<intptr_t>(&buffer[1]))); |
173 EXPECT_EQ(0xCD, buffer[1]); | 157 EXPECT_EQ(0xCD, buffer[1]); |
174 EXPECT_EQ(0xAB, buffer[2]); | 158 EXPECT_EQ(0xAB, buffer[2]); |
175 EXPECT_EQ(0, buffer[3]); | 159 EXPECT_EQ(0, buffer[3]); |
176 } | 160 } |
177 | 161 |
178 | |
179 ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) { | 162 ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) { |
180 __ LoadWordUnaligned(R1, R0, TMP); | 163 __ LoadWordUnaligned(R1, R0, TMP); |
181 __ mov(R0, Operand(R1)); | 164 __ mov(R0, Operand(R1)); |
182 __ bx(LR); | 165 __ bx(LR); |
183 } | 166 } |
184 | 167 |
185 | |
186 ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) { | 168 ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) { |
187 EXPECT(test != NULL); | 169 EXPECT(test != NULL); |
188 typedef intptr_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED; | 170 typedef intptr_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED; |
189 uint8_t buffer[8] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; | 171 uint8_t buffer[8] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; |
190 | 172 |
191 EXPECT_EQ( | 173 EXPECT_EQ( |
192 static_cast<intptr_t>(0x78563412), | 174 static_cast<intptr_t>(0x78563412), |
193 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), | 175 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), |
194 reinterpret_cast<intptr_t>(&buffer[0]))); | 176 reinterpret_cast<intptr_t>(&buffer[0]))); |
195 EXPECT_EQ( | 177 EXPECT_EQ( |
196 static_cast<intptr_t>(0x9A785634), | 178 static_cast<intptr_t>(0x9A785634), |
197 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), | 179 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), |
198 reinterpret_cast<intptr_t>(&buffer[1]))); | 180 reinterpret_cast<intptr_t>(&buffer[1]))); |
199 EXPECT_EQ( | 181 EXPECT_EQ( |
200 static_cast<intptr_t>(0xBC9A7856), | 182 static_cast<intptr_t>(0xBC9A7856), |
201 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), | 183 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), |
202 reinterpret_cast<intptr_t>(&buffer[2]))); | 184 reinterpret_cast<intptr_t>(&buffer[2]))); |
203 EXPECT_EQ( | 185 EXPECT_EQ( |
204 static_cast<intptr_t>(0xDEBC9A78), | 186 static_cast<intptr_t>(0xDEBC9A78), |
205 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), | 187 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadWordUnaligned, test->entry(), |
206 reinterpret_cast<intptr_t>(&buffer[3]))); | 188 reinterpret_cast<intptr_t>(&buffer[3]))); |
207 } | 189 } |
208 | 190 |
209 | |
210 ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) { | 191 ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) { |
211 __ LoadImmediate(R1, 0x12345678); | 192 __ LoadImmediate(R1, 0x12345678); |
212 __ StoreWordUnaligned(R1, R0, TMP); | 193 __ StoreWordUnaligned(R1, R0, TMP); |
213 __ mov(R0, Operand(R1)); | 194 __ mov(R0, Operand(R1)); |
214 __ bx(LR); | 195 __ bx(LR); |
215 } | 196 } |
216 | 197 |
217 | |
218 ASSEMBLER_TEST_RUN(StoreWordUnaligned, test) { | 198 ASSEMBLER_TEST_RUN(StoreWordUnaligned, test) { |
219 EXPECT(test != NULL); | 199 EXPECT(test != NULL); |
220 typedef intptr_t (*StoreWordUnaligned)(intptr_t) DART_UNUSED; | 200 typedef intptr_t (*StoreWordUnaligned)(intptr_t) DART_UNUSED; |
221 uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0}; | 201 uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0}; |
222 | 202 |
223 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 203 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
224 StoreWordUnaligned, test->entry(), | 204 StoreWordUnaligned, test->entry(), |
225 reinterpret_cast<intptr_t>(&buffer[0]))); | 205 reinterpret_cast<intptr_t>(&buffer[0]))); |
226 EXPECT_EQ(0x78, buffer[0]); | 206 EXPECT_EQ(0x78, buffer[0]); |
227 EXPECT_EQ(0x56, buffer[1]); | 207 EXPECT_EQ(0x56, buffer[1]); |
(...skipping 18 matching lines...) Expand all Loading... |
246 | 226 |
247 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 227 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
248 StoreWordUnaligned, test->entry(), | 228 StoreWordUnaligned, test->entry(), |
249 reinterpret_cast<intptr_t>(&buffer[3]))); | 229 reinterpret_cast<intptr_t>(&buffer[3]))); |
250 EXPECT_EQ(0x78, buffer[3]); | 230 EXPECT_EQ(0x78, buffer[3]); |
251 EXPECT_EQ(0x56, buffer[4]); | 231 EXPECT_EQ(0x56, buffer[4]); |
252 EXPECT_EQ(0x34, buffer[5]); | 232 EXPECT_EQ(0x34, buffer[5]); |
253 EXPECT_EQ(0x12, buffer[6]); | 233 EXPECT_EQ(0x12, buffer[6]); |
254 } | 234 } |
255 | 235 |
256 | |
257 ASSEMBLER_TEST_GENERATE(Vmov, assembler) { | 236 ASSEMBLER_TEST_GENERATE(Vmov, assembler) { |
258 if (TargetCPUFeatures::vfp_supported()) { | 237 if (TargetCPUFeatures::vfp_supported()) { |
259 __ mov(R3, Operand(43)); | 238 __ mov(R3, Operand(43)); |
260 __ mov(R1, Operand(41)); | 239 __ mov(R1, Operand(41)); |
261 __ vmovsrr(S1, R1, R3); // S1:S2 = 41:43 | 240 __ vmovsrr(S1, R1, R3); // S1:S2 = 41:43 |
262 __ vmovs(S0, S2); // S0 = S2, S0:S1 == 43:41 | 241 __ vmovs(S0, S2); // S0 = S2, S0:S1 == 43:41 |
263 __ vmovd(D2, D0); // D2 = D0, S4:S5 == 43:41 | 242 __ vmovd(D2, D0); // D2 = D0, S4:S5 == 43:41 |
264 __ vmovrs(R3, S5); // R3 = S5, R3 == 41 | 243 __ vmovrs(R3, S5); // R3 = S5, R3 == 41 |
265 __ vmovrrs(R1, R2, S4); // R1:R2 = S4:S5, R1:R2 == 43:41 | 244 __ vmovrrs(R1, R2, S4); // R1:R2 = S4:S5, R1:R2 == 43:41 |
266 __ vmovdrr(D3, R3, R2); // D3 = R3:R2, S6:S7 == 41:41 | 245 __ vmovdrr(D3, R3, R2); // D3 = R3:R2, S6:S7 == 41:41 |
267 __ vmovdr(D3, 1, R1); // D3[1] == S7 = R1, S6:S7 == 41:43 | 246 __ vmovdr(D3, 1, R1); // D3[1] == S7 = R1, S6:S7 == 41:43 |
268 __ vmovrrd(R0, R1, D3); // R0:R1 = D3, R0:R1 == 41:43 | 247 __ vmovrrd(R0, R1, D3); // R0:R1 = D3, R0:R1 == 41:43 |
269 __ sub(R0, R1, Operand(R0)); // 43-41 | 248 __ sub(R0, R1, Operand(R0)); // 43-41 |
270 } | 249 } |
271 __ bx(LR); | 250 __ bx(LR); |
272 } | 251 } |
273 | 252 |
274 | |
275 ASSEMBLER_TEST_RUN(Vmov, test) { | 253 ASSEMBLER_TEST_RUN(Vmov, test) { |
276 EXPECT(test != NULL); | 254 EXPECT(test != NULL); |
277 if (TargetCPUFeatures::vfp_supported()) { | 255 if (TargetCPUFeatures::vfp_supported()) { |
278 typedef int (*Vmov)() DART_UNUSED; | 256 typedef int (*Vmov)() DART_UNUSED; |
279 EXPECT_EQ(2, EXECUTE_TEST_CODE_INT32(Vmov, test->entry())); | 257 EXPECT_EQ(2, EXECUTE_TEST_CODE_INT32(Vmov, test->entry())); |
280 } | 258 } |
281 } | 259 } |
282 | 260 |
283 | |
284 ASSEMBLER_TEST_GENERATE(SingleVLoadStore, assembler) { | 261 ASSEMBLER_TEST_GENERATE(SingleVLoadStore, assembler) { |
285 if (TargetCPUFeatures::vfp_supported()) { | 262 if (TargetCPUFeatures::vfp_supported()) { |
286 __ LoadImmediate(R0, bit_cast<int32_t, float>(12.3f)); | 263 __ LoadImmediate(R0, bit_cast<int32_t, float>(12.3f)); |
287 __ mov(R2, Operand(SP)); | 264 __ mov(R2, Operand(SP)); |
288 __ str(R0, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 265 __ str(R0, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
289 __ vldrs(S0, Address(R2, (-kWordSize * 30))); | 266 __ vldrs(S0, Address(R2, (-kWordSize * 30))); |
290 __ vadds(S0, S0, S0); | 267 __ vadds(S0, S0, S0); |
291 __ vstrs(S0, Address(R2, (-kWordSize * 30))); | 268 __ vstrs(S0, Address(R2, (-kWordSize * 30))); |
292 __ ldr(R0, Address(SP, (kWordSize * 30), Address::PostIndex)); | 269 __ ldr(R0, Address(SP, (kWordSize * 30), Address::PostIndex)); |
293 } | 270 } |
294 __ bx(LR); | 271 __ bx(LR); |
295 } | 272 } |
296 | 273 |
297 | |
298 ASSEMBLER_TEST_RUN(SingleVLoadStore, test) { | 274 ASSEMBLER_TEST_RUN(SingleVLoadStore, test) { |
299 EXPECT(test != NULL); | 275 EXPECT(test != NULL); |
300 if (TargetCPUFeatures::vfp_supported()) { | 276 if (TargetCPUFeatures::vfp_supported()) { |
301 typedef float (*SingleVLoadStore)() DART_UNUSED; | 277 typedef float (*SingleVLoadStore)() DART_UNUSED; |
302 float res = EXECUTE_TEST_CODE_FLOAT(SingleVLoadStore, test->entry()); | 278 float res = EXECUTE_TEST_CODE_FLOAT(SingleVLoadStore, test->entry()); |
303 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); | 279 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); |
304 } | 280 } |
305 } | 281 } |
306 | 282 |
307 | |
308 ASSEMBLER_TEST_GENERATE(SingleVShiftLoadStore, assembler) { | 283 ASSEMBLER_TEST_GENERATE(SingleVShiftLoadStore, assembler) { |
309 if (TargetCPUFeatures::vfp_supported()) { | 284 if (TargetCPUFeatures::vfp_supported()) { |
310 __ LoadImmediate(R0, bit_cast<int32_t, float>(12.3f)); | 285 __ LoadImmediate(R0, bit_cast<int32_t, float>(12.3f)); |
311 __ mov(R2, Operand(SP)); | 286 __ mov(R2, Operand(SP)); |
312 // Expressing __str(R0, Address(SP, (-kWordSize * 32), Address::PreIndex)); | 287 // Expressing __str(R0, Address(SP, (-kWordSize * 32), Address::PreIndex)); |
313 // as: | 288 // as: |
314 __ mov(R1, Operand(kWordSize)); | 289 __ mov(R1, Operand(kWordSize)); |
315 __ str(R0, Address(SP, R1, LSL, 5, Address::NegPreIndex)); | 290 __ str(R0, Address(SP, R1, LSL, 5, Address::NegPreIndex)); |
316 __ vldrs(S0, Address(R2, (-kWordSize * 32))); | 291 __ vldrs(S0, Address(R2, (-kWordSize * 32))); |
317 __ vadds(S0, S0, S0); | 292 __ vadds(S0, S0, S0); |
318 __ vstrs(S0, Address(R2, (-kWordSize * 32))); | 293 __ vstrs(S0, Address(R2, (-kWordSize * 32))); |
319 // Expressing __ldr(R0, Address(SP, (kWordSize * 32), Address::PostIndex)); | 294 // Expressing __ldr(R0, Address(SP, (kWordSize * 32), Address::PostIndex)); |
320 // as: | 295 // as: |
321 __ ldr(R0, Address(SP, R1, LSL, 5, Address::PostIndex)); | 296 __ ldr(R0, Address(SP, R1, LSL, 5, Address::PostIndex)); |
322 } | 297 } |
323 __ bx(LR); | 298 __ bx(LR); |
324 } | 299 } |
325 | 300 |
326 | |
327 ASSEMBLER_TEST_RUN(SingleVShiftLoadStore, test) { | 301 ASSEMBLER_TEST_RUN(SingleVShiftLoadStore, test) { |
328 EXPECT(test != NULL); | 302 EXPECT(test != NULL); |
329 if (TargetCPUFeatures::vfp_supported()) { | 303 if (TargetCPUFeatures::vfp_supported()) { |
330 typedef float (*SingleVLoadStore)() DART_UNUSED; | 304 typedef float (*SingleVLoadStore)() DART_UNUSED; |
331 float res = EXECUTE_TEST_CODE_FLOAT(SingleVLoadStore, test->entry()); | 305 float res = EXECUTE_TEST_CODE_FLOAT(SingleVLoadStore, test->entry()); |
332 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); | 306 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); |
333 } | 307 } |
334 } | 308 } |
335 | 309 |
336 | |
337 ASSEMBLER_TEST_GENERATE(DoubleVLoadStore, assembler) { | 310 ASSEMBLER_TEST_GENERATE(DoubleVLoadStore, assembler) { |
338 if (TargetCPUFeatures::vfp_supported()) { | 311 if (TargetCPUFeatures::vfp_supported()) { |
339 int64_t value = bit_cast<int64_t, double>(12.3); | 312 int64_t value = bit_cast<int64_t, double>(12.3); |
340 __ LoadImmediate(R0, Utils::Low32Bits(value)); | 313 __ LoadImmediate(R0, Utils::Low32Bits(value)); |
341 __ LoadImmediate(R1, Utils::High32Bits(value)); | 314 __ LoadImmediate(R1, Utils::High32Bits(value)); |
342 __ mov(R2, Operand(SP)); | 315 __ mov(R2, Operand(SP)); |
343 __ str(R0, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 316 __ str(R0, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
344 __ str(R1, Address(R2, (-kWordSize * 29))); | 317 __ str(R1, Address(R2, (-kWordSize * 29))); |
345 __ vldrd(D0, Address(R2, (-kWordSize * 30))); | 318 __ vldrd(D0, Address(R2, (-kWordSize * 30))); |
346 __ vaddd(D0, D0, D0); | 319 __ vaddd(D0, D0, D0); |
347 __ vstrd(D0, Address(R2, (-kWordSize * 30))); | 320 __ vstrd(D0, Address(R2, (-kWordSize * 30))); |
348 __ ldr(R1, Address(R2, (-kWordSize * 29))); | 321 __ ldr(R1, Address(R2, (-kWordSize * 29))); |
349 __ ldr(R0, Address(SP, (kWordSize * 30), Address::PostIndex)); | 322 __ ldr(R0, Address(SP, (kWordSize * 30), Address::PostIndex)); |
350 } | 323 } |
351 __ bx(LR); | 324 __ bx(LR); |
352 } | 325 } |
353 | 326 |
354 | |
355 ASSEMBLER_TEST_RUN(DoubleVLoadStore, test) { | 327 ASSEMBLER_TEST_RUN(DoubleVLoadStore, test) { |
356 EXPECT(test != NULL); | 328 EXPECT(test != NULL); |
357 if (TargetCPUFeatures::vfp_supported()) { | 329 if (TargetCPUFeatures::vfp_supported()) { |
358 typedef double (*DoubleVLoadStore)() DART_UNUSED; | 330 typedef double (*DoubleVLoadStore)() DART_UNUSED; |
359 float res = EXECUTE_TEST_CODE_DOUBLE(DoubleVLoadStore, test->entry()); | 331 float res = EXECUTE_TEST_CODE_DOUBLE(DoubleVLoadStore, test->entry()); |
360 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); | 332 EXPECT_FLOAT_EQ(2 * 12.3f, res, 0.001f); |
361 } | 333 } |
362 } | 334 } |
363 | 335 |
364 | |
365 ASSEMBLER_TEST_GENERATE(SingleFPOperations, assembler) { | 336 ASSEMBLER_TEST_GENERATE(SingleFPOperations, assembler) { |
366 if (TargetCPUFeatures::vfp_supported()) { | 337 if (TargetCPUFeatures::vfp_supported()) { |
367 __ LoadSImmediate(S0, 12.3f); | 338 __ LoadSImmediate(S0, 12.3f); |
368 __ LoadSImmediate(S1, 3.4f); | 339 __ LoadSImmediate(S1, 3.4f); |
369 __ vnegs(S0, S0); // -12.3f | 340 __ vnegs(S0, S0); // -12.3f |
370 __ vabss(S0, S0); // 12.3f | 341 __ vabss(S0, S0); // 12.3f |
371 __ vadds(S0, S0, S1); // 15.7f | 342 __ vadds(S0, S0, S1); // 15.7f |
372 __ vmuls(S0, S0, S1); // 53.38f | 343 __ vmuls(S0, S0, S1); // 53.38f |
373 __ vsubs(S0, S0, S1); // 49.98f | 344 __ vsubs(S0, S0, S1); // 49.98f |
374 __ vdivs(S0, S0, S1); // 14.7f | 345 __ vdivs(S0, S0, S1); // 14.7f |
375 __ vsqrts(S0, S0); // 3.8340579f | 346 __ vsqrts(S0, S0); // 3.8340579f |
376 } | 347 } |
377 __ bx(LR); | 348 __ bx(LR); |
378 } | 349 } |
379 | 350 |
380 | |
381 ASSEMBLER_TEST_RUN(SingleFPOperations, test) { | 351 ASSEMBLER_TEST_RUN(SingleFPOperations, test) { |
382 EXPECT(test != NULL); | 352 EXPECT(test != NULL); |
383 if (TargetCPUFeatures::vfp_supported()) { | 353 if (TargetCPUFeatures::vfp_supported()) { |
384 typedef float (*SingleFPOperations)() DART_UNUSED; | 354 typedef float (*SingleFPOperations)() DART_UNUSED; |
385 float res = EXECUTE_TEST_CODE_FLOAT(SingleFPOperations, test->entry()); | 355 float res = EXECUTE_TEST_CODE_FLOAT(SingleFPOperations, test->entry()); |
386 EXPECT_FLOAT_EQ(3.8340579f, res, 0.001f); | 356 EXPECT_FLOAT_EQ(3.8340579f, res, 0.001f); |
387 } | 357 } |
388 } | 358 } |
389 | 359 |
390 | |
391 ASSEMBLER_TEST_GENERATE(DoubleFPOperations, assembler) { | 360 ASSEMBLER_TEST_GENERATE(DoubleFPOperations, assembler) { |
392 if (TargetCPUFeatures::vfp_supported()) { | 361 if (TargetCPUFeatures::vfp_supported()) { |
393 __ LoadDImmediate(D0, 12.3, R0); | 362 __ LoadDImmediate(D0, 12.3, R0); |
394 __ LoadDImmediate(D1, 3.4, R0); | 363 __ LoadDImmediate(D1, 3.4, R0); |
395 __ vnegd(D0, D0); // -12.3 | 364 __ vnegd(D0, D0); // -12.3 |
396 __ vabsd(D0, D0); // 12.3 | 365 __ vabsd(D0, D0); // 12.3 |
397 __ vaddd(D0, D0, D1); // 15.7 | 366 __ vaddd(D0, D0, D1); // 15.7 |
398 __ vmuld(D0, D0, D1); // 53.38 | 367 __ vmuld(D0, D0, D1); // 53.38 |
399 __ vsubd(D0, D0, D1); // 49.98 | 368 __ vsubd(D0, D0, D1); // 49.98 |
400 __ vdivd(D0, D0, D1); // 14.7 | 369 __ vdivd(D0, D0, D1); // 14.7 |
401 __ vsqrtd(D0, D0); // 3.8340579 | 370 __ vsqrtd(D0, D0); // 3.8340579 |
402 } | 371 } |
403 __ bx(LR); | 372 __ bx(LR); |
404 } | 373 } |
405 | 374 |
406 | |
407 ASSEMBLER_TEST_RUN(DoubleFPOperations, test) { | 375 ASSEMBLER_TEST_RUN(DoubleFPOperations, test) { |
408 EXPECT(test != NULL); | 376 EXPECT(test != NULL); |
409 if (TargetCPUFeatures::vfp_supported()) { | 377 if (TargetCPUFeatures::vfp_supported()) { |
410 typedef double (*DoubleFPOperations)() DART_UNUSED; | 378 typedef double (*DoubleFPOperations)() DART_UNUSED; |
411 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleFPOperations, test->entry()); | 379 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleFPOperations, test->entry()); |
412 EXPECT_FLOAT_EQ(3.8340579, res, 0.001); | 380 EXPECT_FLOAT_EQ(3.8340579, res, 0.001); |
413 } | 381 } |
414 } | 382 } |
415 | 383 |
416 | |
417 ASSEMBLER_TEST_GENERATE(DoubleSqrtNeg, assembler) { | 384 ASSEMBLER_TEST_GENERATE(DoubleSqrtNeg, assembler) { |
418 if (TargetCPUFeatures::vfp_supported()) { | 385 if (TargetCPUFeatures::vfp_supported()) { |
419 // Check that sqrt of a negative double gives NaN. | 386 // Check that sqrt of a negative double gives NaN. |
420 __ LoadDImmediate(D1, -1.0, R0); | 387 __ LoadDImmediate(D1, -1.0, R0); |
421 __ vsqrtd(D0, D1); | 388 __ vsqrtd(D0, D1); |
422 __ vcmpd(D0, D0); | 389 __ vcmpd(D0, D0); |
423 __ vmstat(); | 390 __ vmstat(); |
424 __ mov(R0, Operand(1), VS); | 391 __ mov(R0, Operand(1), VS); |
425 __ mov(R0, Operand(0), VC); | 392 __ mov(R0, Operand(0), VC); |
426 } | 393 } |
427 __ Ret(); | 394 __ Ret(); |
428 } | 395 } |
429 | 396 |
430 | |
431 ASSEMBLER_TEST_RUN(DoubleSqrtNeg, test) { | 397 ASSEMBLER_TEST_RUN(DoubleSqrtNeg, test) { |
432 EXPECT(test != NULL); | 398 EXPECT(test != NULL); |
433 if (TargetCPUFeatures::vfp_supported()) { | 399 if (TargetCPUFeatures::vfp_supported()) { |
434 typedef int (*DoubleSqrtNeg)() DART_UNUSED; | 400 typedef int (*DoubleSqrtNeg)() DART_UNUSED; |
435 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(DoubleSqrtNeg, test->entry())); | 401 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(DoubleSqrtNeg, test->entry())); |
436 } | 402 } |
437 } | 403 } |
438 | 404 |
439 | |
440 ASSEMBLER_TEST_GENERATE(IntToDoubleConversion, assembler) { | 405 ASSEMBLER_TEST_GENERATE(IntToDoubleConversion, assembler) { |
441 if (TargetCPUFeatures::vfp_supported()) { | 406 if (TargetCPUFeatures::vfp_supported()) { |
442 __ mov(R3, Operand(6)); | 407 __ mov(R3, Operand(6)); |
443 __ vmovsr(S3, R3); | 408 __ vmovsr(S3, R3); |
444 __ vcvtdi(D0, S3); | 409 __ vcvtdi(D0, S3); |
445 } | 410 } |
446 __ bx(LR); | 411 __ bx(LR); |
447 } | 412 } |
448 | 413 |
449 | |
450 ASSEMBLER_TEST_RUN(IntToDoubleConversion, test) { | 414 ASSEMBLER_TEST_RUN(IntToDoubleConversion, test) { |
451 EXPECT(test != NULL); | 415 EXPECT(test != NULL); |
452 if (TargetCPUFeatures::vfp_supported()) { | 416 if (TargetCPUFeatures::vfp_supported()) { |
453 typedef double (*IntToDoubleConversionCode)() DART_UNUSED; | 417 typedef double (*IntToDoubleConversionCode)() DART_UNUSED; |
454 double res = | 418 double res = |
455 EXECUTE_TEST_CODE_DOUBLE(IntToDoubleConversionCode, test->entry()); | 419 EXECUTE_TEST_CODE_DOUBLE(IntToDoubleConversionCode, test->entry()); |
456 EXPECT_FLOAT_EQ(6.0, res, 0.001); | 420 EXPECT_FLOAT_EQ(6.0, res, 0.001); |
457 } | 421 } |
458 } | 422 } |
459 | 423 |
460 | |
461 ASSEMBLER_TEST_GENERATE(LongToDoubleConversion, assembler) { | 424 ASSEMBLER_TEST_GENERATE(LongToDoubleConversion, assembler) { |
462 if (TargetCPUFeatures::vfp_supported()) { | 425 if (TargetCPUFeatures::vfp_supported()) { |
463 int64_t value = 60000000000LL; | 426 int64_t value = 60000000000LL; |
464 __ LoadImmediate(R0, Utils::Low32Bits(value)); | 427 __ LoadImmediate(R0, Utils::Low32Bits(value)); |
465 __ LoadImmediate(R1, Utils::High32Bits(value)); | 428 __ LoadImmediate(R1, Utils::High32Bits(value)); |
466 __ vmovsr(S0, R0); | 429 __ vmovsr(S0, R0); |
467 __ vmovsr(S2, R1); | 430 __ vmovsr(S2, R1); |
468 __ vcvtdu(D0, S0); | 431 __ vcvtdu(D0, S0); |
469 __ vcvtdi(D1, S2); | 432 __ vcvtdi(D1, S2); |
470 __ LoadDImmediate(D2, 1.0 * (1LL << 32), R0); | 433 __ LoadDImmediate(D2, 1.0 * (1LL << 32), R0); |
471 __ vmlad(D0, D1, D2); | 434 __ vmlad(D0, D1, D2); |
472 } | 435 } |
473 __ bx(LR); | 436 __ bx(LR); |
474 } | 437 } |
475 | 438 |
476 | |
477 ASSEMBLER_TEST_RUN(LongToDoubleConversion, test) { | 439 ASSEMBLER_TEST_RUN(LongToDoubleConversion, test) { |
478 EXPECT(test != NULL); | 440 EXPECT(test != NULL); |
479 if (TargetCPUFeatures::vfp_supported()) { | 441 if (TargetCPUFeatures::vfp_supported()) { |
480 typedef double (*LongToDoubleConversionCode)() DART_UNUSED; | 442 typedef double (*LongToDoubleConversionCode)() DART_UNUSED; |
481 double res = | 443 double res = |
482 EXECUTE_TEST_CODE_DOUBLE(LongToDoubleConversionCode, test->entry()); | 444 EXECUTE_TEST_CODE_DOUBLE(LongToDoubleConversionCode, test->entry()); |
483 EXPECT_FLOAT_EQ(60000000000.0, res, 0.001); | 445 EXPECT_FLOAT_EQ(60000000000.0, res, 0.001); |
484 } | 446 } |
485 } | 447 } |
486 | 448 |
487 | |
488 ASSEMBLER_TEST_GENERATE(IntToFloatConversion, assembler) { | 449 ASSEMBLER_TEST_GENERATE(IntToFloatConversion, assembler) { |
489 if (TargetCPUFeatures::vfp_supported()) { | 450 if (TargetCPUFeatures::vfp_supported()) { |
490 __ mov(R3, Operand(6)); | 451 __ mov(R3, Operand(6)); |
491 __ vmovsr(S3, R3); | 452 __ vmovsr(S3, R3); |
492 __ vcvtsi(S0, S3); | 453 __ vcvtsi(S0, S3); |
493 } | 454 } |
494 __ bx(LR); | 455 __ bx(LR); |
495 } | 456 } |
496 | 457 |
497 | |
498 ASSEMBLER_TEST_RUN(IntToFloatConversion, test) { | 458 ASSEMBLER_TEST_RUN(IntToFloatConversion, test) { |
499 EXPECT(test != NULL); | 459 EXPECT(test != NULL); |
500 if (TargetCPUFeatures::vfp_supported()) { | 460 if (TargetCPUFeatures::vfp_supported()) { |
501 typedef float (*IntToFloatConversionCode)() DART_UNUSED; | 461 typedef float (*IntToFloatConversionCode)() DART_UNUSED; |
502 float res = | 462 float res = |
503 EXECUTE_TEST_CODE_FLOAT(IntToFloatConversionCode, test->entry()); | 463 EXECUTE_TEST_CODE_FLOAT(IntToFloatConversionCode, test->entry()); |
504 EXPECT_FLOAT_EQ(6.0, res, 0.001); | 464 EXPECT_FLOAT_EQ(6.0, res, 0.001); |
505 } | 465 } |
506 } | 466 } |
507 | 467 |
508 | |
509 ASSEMBLER_TEST_GENERATE(FloatToIntConversion, assembler) { | 468 ASSEMBLER_TEST_GENERATE(FloatToIntConversion, assembler) { |
510 if (TargetCPUFeatures::vfp_supported()) { | 469 if (TargetCPUFeatures::vfp_supported()) { |
511 __ vcvtis(S1, S0); | 470 __ vcvtis(S1, S0); |
512 __ vmovrs(R0, S1); | 471 __ vmovrs(R0, S1); |
513 } | 472 } |
514 __ bx(LR); | 473 __ bx(LR); |
515 } | 474 } |
516 | 475 |
517 | |
518 ASSEMBLER_TEST_RUN(FloatToIntConversion, test) { | 476 ASSEMBLER_TEST_RUN(FloatToIntConversion, test) { |
519 EXPECT(test != NULL); | 477 EXPECT(test != NULL); |
520 if (TargetCPUFeatures::vfp_supported()) { | 478 if (TargetCPUFeatures::vfp_supported()) { |
521 typedef int (*FloatToIntConversion)(float arg) DART_UNUSED; | 479 typedef int (*FloatToIntConversion)(float arg) DART_UNUSED; |
522 EXPECT_EQ(12, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, test->entry(), | 480 EXPECT_EQ(12, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, test->entry(), |
523 12.8f)); | 481 12.8f)); |
524 EXPECT_EQ(INT_MIN, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, | 482 EXPECT_EQ(INT_MIN, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, |
525 test->entry(), -FLT_MAX)); | 483 test->entry(), -FLT_MAX)); |
526 EXPECT_EQ(INT_MAX, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, | 484 EXPECT_EQ(INT_MAX, EXECUTE_TEST_CODE_INT32_F(FloatToIntConversion, |
527 test->entry(), FLT_MAX)); | 485 test->entry(), FLT_MAX)); |
528 } | 486 } |
529 } | 487 } |
530 | 488 |
531 | |
532 ASSEMBLER_TEST_GENERATE(DoubleToIntConversion, assembler) { | 489 ASSEMBLER_TEST_GENERATE(DoubleToIntConversion, assembler) { |
533 if (TargetCPUFeatures::vfp_supported()) { | 490 if (TargetCPUFeatures::vfp_supported()) { |
534 __ vcvtid(S0, D0); | 491 __ vcvtid(S0, D0); |
535 __ vmovrs(R0, S0); | 492 __ vmovrs(R0, S0); |
536 } | 493 } |
537 __ bx(LR); | 494 __ bx(LR); |
538 } | 495 } |
539 | 496 |
540 | |
541 ASSEMBLER_TEST_RUN(DoubleToIntConversion, test) { | 497 ASSEMBLER_TEST_RUN(DoubleToIntConversion, test) { |
542 if (TargetCPUFeatures::vfp_supported()) { | 498 if (TargetCPUFeatures::vfp_supported()) { |
543 typedef int (*DoubleToIntConversion)(double arg) DART_UNUSED; | 499 typedef int (*DoubleToIntConversion)(double arg) DART_UNUSED; |
544 EXPECT(test != NULL); | 500 EXPECT(test != NULL); |
545 EXPECT_EQ(12, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, | 501 EXPECT_EQ(12, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, |
546 test->entry(), 12.8)); | 502 test->entry(), 12.8)); |
547 EXPECT_EQ(INT_MIN, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, | 503 EXPECT_EQ(INT_MIN, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, |
548 test->entry(), -DBL_MAX)); | 504 test->entry(), -DBL_MAX)); |
549 EXPECT_EQ(INT_MAX, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, | 505 EXPECT_EQ(INT_MAX, EXECUTE_TEST_CODE_INT32_D(DoubleToIntConversion, |
550 test->entry(), DBL_MAX)); | 506 test->entry(), DBL_MAX)); |
551 } | 507 } |
552 } | 508 } |
553 | 509 |
554 | |
555 ASSEMBLER_TEST_GENERATE(FloatToDoubleConversion, assembler) { | 510 ASSEMBLER_TEST_GENERATE(FloatToDoubleConversion, assembler) { |
556 if (TargetCPUFeatures::vfp_supported()) { | 511 if (TargetCPUFeatures::vfp_supported()) { |
557 __ LoadSImmediate(S2, 12.8f); | 512 __ LoadSImmediate(S2, 12.8f); |
558 __ vcvtds(D0, S2); | 513 __ vcvtds(D0, S2); |
559 } | 514 } |
560 __ bx(LR); | 515 __ bx(LR); |
561 } | 516 } |
562 | 517 |
563 | |
564 ASSEMBLER_TEST_RUN(FloatToDoubleConversion, test) { | 518 ASSEMBLER_TEST_RUN(FloatToDoubleConversion, test) { |
565 if (TargetCPUFeatures::vfp_supported()) { | 519 if (TargetCPUFeatures::vfp_supported()) { |
566 typedef double (*FloatToDoubleConversionCode)() DART_UNUSED; | 520 typedef double (*FloatToDoubleConversionCode)() DART_UNUSED; |
567 EXPECT(test != NULL); | 521 EXPECT(test != NULL); |
568 double res = | 522 double res = |
569 EXECUTE_TEST_CODE_DOUBLE(FloatToDoubleConversionCode, test->entry()); | 523 EXECUTE_TEST_CODE_DOUBLE(FloatToDoubleConversionCode, test->entry()); |
570 EXPECT_FLOAT_EQ(12.8, res, 0.001); | 524 EXPECT_FLOAT_EQ(12.8, res, 0.001); |
571 } | 525 } |
572 } | 526 } |
573 | 527 |
574 | |
575 ASSEMBLER_TEST_GENERATE(DoubleToFloatConversion, assembler) { | 528 ASSEMBLER_TEST_GENERATE(DoubleToFloatConversion, assembler) { |
576 if (TargetCPUFeatures::vfp_supported()) { | 529 if (TargetCPUFeatures::vfp_supported()) { |
577 __ LoadDImmediate(D1, 12.8, R0); | 530 __ LoadDImmediate(D1, 12.8, R0); |
578 __ vcvtsd(S0, D1); | 531 __ vcvtsd(S0, D1); |
579 } | 532 } |
580 __ bx(LR); | 533 __ bx(LR); |
581 } | 534 } |
582 | 535 |
583 | |
584 ASSEMBLER_TEST_RUN(DoubleToFloatConversion, test) { | 536 ASSEMBLER_TEST_RUN(DoubleToFloatConversion, test) { |
585 EXPECT(test != NULL); | 537 EXPECT(test != NULL); |
586 if (TargetCPUFeatures::vfp_supported()) { | 538 if (TargetCPUFeatures::vfp_supported()) { |
587 typedef float (*DoubleToFloatConversionCode)() DART_UNUSED; | 539 typedef float (*DoubleToFloatConversionCode)() DART_UNUSED; |
588 float res = | 540 float res = |
589 EXECUTE_TEST_CODE_FLOAT(DoubleToFloatConversionCode, test->entry()); | 541 EXECUTE_TEST_CODE_FLOAT(DoubleToFloatConversionCode, test->entry()); |
590 EXPECT_FLOAT_EQ(12.8, res, 0.001); | 542 EXPECT_FLOAT_EQ(12.8, res, 0.001); |
591 } | 543 } |
592 } | 544 } |
593 | 545 |
594 | |
595 ASSEMBLER_TEST_GENERATE(FloatCompare, assembler) { | 546 ASSEMBLER_TEST_GENERATE(FloatCompare, assembler) { |
596 if (TargetCPUFeatures::vfp_supported()) { | 547 if (TargetCPUFeatures::vfp_supported()) { |
597 // Test 12.3f vs 12.5f. | 548 // Test 12.3f vs 12.5f. |
598 __ LoadSImmediate(S0, 12.3f); | 549 __ LoadSImmediate(S0, 12.3f); |
599 __ LoadSImmediate(S1, 12.5f); | 550 __ LoadSImmediate(S1, 12.5f); |
600 | 551 |
601 // Count errors in R0. R0 is zero if no errors found. | 552 // Count errors in R0. R0 is zero if no errors found. |
602 __ mov(R0, Operand(0)); | 553 __ mov(R0, Operand(0)); |
603 __ vcmps(S0, S1); | 554 __ vcmps(S0, S1); |
604 __ vmstat(); | 555 __ vmstat(); |
605 __ add(R0, R0, Operand(1), VS); // Error if unordered (Nan). | 556 __ add(R0, R0, Operand(1), VS); // Error if unordered (Nan). |
606 __ add(R0, R0, Operand(2), GT); // Error if greater. | 557 __ add(R0, R0, Operand(2), GT); // Error if greater. |
607 __ add(R0, R0, Operand(4), EQ); // Error if equal. | 558 __ add(R0, R0, Operand(4), EQ); // Error if equal. |
608 __ add(R0, R0, Operand(8), PL); // Error if not less. | 559 __ add(R0, R0, Operand(8), PL); // Error if not less. |
609 | 560 |
610 // Test NaN. | 561 // Test NaN. |
611 // Create NaN by dividing 0.0f/0.0f. | 562 // Create NaN by dividing 0.0f/0.0f. |
612 __ LoadSImmediate(S1, 0.0f); | 563 __ LoadSImmediate(S1, 0.0f); |
613 __ vdivs(S1, S1, S1); | 564 __ vdivs(S1, S1, S1); |
614 __ vcmps(S1, S1); | 565 __ vcmps(S1, S1); |
615 __ vmstat(); | 566 __ vmstat(); |
616 // Error if not unordered (not Nan). | 567 // Error if not unordered (not Nan). |
617 __ add(R0, R0, Operand(16), VC); | 568 __ add(R0, R0, Operand(16), VC); |
618 } | 569 } |
619 // R0 is 0 if all tests passed. | 570 // R0 is 0 if all tests passed. |
620 __ bx(LR); | 571 __ bx(LR); |
621 } | 572 } |
622 | 573 |
623 | |
624 ASSEMBLER_TEST_RUN(FloatCompare, test) { | 574 ASSEMBLER_TEST_RUN(FloatCompare, test) { |
625 EXPECT(test != NULL); | 575 EXPECT(test != NULL); |
626 if (TargetCPUFeatures::vfp_supported()) { | 576 if (TargetCPUFeatures::vfp_supported()) { |
627 typedef int (*FloatCompare)() DART_UNUSED; | 577 typedef int (*FloatCompare)() DART_UNUSED; |
628 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(FloatCompare, test->entry())); | 578 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(FloatCompare, test->entry())); |
629 } | 579 } |
630 } | 580 } |
631 | 581 |
632 | |
633 ASSEMBLER_TEST_GENERATE(DoubleCompare, assembler) { | 582 ASSEMBLER_TEST_GENERATE(DoubleCompare, assembler) { |
634 if (TargetCPUFeatures::vfp_supported()) { | 583 if (TargetCPUFeatures::vfp_supported()) { |
635 // Test 12.3 vs 12.5. | 584 // Test 12.3 vs 12.5. |
636 __ LoadDImmediate(D0, 12.3, R1); | 585 __ LoadDImmediate(D0, 12.3, R1); |
637 __ LoadDImmediate(D1, 12.5, R1); | 586 __ LoadDImmediate(D1, 12.5, R1); |
638 | 587 |
639 // Count errors in R0. R0 is zero if no errors found. | 588 // Count errors in R0. R0 is zero if no errors found. |
640 __ mov(R0, Operand(0)); | 589 __ mov(R0, Operand(0)); |
641 __ vcmpd(D0, D1); | 590 __ vcmpd(D0, D1); |
642 __ vmstat(); | 591 __ vmstat(); |
643 __ add(R0, R0, Operand(1), VS); // Error if unordered (Nan). | 592 __ add(R0, R0, Operand(1), VS); // Error if unordered (Nan). |
644 __ add(R0, R0, Operand(2), GT); // Error if greater. | 593 __ add(R0, R0, Operand(2), GT); // Error if greater. |
645 __ add(R0, R0, Operand(4), EQ); // Error if equal. | 594 __ add(R0, R0, Operand(4), EQ); // Error if equal. |
646 __ add(R0, R0, Operand(8), PL); // Error if not less. | 595 __ add(R0, R0, Operand(8), PL); // Error if not less. |
647 | 596 |
648 // Test NaN. | 597 // Test NaN. |
649 // Create NaN by dividing 0.0/0.0. | 598 // Create NaN by dividing 0.0/0.0. |
650 __ LoadDImmediate(D1, 0.0, R1); | 599 __ LoadDImmediate(D1, 0.0, R1); |
651 __ vdivd(D1, D1, D1); | 600 __ vdivd(D1, D1, D1); |
652 __ vcmpd(D1, D1); | 601 __ vcmpd(D1, D1); |
653 __ vmstat(); | 602 __ vmstat(); |
654 // Error if not unordered (not Nan). | 603 // Error if not unordered (not Nan). |
655 __ add(R0, R0, Operand(16), VC); | 604 __ add(R0, R0, Operand(16), VC); |
656 } | 605 } |
657 // R0 is 0 if all tests passed. | 606 // R0 is 0 if all tests passed. |
658 __ bx(LR); | 607 __ bx(LR); |
659 } | 608 } |
660 | 609 |
661 | |
662 ASSEMBLER_TEST_RUN(DoubleCompare, test) { | 610 ASSEMBLER_TEST_RUN(DoubleCompare, test) { |
663 EXPECT(test != NULL); | 611 EXPECT(test != NULL); |
664 if (TargetCPUFeatures::vfp_supported()) { | 612 if (TargetCPUFeatures::vfp_supported()) { |
665 typedef int (*DoubleCompare)() DART_UNUSED; | 613 typedef int (*DoubleCompare)() DART_UNUSED; |
666 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(DoubleCompare, test->entry())); | 614 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(DoubleCompare, test->entry())); |
667 } | 615 } |
668 } | 616 } |
669 | 617 |
670 | |
671 ASSEMBLER_TEST_GENERATE(Loop, assembler) { | 618 ASSEMBLER_TEST_GENERATE(Loop, assembler) { |
672 Label loop_entry; | 619 Label loop_entry; |
673 __ mov(R0, Operand(1)); | 620 __ mov(R0, Operand(1)); |
674 __ mov(R1, Operand(2)); | 621 __ mov(R1, Operand(2)); |
675 __ Bind(&loop_entry); | 622 __ Bind(&loop_entry); |
676 __ mov(R0, Operand(R0, LSL, 1)); | 623 __ mov(R0, Operand(R0, LSL, 1)); |
677 __ movs(R1, Operand(R1, LSR, 1)); | 624 __ movs(R1, Operand(R1, LSR, 1)); |
678 __ b(&loop_entry, NE); | 625 __ b(&loop_entry, NE); |
679 __ bx(LR); | 626 __ bx(LR); |
680 } | 627 } |
681 | 628 |
682 | |
683 ASSEMBLER_TEST_RUN(Loop, test) { | 629 ASSEMBLER_TEST_RUN(Loop, test) { |
684 EXPECT(test != NULL); | 630 EXPECT(test != NULL); |
685 typedef int (*Loop)() DART_UNUSED; | 631 typedef int (*Loop)() DART_UNUSED; |
686 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); | 632 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); |
687 } | 633 } |
688 | 634 |
689 | |
690 ASSEMBLER_TEST_GENERATE(ForwardBranch, assembler) { | 635 ASSEMBLER_TEST_GENERATE(ForwardBranch, assembler) { |
691 Label skip; | 636 Label skip; |
692 __ mov(R0, Operand(42)); | 637 __ mov(R0, Operand(42)); |
693 __ b(&skip); | 638 __ b(&skip); |
694 __ mov(R0, Operand(11)); | 639 __ mov(R0, Operand(11)); |
695 __ Bind(&skip); | 640 __ Bind(&skip); |
696 __ bx(LR); | 641 __ bx(LR); |
697 } | 642 } |
698 | 643 |
699 | |
700 ASSEMBLER_TEST_RUN(ForwardBranch, test) { | 644 ASSEMBLER_TEST_RUN(ForwardBranch, test) { |
701 EXPECT(test != NULL); | 645 EXPECT(test != NULL); |
702 typedef int (*ForwardBranch)() DART_UNUSED; | 646 typedef int (*ForwardBranch)() DART_UNUSED; |
703 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(ForwardBranch, test->entry())); | 647 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(ForwardBranch, test->entry())); |
704 } | 648 } |
705 | 649 |
706 | |
707 ASSEMBLER_TEST_GENERATE(Loop2, assembler) { | 650 ASSEMBLER_TEST_GENERATE(Loop2, assembler) { |
708 Label loop_entry; | 651 Label loop_entry; |
709 __ set_use_far_branches(true); | 652 __ set_use_far_branches(true); |
710 __ mov(R0, Operand(1)); | 653 __ mov(R0, Operand(1)); |
711 __ mov(R1, Operand(2)); | 654 __ mov(R1, Operand(2)); |
712 __ Bind(&loop_entry); | 655 __ Bind(&loop_entry); |
713 __ mov(R0, Operand(R0, LSL, 1)); | 656 __ mov(R0, Operand(R0, LSL, 1)); |
714 __ movs(R1, Operand(R1, LSR, 1)); | 657 __ movs(R1, Operand(R1, LSR, 1)); |
715 __ b(&loop_entry, NE); | 658 __ b(&loop_entry, NE); |
716 __ bx(LR); | 659 __ bx(LR); |
717 } | 660 } |
718 | 661 |
719 | |
720 ASSEMBLER_TEST_RUN(Loop2, test) { | 662 ASSEMBLER_TEST_RUN(Loop2, test) { |
721 EXPECT(test != NULL); | 663 EXPECT(test != NULL); |
722 typedef int (*Loop)() DART_UNUSED; | 664 typedef int (*Loop)() DART_UNUSED; |
723 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); | 665 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); |
724 } | 666 } |
725 | 667 |
726 | |
727 ASSEMBLER_TEST_GENERATE(Loop3, assembler) { | 668 ASSEMBLER_TEST_GENERATE(Loop3, assembler) { |
728 Label loop_entry; | 669 Label loop_entry; |
729 __ set_use_far_branches(true); | 670 __ set_use_far_branches(true); |
730 __ mov(R0, Operand(1)); | 671 __ mov(R0, Operand(1)); |
731 __ mov(R1, Operand(2)); | 672 __ mov(R1, Operand(2)); |
732 __ Bind(&loop_entry); | 673 __ Bind(&loop_entry); |
733 for (int i = 0; i < (1 << 22); i++) { | 674 for (int i = 0; i < (1 << 22); i++) { |
734 __ nop(); | 675 __ nop(); |
735 } | 676 } |
736 __ mov(R0, Operand(R0, LSL, 1)); | 677 __ mov(R0, Operand(R0, LSL, 1)); |
737 __ movs(R1, Operand(R1, LSR, 1)); | 678 __ movs(R1, Operand(R1, LSR, 1)); |
738 __ b(&loop_entry, NE); | 679 __ b(&loop_entry, NE); |
739 __ bx(LR); | 680 __ bx(LR); |
740 } | 681 } |
741 | 682 |
742 | |
743 ASSEMBLER_TEST_RUN(Loop3, test) { | 683 ASSEMBLER_TEST_RUN(Loop3, test) { |
744 EXPECT(test != NULL); | 684 EXPECT(test != NULL); |
745 typedef int (*Loop)() DART_UNUSED; | 685 typedef int (*Loop)() DART_UNUSED; |
746 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); | 686 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Loop, test->entry())); |
747 } | 687 } |
748 | 688 |
749 | |
750 ASSEMBLER_TEST_GENERATE(LoadStore, assembler) { | 689 ASSEMBLER_TEST_GENERATE(LoadStore, assembler) { |
751 __ mov(R1, Operand(123)); | 690 __ mov(R1, Operand(123)); |
752 __ Push(R1); | 691 __ Push(R1); |
753 __ Pop(R0); | 692 __ Pop(R0); |
754 __ bx(LR); | 693 __ bx(LR); |
755 } | 694 } |
756 | 695 |
757 | |
758 ASSEMBLER_TEST_RUN(LoadStore, test) { | 696 ASSEMBLER_TEST_RUN(LoadStore, test) { |
759 EXPECT(test != NULL); | 697 EXPECT(test != NULL); |
760 typedef int (*LoadStore)() DART_UNUSED; | 698 typedef int (*LoadStore)() DART_UNUSED; |
761 EXPECT_EQ(123, EXECUTE_TEST_CODE_INT32(LoadStore, test->entry())); | 699 EXPECT_EQ(123, EXECUTE_TEST_CODE_INT32(LoadStore, test->entry())); |
762 } | 700 } |
763 | 701 |
764 | |
765 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) { | 702 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) { |
766 if (TargetCPUFeatures::arm_version() != ARMv5TE) { | 703 if (TargetCPUFeatures::arm_version() != ARMv5TE) { |
767 __ mov(R0, Operand(40)); | 704 __ mov(R0, Operand(40)); |
768 __ mov(R1, Operand(42)); | 705 __ mov(R1, Operand(42)); |
769 __ Push(R0); | 706 __ Push(R0); |
770 Label retry; | 707 Label retry; |
771 __ Bind(&retry); | 708 __ Bind(&retry); |
772 __ ldrex(R0, SP); | 709 __ ldrex(R0, SP); |
773 __ strex(IP, R1, SP); // IP == 0, success | 710 __ strex(IP, R1, SP); // IP == 0, success |
774 __ tst(IP, Operand(0)); | 711 __ tst(IP, Operand(0)); |
775 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. | 712 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. |
776 __ Pop(R0); // 42 | 713 __ Pop(R0); // 42 |
777 } | 714 } |
778 __ bx(LR); | 715 __ bx(LR); |
779 } | 716 } |
780 | 717 |
781 | |
782 ASSEMBLER_TEST_RUN(Semaphore, test) { | 718 ASSEMBLER_TEST_RUN(Semaphore, test) { |
783 EXPECT(test != NULL); | 719 EXPECT(test != NULL); |
784 if (TargetCPUFeatures::arm_version() != ARMv5TE) { | 720 if (TargetCPUFeatures::arm_version() != ARMv5TE) { |
785 typedef int (*Semaphore)() DART_UNUSED; | 721 typedef int (*Semaphore)() DART_UNUSED; |
786 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Semaphore, test->entry())); | 722 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Semaphore, test->entry())); |
787 } | 723 } |
788 } | 724 } |
789 | 725 |
790 | |
791 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) { | 726 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) { |
792 if (TargetCPUFeatures::arm_version() != ARMv5TE) { | 727 if (TargetCPUFeatures::arm_version() != ARMv5TE) { |
793 __ mov(R0, Operand(40)); | 728 __ mov(R0, Operand(40)); |
794 __ mov(R1, Operand(42)); | 729 __ mov(R1, Operand(42)); |
795 __ Push(R0); | 730 __ Push(R0); |
796 __ ldrex(R0, SP); | 731 __ ldrex(R0, SP); |
797 __ clrex(); // Simulate a context switch. | 732 __ clrex(); // Simulate a context switch. |
798 __ strex(IP, R1, SP); // IP == 1, failure | 733 __ strex(IP, R1, SP); // IP == 1, failure |
799 __ Pop(R0); // 40 | 734 __ Pop(R0); // 40 |
800 __ add(R0, R0, Operand(IP)); | 735 __ add(R0, R0, Operand(IP)); |
801 } | 736 } |
802 __ bx(LR); | 737 __ bx(LR); |
803 } | 738 } |
804 | 739 |
805 | |
806 ASSEMBLER_TEST_RUN(FailedSemaphore, test) { | 740 ASSEMBLER_TEST_RUN(FailedSemaphore, test) { |
807 EXPECT(test != NULL); | 741 EXPECT(test != NULL); |
808 if (TargetCPUFeatures::arm_version() != ARMv5TE) { | 742 if (TargetCPUFeatures::arm_version() != ARMv5TE) { |
809 typedef int (*FailedSemaphore)() DART_UNUSED; | 743 typedef int (*FailedSemaphore)() DART_UNUSED; |
810 EXPECT_EQ(41, EXECUTE_TEST_CODE_INT32(FailedSemaphore, test->entry())); | 744 EXPECT_EQ(41, EXECUTE_TEST_CODE_INT32(FailedSemaphore, test->entry())); |
811 } | 745 } |
812 } | 746 } |
813 | 747 |
814 | |
815 ASSEMBLER_TEST_GENERATE(AddSub, assembler) { | 748 ASSEMBLER_TEST_GENERATE(AddSub, assembler) { |
816 __ mov(R1, Operand(40)); | 749 __ mov(R1, Operand(40)); |
817 __ sub(R1, R1, Operand(2)); | 750 __ sub(R1, R1, Operand(2)); |
818 __ add(R0, R1, Operand(4)); | 751 __ add(R0, R1, Operand(4)); |
819 __ rsbs(R0, R0, Operand(100)); | 752 __ rsbs(R0, R0, Operand(100)); |
820 __ rsc(R0, R0, Operand(100)); | 753 __ rsc(R0, R0, Operand(100)); |
821 __ bx(LR); | 754 __ bx(LR); |
822 } | 755 } |
823 | 756 |
824 | |
825 ASSEMBLER_TEST_RUN(AddSub, test) { | 757 ASSEMBLER_TEST_RUN(AddSub, test) { |
826 EXPECT(test != NULL); | 758 EXPECT(test != NULL); |
827 typedef int (*AddSub)() DART_UNUSED; | 759 typedef int (*AddSub)() DART_UNUSED; |
828 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(AddSub, test->entry())); | 760 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(AddSub, test->entry())); |
829 } | 761 } |
830 | 762 |
831 | |
832 ASSEMBLER_TEST_GENERATE(AddCarry, assembler) { | 763 ASSEMBLER_TEST_GENERATE(AddCarry, assembler) { |
833 __ LoadImmediate(R2, 0xFFFFFFFF); | 764 __ LoadImmediate(R2, 0xFFFFFFFF); |
834 __ mov(R1, Operand(1)); | 765 __ mov(R1, Operand(1)); |
835 __ mov(R0, Operand(0)); | 766 __ mov(R0, Operand(0)); |
836 __ adds(R2, R2, Operand(R1)); | 767 __ adds(R2, R2, Operand(R1)); |
837 __ adcs(R0, R0, Operand(R0)); | 768 __ adcs(R0, R0, Operand(R0)); |
838 __ bx(LR); | 769 __ bx(LR); |
839 } | 770 } |
840 | 771 |
841 | |
842 ASSEMBLER_TEST_RUN(AddCarry, test) { | 772 ASSEMBLER_TEST_RUN(AddCarry, test) { |
843 EXPECT(test != NULL); | 773 EXPECT(test != NULL); |
844 typedef int (*AddCarry)() DART_UNUSED; | 774 typedef int (*AddCarry)() DART_UNUSED; |
845 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(AddCarry, test->entry())); | 775 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(AddCarry, test->entry())); |
846 } | 776 } |
847 | 777 |
848 | |
849 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) { | 778 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) { |
850 __ LoadImmediate(R2, 0xFFFFFFFF); | 779 __ LoadImmediate(R2, 0xFFFFFFFF); |
851 __ mov(R1, Operand(1)); | 780 __ mov(R1, Operand(1)); |
852 __ mov(R0, Operand(0)); | 781 __ mov(R0, Operand(0)); |
853 __ adds(IP, R2, Operand(R1)); // c_out = 1. | 782 __ adds(IP, R2, Operand(R1)); // c_out = 1. |
854 __ adcs(IP, R2, Operand(R0)); // c_in = 1, c_out = 1. | 783 __ adcs(IP, R2, Operand(R0)); // c_in = 1, c_out = 1. |
855 __ adc(R0, R0, Operand(R0)); // c_in = 1. | 784 __ adc(R0, R0, Operand(R0)); // c_in = 1. |
856 __ bx(LR); | 785 __ bx(LR); |
857 } | 786 } |
858 | 787 |
859 | |
860 ASSEMBLER_TEST_RUN(AddCarryInOut, test) { | 788 ASSEMBLER_TEST_RUN(AddCarryInOut, test) { |
861 EXPECT(test != NULL); | 789 EXPECT(test != NULL); |
862 typedef int (*AddCarryInOut)() DART_UNUSED; | 790 typedef int (*AddCarryInOut)() DART_UNUSED; |
863 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(AddCarryInOut, test->entry())); | 791 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(AddCarryInOut, test->entry())); |
864 } | 792 } |
865 | 793 |
866 | |
867 ASSEMBLER_TEST_GENERATE(SubCarry, assembler) { | 794 ASSEMBLER_TEST_GENERATE(SubCarry, assembler) { |
868 __ LoadImmediate(R2, 0x0); | 795 __ LoadImmediate(R2, 0x0); |
869 __ mov(R1, Operand(1)); | 796 __ mov(R1, Operand(1)); |
870 __ mov(R0, Operand(0)); | 797 __ mov(R0, Operand(0)); |
871 __ subs(R2, R2, Operand(R1)); | 798 __ subs(R2, R2, Operand(R1)); |
872 __ sbcs(R0, R0, Operand(R0)); | 799 __ sbcs(R0, R0, Operand(R0)); |
873 __ bx(LR); | 800 __ bx(LR); |
874 } | 801 } |
875 | 802 |
876 | |
877 ASSEMBLER_TEST_RUN(SubCarry, test) { | 803 ASSEMBLER_TEST_RUN(SubCarry, test) { |
878 EXPECT(test != NULL); | 804 EXPECT(test != NULL); |
879 typedef int (*SubCarry)() DART_UNUSED; | 805 typedef int (*SubCarry)() DART_UNUSED; |
880 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(SubCarry, test->entry())); | 806 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(SubCarry, test->entry())); |
881 } | 807 } |
882 | 808 |
883 | |
884 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) { | 809 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) { |
885 __ mov(R1, Operand(1)); | 810 __ mov(R1, Operand(1)); |
886 __ mov(R0, Operand(0)); | 811 __ mov(R0, Operand(0)); |
887 __ subs(IP, R0, Operand(R1)); // c_out = 1. | 812 __ subs(IP, R0, Operand(R1)); // c_out = 1. |
888 __ sbcs(IP, R0, Operand(R0)); // c_in = 1, c_out = 1. | 813 __ sbcs(IP, R0, Operand(R0)); // c_in = 1, c_out = 1. |
889 __ sbc(R0, R0, Operand(R0)); // c_in = 1. | 814 __ sbc(R0, R0, Operand(R0)); // c_in = 1. |
890 __ bx(LR); | 815 __ bx(LR); |
891 } | 816 } |
892 | 817 |
893 | |
894 ASSEMBLER_TEST_RUN(SubCarryInOut, test) { | 818 ASSEMBLER_TEST_RUN(SubCarryInOut, test) { |
895 EXPECT(test != NULL); | 819 EXPECT(test != NULL); |
896 typedef int (*SubCarryInOut)() DART_UNUSED; | 820 typedef int (*SubCarryInOut)() DART_UNUSED; |
897 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(SubCarryInOut, test->entry())); | 821 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(SubCarryInOut, test->entry())); |
898 } | 822 } |
899 | 823 |
900 | |
901 ASSEMBLER_TEST_GENERATE(Overflow, assembler) { | 824 ASSEMBLER_TEST_GENERATE(Overflow, assembler) { |
902 __ LoadImmediate(R0, 0xFFFFFFFF); | 825 __ LoadImmediate(R0, 0xFFFFFFFF); |
903 __ LoadImmediate(R1, 0x7FFFFFFF); | 826 __ LoadImmediate(R1, 0x7FFFFFFF); |
904 __ adds(IP, R0, Operand(1)); // c_out = 1. | 827 __ adds(IP, R0, Operand(1)); // c_out = 1. |
905 __ adcs(IP, R1, Operand(0)); // c_in = 1, c_out = 1, v = 1. | 828 __ adcs(IP, R1, Operand(0)); // c_in = 1, c_out = 1, v = 1. |
906 __ mov(R0, Operand(1), VS); | 829 __ mov(R0, Operand(1), VS); |
907 __ bx(LR); | 830 __ bx(LR); |
908 } | 831 } |
909 | 832 |
910 | |
911 ASSEMBLER_TEST_RUN(Overflow, test) { | 833 ASSEMBLER_TEST_RUN(Overflow, test) { |
912 EXPECT(test != NULL); | 834 EXPECT(test != NULL); |
913 typedef int (*Overflow)() DART_UNUSED; | 835 typedef int (*Overflow)() DART_UNUSED; |
914 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Overflow, test->entry())); | 836 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Overflow, test->entry())); |
915 } | 837 } |
916 | 838 |
917 | |
918 ASSEMBLER_TEST_GENERATE(AndOrr, assembler) { | 839 ASSEMBLER_TEST_GENERATE(AndOrr, assembler) { |
919 __ mov(R1, Operand(40)); | 840 __ mov(R1, Operand(40)); |
920 __ mov(R2, Operand(0)); | 841 __ mov(R2, Operand(0)); |
921 __ and_(R1, R2, Operand(R1)); | 842 __ and_(R1, R2, Operand(R1)); |
922 __ mov(R3, Operand(42)); | 843 __ mov(R3, Operand(42)); |
923 __ orr(R0, R1, Operand(R3)); | 844 __ orr(R0, R1, Operand(R3)); |
924 __ bx(LR); | 845 __ bx(LR); |
925 } | 846 } |
926 | 847 |
927 | |
928 ASSEMBLER_TEST_RUN(AndOrr, test) { | 848 ASSEMBLER_TEST_RUN(AndOrr, test) { |
929 EXPECT(test != NULL); | 849 EXPECT(test != NULL); |
930 typedef int (*AndOrr)() DART_UNUSED; | 850 typedef int (*AndOrr)() DART_UNUSED; |
931 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(AndOrr, test->entry())); | 851 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(AndOrr, test->entry())); |
932 } | 852 } |
933 | 853 |
934 | |
935 ASSEMBLER_TEST_GENERATE(Orrs, assembler) { | 854 ASSEMBLER_TEST_GENERATE(Orrs, assembler) { |
936 __ mov(R0, Operand(0)); | 855 __ mov(R0, Operand(0)); |
937 __ tst(R0, Operand(R1)); // Set zero-flag. | 856 __ tst(R0, Operand(R1)); // Set zero-flag. |
938 __ orrs(R0, R0, Operand(1)); // Clear zero-flag. | 857 __ orrs(R0, R0, Operand(1)); // Clear zero-flag. |
939 __ bx(LR, EQ); | 858 __ bx(LR, EQ); |
940 __ mov(R0, Operand(42)); | 859 __ mov(R0, Operand(42)); |
941 __ bx(LR, NE); // Only this return should fire. | 860 __ bx(LR, NE); // Only this return should fire. |
942 __ mov(R0, Operand(2)); | 861 __ mov(R0, Operand(2)); |
943 __ bx(LR); | 862 __ bx(LR); |
944 } | 863 } |
945 | 864 |
946 | |
947 ASSEMBLER_TEST_RUN(Orrs, test) { | 865 ASSEMBLER_TEST_RUN(Orrs, test) { |
948 EXPECT(test != NULL); | 866 EXPECT(test != NULL); |
949 typedef int (*Orrs)() DART_UNUSED; | 867 typedef int (*Orrs)() DART_UNUSED; |
950 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Orrs, test->entry())); | 868 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Orrs, test->entry())); |
951 } | 869 } |
952 | 870 |
953 | |
954 ASSEMBLER_TEST_GENERATE(Multiply, assembler) { | 871 ASSEMBLER_TEST_GENERATE(Multiply, assembler) { |
955 __ mov(R1, Operand(20)); | 872 __ mov(R1, Operand(20)); |
956 __ mov(R2, Operand(40)); | 873 __ mov(R2, Operand(40)); |
957 __ mul(R3, R2, R1); | 874 __ mul(R3, R2, R1); |
958 __ mov(R0, Operand(R3)); | 875 __ mov(R0, Operand(R3)); |
959 __ bx(LR); | 876 __ bx(LR); |
960 } | 877 } |
961 | 878 |
962 | |
963 ASSEMBLER_TEST_RUN(Multiply, test) { | 879 ASSEMBLER_TEST_RUN(Multiply, test) { |
964 EXPECT(test != NULL); | 880 EXPECT(test != NULL); |
965 typedef int (*Multiply)() DART_UNUSED; | 881 typedef int (*Multiply)() DART_UNUSED; |
966 EXPECT_EQ(800, EXECUTE_TEST_CODE_INT32(Multiply, test->entry())); | 882 EXPECT_EQ(800, EXECUTE_TEST_CODE_INT32(Multiply, test->entry())); |
967 } | 883 } |
968 | 884 |
969 | |
970 ASSEMBLER_TEST_GENERATE(QuotientRemainder, assembler) { | 885 ASSEMBLER_TEST_GENERATE(QuotientRemainder, assembler) { |
971 if (TargetCPUFeatures::vfp_supported()) { | 886 if (TargetCPUFeatures::vfp_supported()) { |
972 __ vmovsr(S2, R0); | 887 __ vmovsr(S2, R0); |
973 __ vmovsr(S4, R2); | 888 __ vmovsr(S4, R2); |
974 __ vcvtdi(D1, S2); | 889 __ vcvtdi(D1, S2); |
975 __ vcvtdi(D2, S4); | 890 __ vcvtdi(D2, S4); |
976 __ vdivd(D0, D1, D2); | 891 __ vdivd(D0, D1, D2); |
977 __ vcvtid(S0, D0); | 892 __ vcvtid(S0, D0); |
978 __ vmovrs(R1, S0); // r1 = r0/r2 | 893 __ vmovrs(R1, S0); // r1 = r0/r2 |
979 __ mls(R0, R1, R2, R0); // r0 = r0 - r1*r2 | 894 __ mls(R0, R1, R2, R0); // r0 = r0 - r1*r2 |
980 } | 895 } |
981 __ bx(LR); | 896 __ bx(LR); |
982 } | 897 } |
983 | 898 |
984 | |
985 ASSEMBLER_TEST_RUN(QuotientRemainder, test) { | 899 ASSEMBLER_TEST_RUN(QuotientRemainder, test) { |
986 EXPECT(test != NULL); | 900 EXPECT(test != NULL); |
987 if (TargetCPUFeatures::vfp_supported()) { | 901 if (TargetCPUFeatures::vfp_supported()) { |
988 typedef int64_t (*QuotientRemainder)(int64_t dividend, int64_t divisor) | 902 typedef int64_t (*QuotientRemainder)(int64_t dividend, int64_t divisor) |
989 DART_UNUSED; | 903 DART_UNUSED; |
990 EXPECT_EQ(0x1000400000da8LL, | 904 EXPECT_EQ(0x1000400000da8LL, |
991 EXECUTE_TEST_CODE_INT64_LL(QuotientRemainder, test->entry(), | 905 EXECUTE_TEST_CODE_INT64_LL(QuotientRemainder, test->entry(), |
992 0x12345678, 0x1234)); | 906 0x12345678, 0x1234)); |
993 } | 907 } |
994 } | 908 } |
995 | 909 |
996 | |
997 ASSEMBLER_TEST_GENERATE(Multiply64To64, assembler) { | 910 ASSEMBLER_TEST_GENERATE(Multiply64To64, assembler) { |
998 __ Push(R4); | 911 __ Push(R4); |
999 __ mov(IP, Operand(R0)); | 912 __ mov(IP, Operand(R0)); |
1000 __ mul(R4, R2, R1); | 913 __ mul(R4, R2, R1); |
1001 __ umull(R0, R1, R2, IP); | 914 __ umull(R0, R1, R2, IP); |
1002 __ mla(R2, IP, R3, R4); | 915 __ mla(R2, IP, R3, R4); |
1003 __ add(R1, R2, Operand(R1)); | 916 __ add(R1, R2, Operand(R1)); |
1004 __ Pop(R4); | 917 __ Pop(R4); |
1005 __ bx(LR); | 918 __ bx(LR); |
1006 } | 919 } |
1007 | 920 |
1008 | |
1009 ASSEMBLER_TEST_RUN(Multiply64To64, test) { | 921 ASSEMBLER_TEST_RUN(Multiply64To64, test) { |
1010 EXPECT(test != NULL); | 922 EXPECT(test != NULL); |
1011 typedef int64_t (*Multiply64To64)(int64_t operand0, int64_t operand1) | 923 typedef int64_t (*Multiply64To64)(int64_t operand0, int64_t operand1) |
1012 DART_UNUSED; | 924 DART_UNUSED; |
1013 EXPECT_EQ(6, | 925 EXPECT_EQ(6, |
1014 EXECUTE_TEST_CODE_INT64_LL(Multiply64To64, test->entry(), -3, -2)); | 926 EXECUTE_TEST_CODE_INT64_LL(Multiply64To64, test->entry(), -3, -2)); |
1015 } | 927 } |
1016 | 928 |
1017 | |
1018 ASSEMBLER_TEST_GENERATE(Multiply32To64, assembler) { | 929 ASSEMBLER_TEST_GENERATE(Multiply32To64, assembler) { |
1019 __ smull(R0, R1, R0, R2); | 930 __ smull(R0, R1, R0, R2); |
1020 __ bx(LR); | 931 __ bx(LR); |
1021 } | 932 } |
1022 | 933 |
1023 | |
1024 ASSEMBLER_TEST_RUN(Multiply32To64, test) { | 934 ASSEMBLER_TEST_RUN(Multiply32To64, test) { |
1025 EXPECT(test != NULL); | 935 EXPECT(test != NULL); |
1026 typedef int64_t (*Multiply32To64)(int64_t operand0, int64_t operand1) | 936 typedef int64_t (*Multiply32To64)(int64_t operand0, int64_t operand1) |
1027 DART_UNUSED; | 937 DART_UNUSED; |
1028 EXPECT_EQ(6, | 938 EXPECT_EQ(6, |
1029 EXECUTE_TEST_CODE_INT64_LL(Multiply32To64, test->entry(), -3, -2)); | 939 EXECUTE_TEST_CODE_INT64_LL(Multiply32To64, test->entry(), -3, -2)); |
1030 } | 940 } |
1031 | 941 |
1032 | |
1033 ASSEMBLER_TEST_GENERATE(MultiplyAccumAccum32To64, assembler) { | 942 ASSEMBLER_TEST_GENERATE(MultiplyAccumAccum32To64, assembler) { |
1034 __ umaal(R0, R1, R2, R3); | 943 __ umaal(R0, R1, R2, R3); |
1035 __ bx(LR); | 944 __ bx(LR); |
1036 } | 945 } |
1037 | 946 |
1038 | |
1039 ASSEMBLER_TEST_RUN(MultiplyAccumAccum32To64, test) { | 947 ASSEMBLER_TEST_RUN(MultiplyAccumAccum32To64, test) { |
1040 EXPECT(test != NULL); | 948 EXPECT(test != NULL); |
1041 typedef int64_t (*MultiplyAccumAccum32To64)(int64_t operand0, | 949 typedef int64_t (*MultiplyAccumAccum32To64)(int64_t operand0, |
1042 int64_t operand1) DART_UNUSED; | 950 int64_t operand1) DART_UNUSED; |
1043 EXPECT_EQ(3 + 7 + 5 * 11, | 951 EXPECT_EQ(3 + 7 + 5 * 11, |
1044 EXECUTE_TEST_CODE_INT64_LL(MultiplyAccumAccum32To64, test->entry(), | 952 EXECUTE_TEST_CODE_INT64_LL(MultiplyAccumAccum32To64, test->entry(), |
1045 (3LL << 32) + 7, (5LL << 32) + 11)); | 953 (3LL << 32) + 7, (5LL << 32) + 11)); |
1046 } | 954 } |
1047 | 955 |
1048 | |
1049 ASSEMBLER_TEST_GENERATE(Clz, assembler) { | 956 ASSEMBLER_TEST_GENERATE(Clz, assembler) { |
1050 Label error; | 957 Label error; |
1051 | 958 |
1052 __ mov(R0, Operand(0)); | 959 __ mov(R0, Operand(0)); |
1053 __ clz(R1, R0); | 960 __ clz(R1, R0); |
1054 __ cmp(R1, Operand(32)); | 961 __ cmp(R1, Operand(32)); |
1055 __ b(&error, NE); | 962 __ b(&error, NE); |
1056 __ mov(R2, Operand(42)); | 963 __ mov(R2, Operand(42)); |
1057 __ clz(R2, R2); | 964 __ clz(R2, R2); |
1058 __ cmp(R2, Operand(26)); | 965 __ cmp(R2, Operand(26)); |
1059 __ b(&error, NE); | 966 __ b(&error, NE); |
1060 __ mvn(R0, Operand(0)); | 967 __ mvn(R0, Operand(0)); |
1061 __ clz(R1, R0); | 968 __ clz(R1, R0); |
1062 __ cmp(R1, Operand(0)); | 969 __ cmp(R1, Operand(0)); |
1063 __ b(&error, NE); | 970 __ b(&error, NE); |
1064 __ Lsr(R0, R0, Operand(3)); | 971 __ Lsr(R0, R0, Operand(3)); |
1065 __ clz(R1, R0); | 972 __ clz(R1, R0); |
1066 __ cmp(R1, Operand(3)); | 973 __ cmp(R1, Operand(3)); |
1067 __ b(&error, NE); | 974 __ b(&error, NE); |
1068 __ mov(R0, Operand(0)); | 975 __ mov(R0, Operand(0)); |
1069 __ bx(LR); | 976 __ bx(LR); |
1070 __ Bind(&error); | 977 __ Bind(&error); |
1071 __ mov(R0, Operand(1)); | 978 __ mov(R0, Operand(1)); |
1072 __ bx(LR); | 979 __ bx(LR); |
1073 } | 980 } |
1074 | 981 |
1075 | |
1076 ASSEMBLER_TEST_RUN(Clz, test) { | 982 ASSEMBLER_TEST_RUN(Clz, test) { |
1077 EXPECT(test != NULL); | 983 EXPECT(test != NULL); |
1078 typedef int (*Clz)() DART_UNUSED; | 984 typedef int (*Clz)() DART_UNUSED; |
1079 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Clz, test->entry())); | 985 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Clz, test->entry())); |
1080 } | 986 } |
1081 | 987 |
1082 | |
1083 ASSEMBLER_TEST_GENERATE(Tst, assembler) { | 988 ASSEMBLER_TEST_GENERATE(Tst, assembler) { |
1084 Label skip; | 989 Label skip; |
1085 | 990 |
1086 __ mov(R0, Operand(42)); | 991 __ mov(R0, Operand(42)); |
1087 __ mov(R1, Operand(40)); | 992 __ mov(R1, Operand(40)); |
1088 __ tst(R1, Operand(0)); | 993 __ tst(R1, Operand(0)); |
1089 __ b(&skip, NE); | 994 __ b(&skip, NE); |
1090 __ mov(R0, Operand(0)); | 995 __ mov(R0, Operand(0)); |
1091 __ Bind(&skip); | 996 __ Bind(&skip); |
1092 __ bx(LR); | 997 __ bx(LR); |
1093 } | 998 } |
1094 | 999 |
1095 | |
1096 ASSEMBLER_TEST_RUN(Tst, test) { | 1000 ASSEMBLER_TEST_RUN(Tst, test) { |
1097 EXPECT(test != NULL); | 1001 EXPECT(test != NULL); |
1098 typedef int (*Tst)() DART_UNUSED; | 1002 typedef int (*Tst)() DART_UNUSED; |
1099 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1003 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1100 } | 1004 } |
1101 | 1005 |
1102 | |
1103 ASSEMBLER_TEST_GENERATE(Lsl, assembler) { | 1006 ASSEMBLER_TEST_GENERATE(Lsl, assembler) { |
1104 Label skip; | 1007 Label skip; |
1105 | 1008 |
1106 __ mov(R0, Operand(1)); | 1009 __ mov(R0, Operand(1)); |
1107 __ mov(R0, Operand(R0, LSL, 1)); | 1010 __ mov(R0, Operand(R0, LSL, 1)); |
1108 __ mov(R1, Operand(1)); | 1011 __ mov(R1, Operand(1)); |
1109 __ mov(R0, Operand(R0, LSL, R1)); | 1012 __ mov(R0, Operand(R0, LSL, R1)); |
1110 __ bx(LR); | 1013 __ bx(LR); |
1111 } | 1014 } |
1112 | 1015 |
1113 | |
1114 ASSEMBLER_TEST_RUN(Lsl, test) { | 1016 ASSEMBLER_TEST_RUN(Lsl, test) { |
1115 EXPECT(test != NULL); | 1017 EXPECT(test != NULL); |
1116 typedef int (*Tst)() DART_UNUSED; | 1018 typedef int (*Tst)() DART_UNUSED; |
1117 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1019 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1118 } | 1020 } |
1119 | 1021 |
1120 | |
1121 ASSEMBLER_TEST_GENERATE(Lsr, assembler) { | 1022 ASSEMBLER_TEST_GENERATE(Lsr, assembler) { |
1122 Label skip; | 1023 Label skip; |
1123 | 1024 |
1124 __ mov(R0, Operand(4)); | 1025 __ mov(R0, Operand(4)); |
1125 __ mov(R0, Operand(R0, LSR, 1)); | 1026 __ mov(R0, Operand(R0, LSR, 1)); |
1126 __ mov(R1, Operand(1)); | 1027 __ mov(R1, Operand(1)); |
1127 __ mov(R0, Operand(R0, LSR, R1)); | 1028 __ mov(R0, Operand(R0, LSR, R1)); |
1128 __ bx(LR); | 1029 __ bx(LR); |
1129 } | 1030 } |
1130 | 1031 |
1131 | |
1132 ASSEMBLER_TEST_RUN(Lsr, test) { | 1032 ASSEMBLER_TEST_RUN(Lsr, test) { |
1133 EXPECT(test != NULL); | 1033 EXPECT(test != NULL); |
1134 typedef int (*Tst)() DART_UNUSED; | 1034 typedef int (*Tst)() DART_UNUSED; |
1135 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1035 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1136 } | 1036 } |
1137 | 1037 |
1138 | |
1139 ASSEMBLER_TEST_GENERATE(Lsr1, assembler) { | 1038 ASSEMBLER_TEST_GENERATE(Lsr1, assembler) { |
1140 Label skip; | 1039 Label skip; |
1141 | 1040 |
1142 __ mov(R0, Operand(1)); | 1041 __ mov(R0, Operand(1)); |
1143 __ Lsl(R0, R0, Operand(31)); | 1042 __ Lsl(R0, R0, Operand(31)); |
1144 __ Lsr(R0, R0, Operand(31)); | 1043 __ Lsr(R0, R0, Operand(31)); |
1145 __ bx(LR); | 1044 __ bx(LR); |
1146 } | 1045 } |
1147 | 1046 |
1148 | |
1149 ASSEMBLER_TEST_RUN(Lsr1, test) { | 1047 ASSEMBLER_TEST_RUN(Lsr1, test) { |
1150 EXPECT(test != NULL); | 1048 EXPECT(test != NULL); |
1151 typedef int (*Tst)() DART_UNUSED; | 1049 typedef int (*Tst)() DART_UNUSED; |
1152 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1050 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1153 } | 1051 } |
1154 | 1052 |
1155 | |
1156 ASSEMBLER_TEST_GENERATE(Asr1, assembler) { | 1053 ASSEMBLER_TEST_GENERATE(Asr1, assembler) { |
1157 Label skip; | 1054 Label skip; |
1158 | 1055 |
1159 __ mov(R0, Operand(1)); | 1056 __ mov(R0, Operand(1)); |
1160 __ Lsl(R0, R0, Operand(31)); | 1057 __ Lsl(R0, R0, Operand(31)); |
1161 __ Asr(R0, R0, Operand(31)); | 1058 __ Asr(R0, R0, Operand(31)); |
1162 __ bx(LR); | 1059 __ bx(LR); |
1163 } | 1060 } |
1164 | 1061 |
1165 | |
1166 ASSEMBLER_TEST_RUN(Asr1, test) { | 1062 ASSEMBLER_TEST_RUN(Asr1, test) { |
1167 EXPECT(test != NULL); | 1063 EXPECT(test != NULL); |
1168 typedef int (*Tst)() DART_UNUSED; | 1064 typedef int (*Tst)() DART_UNUSED; |
1169 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1065 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1170 } | 1066 } |
1171 | 1067 |
1172 | |
1173 ASSEMBLER_TEST_GENERATE(Rsb, assembler) { | 1068 ASSEMBLER_TEST_GENERATE(Rsb, assembler) { |
1174 __ mov(R3, Operand(10)); | 1069 __ mov(R3, Operand(10)); |
1175 __ rsb(R0, R3, Operand(42)); | 1070 __ rsb(R0, R3, Operand(42)); |
1176 __ bx(LR); | 1071 __ bx(LR); |
1177 } | 1072 } |
1178 | 1073 |
1179 | |
1180 ASSEMBLER_TEST_RUN(Rsb, test) { | 1074 ASSEMBLER_TEST_RUN(Rsb, test) { |
1181 EXPECT(test != NULL); | 1075 EXPECT(test != NULL); |
1182 typedef int (*Rsb)() DART_UNUSED; | 1076 typedef int (*Rsb)() DART_UNUSED; |
1183 EXPECT_EQ(32, EXECUTE_TEST_CODE_INT32(Rsb, test->entry())); | 1077 EXPECT_EQ(32, EXECUTE_TEST_CODE_INT32(Rsb, test->entry())); |
1184 } | 1078 } |
1185 | 1079 |
1186 | |
1187 ASSEMBLER_TEST_GENERATE(Ldrh, assembler) { | 1080 ASSEMBLER_TEST_GENERATE(Ldrh, assembler) { |
1188 Label Test1, Test2, Test3, Done; | 1081 Label Test1, Test2, Test3, Done; |
1189 | 1082 |
1190 __ mov(R1, Operand(0x11)); | 1083 __ mov(R1, Operand(0x11)); |
1191 __ mov(R2, Operand(SP)); | 1084 __ mov(R2, Operand(SP)); |
1192 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 1085 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
1193 __ ldrh(R0, Address(R2, (-kWordSize * 30))); | 1086 __ ldrh(R0, Address(R2, (-kWordSize * 30))); |
1194 __ cmp(R0, Operand(0x11)); | 1087 __ cmp(R0, Operand(0x11)); |
1195 __ b(&Test1, EQ); | 1088 __ b(&Test1, EQ); |
1196 __ mov(R0, Operand(1)); | 1089 __ mov(R0, Operand(1)); |
(...skipping 18 matching lines...) Expand all Loading... |
1215 __ mov(R0, Operand(1)); | 1108 __ mov(R0, Operand(1)); |
1216 __ b(&Done); | 1109 __ b(&Done); |
1217 __ Bind(&Test3); | 1110 __ Bind(&Test3); |
1218 | 1111 |
1219 __ mov(R0, Operand(0)); | 1112 __ mov(R0, Operand(0)); |
1220 __ Bind(&Done); | 1113 __ Bind(&Done); |
1221 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); | 1114 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); |
1222 __ bx(LR); | 1115 __ bx(LR); |
1223 } | 1116 } |
1224 | 1117 |
1225 | |
1226 ASSEMBLER_TEST_RUN(Ldrh, test) { | 1118 ASSEMBLER_TEST_RUN(Ldrh, test) { |
1227 EXPECT(test != NULL); | 1119 EXPECT(test != NULL); |
1228 typedef int (*Tst)() DART_UNUSED; | 1120 typedef int (*Tst)() DART_UNUSED; |
1229 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1121 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1230 } | 1122 } |
1231 | 1123 |
1232 | |
1233 ASSEMBLER_TEST_GENERATE(Ldrsb, assembler) { | 1124 ASSEMBLER_TEST_GENERATE(Ldrsb, assembler) { |
1234 __ mov(R1, Operand(0xFF)); | 1125 __ mov(R1, Operand(0xFF)); |
1235 __ mov(R2, Operand(SP)); | 1126 __ mov(R2, Operand(SP)); |
1236 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 1127 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
1237 __ ldrsb(R0, Address(R2, (-kWordSize * 30))); | 1128 __ ldrsb(R0, Address(R2, (-kWordSize * 30))); |
1238 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); | 1129 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); |
1239 __ bx(LR); | 1130 __ bx(LR); |
1240 } | 1131 } |
1241 | 1132 |
1242 | |
1243 ASSEMBLER_TEST_RUN(Ldrsb, test) { | 1133 ASSEMBLER_TEST_RUN(Ldrsb, test) { |
1244 EXPECT(test != NULL); | 1134 EXPECT(test != NULL); |
1245 typedef int (*Tst)() DART_UNUSED; | 1135 typedef int (*Tst)() DART_UNUSED; |
1246 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1136 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1247 } | 1137 } |
1248 | 1138 |
1249 | |
1250 ASSEMBLER_TEST_GENERATE(Ldrb, assembler) { | 1139 ASSEMBLER_TEST_GENERATE(Ldrb, assembler) { |
1251 __ mov(R1, Operand(0xFF)); | 1140 __ mov(R1, Operand(0xFF)); |
1252 __ mov(R2, Operand(SP)); | 1141 __ mov(R2, Operand(SP)); |
1253 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 1142 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
1254 __ ldrb(R0, Address(R2, (-kWordSize * 30))); | 1143 __ ldrb(R0, Address(R2, (-kWordSize * 30))); |
1255 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); | 1144 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); |
1256 __ bx(LR); | 1145 __ bx(LR); |
1257 } | 1146 } |
1258 | 1147 |
1259 | |
1260 ASSEMBLER_TEST_RUN(Ldrb, test) { | 1148 ASSEMBLER_TEST_RUN(Ldrb, test) { |
1261 EXPECT(test != NULL); | 1149 EXPECT(test != NULL); |
1262 typedef int (*Tst)() DART_UNUSED; | 1150 typedef int (*Tst)() DART_UNUSED; |
1263 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1151 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1264 } | 1152 } |
1265 | 1153 |
1266 | |
1267 ASSEMBLER_TEST_GENERATE(Ldrsh, assembler) { | 1154 ASSEMBLER_TEST_GENERATE(Ldrsh, assembler) { |
1268 __ mov(R1, Operand(0xFF)); | 1155 __ mov(R1, Operand(0xFF)); |
1269 __ mov(R2, Operand(SP)); | 1156 __ mov(R2, Operand(SP)); |
1270 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 1157 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
1271 __ ldrsh(R0, Address(R2, (-kWordSize * 30))); | 1158 __ ldrsh(R0, Address(R2, (-kWordSize * 30))); |
1272 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); | 1159 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); |
1273 __ bx(LR); | 1160 __ bx(LR); |
1274 } | 1161 } |
1275 | 1162 |
1276 | |
1277 ASSEMBLER_TEST_RUN(Ldrsh, test) { | 1163 ASSEMBLER_TEST_RUN(Ldrsh, test) { |
1278 EXPECT(test != NULL); | 1164 EXPECT(test != NULL); |
1279 typedef int (*Tst)() DART_UNUSED; | 1165 typedef int (*Tst)() DART_UNUSED; |
1280 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1166 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1281 } | 1167 } |
1282 | 1168 |
1283 | |
1284 ASSEMBLER_TEST_GENERATE(Ldrh1, assembler) { | 1169 ASSEMBLER_TEST_GENERATE(Ldrh1, assembler) { |
1285 __ mov(R1, Operand(0xFF)); | 1170 __ mov(R1, Operand(0xFF)); |
1286 __ mov(R2, Operand(SP)); | 1171 __ mov(R2, Operand(SP)); |
1287 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); | 1172 __ str(R1, Address(SP, (-kWordSize * 30), Address::PreIndex)); |
1288 __ ldrh(R0, Address(R2, (-kWordSize * 30))); | 1173 __ ldrh(R0, Address(R2, (-kWordSize * 30))); |
1289 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); | 1174 __ ldr(R1, Address(SP, (kWordSize * 30), Address::PostIndex)); |
1290 __ bx(LR); | 1175 __ bx(LR); |
1291 } | 1176 } |
1292 | 1177 |
1293 | |
1294 ASSEMBLER_TEST_RUN(Ldrh1, test) { | 1178 ASSEMBLER_TEST_RUN(Ldrh1, test) { |
1295 EXPECT(test != NULL); | 1179 EXPECT(test != NULL); |
1296 typedef int (*Tst)() DART_UNUSED; | 1180 typedef int (*Tst)() DART_UNUSED; |
1297 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1181 EXPECT_EQ(0xff, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1298 } | 1182 } |
1299 | 1183 |
1300 | |
1301 ASSEMBLER_TEST_GENERATE(Ldrd, assembler) { | 1184 ASSEMBLER_TEST_GENERATE(Ldrd, assembler) { |
1302 __ mov(IP, Operand(SP)); | 1185 __ mov(IP, Operand(SP)); |
1303 __ sub(SP, SP, Operand(kWordSize * 30)); | 1186 __ sub(SP, SP, Operand(kWordSize * 30)); |
1304 __ strd(R2, R3, SP, 0); | 1187 __ strd(R2, R3, SP, 0); |
1305 __ strd(R0, R1, IP, (-kWordSize * 28)); | 1188 __ strd(R0, R1, IP, (-kWordSize * 28)); |
1306 __ ldrd(R2, R3, IP, (-kWordSize * 28)); | 1189 __ ldrd(R2, R3, IP, (-kWordSize * 28)); |
1307 __ ldrd(R0, R1, SP, 0); | 1190 __ ldrd(R0, R1, SP, 0); |
1308 __ add(SP, SP, Operand(kWordSize * 30)); | 1191 __ add(SP, SP, Operand(kWordSize * 30)); |
1309 __ sub(R0, R0, Operand(R2)); | 1192 __ sub(R0, R0, Operand(R2)); |
1310 __ add(R1, R1, Operand(R3)); | 1193 __ add(R1, R1, Operand(R3)); |
1311 __ bx(LR); | 1194 __ bx(LR); |
1312 } | 1195 } |
1313 | 1196 |
1314 | |
1315 ASSEMBLER_TEST_RUN(Ldrd, test) { | 1197 ASSEMBLER_TEST_RUN(Ldrd, test) { |
1316 EXPECT(test != NULL); | 1198 EXPECT(test != NULL); |
1317 typedef int64_t (*Tst)(int64_t r0r1, int64_t r2r3) DART_UNUSED; | 1199 typedef int64_t (*Tst)(int64_t r0r1, int64_t r2r3) DART_UNUSED; |
1318 EXPECT_EQ(0x0000444400002222LL, | 1200 EXPECT_EQ(0x0000444400002222LL, |
1319 EXECUTE_TEST_CODE_INT64_LL(Tst, test->entry(), 0x0000111100000000LL, | 1201 EXECUTE_TEST_CODE_INT64_LL(Tst, test->entry(), 0x0000111100000000LL, |
1320 0x0000333300002222LL)); | 1202 0x0000333300002222LL)); |
1321 } | 1203 } |
1322 | 1204 |
1323 | |
1324 ASSEMBLER_TEST_GENERATE(Ldm_stm_da, assembler) { | 1205 ASSEMBLER_TEST_GENERATE(Ldm_stm_da, assembler) { |
1325 __ mov(R0, Operand(1)); | 1206 __ mov(R0, Operand(1)); |
1326 __ mov(R1, Operand(7)); | 1207 __ mov(R1, Operand(7)); |
1327 __ mov(R2, Operand(11)); | 1208 __ mov(R2, Operand(11)); |
1328 __ mov(R3, Operand(31)); | 1209 __ mov(R3, Operand(31)); |
1329 __ Push(R9); // We use R9 as accumulator. | 1210 __ Push(R9); // We use R9 as accumulator. |
1330 __ Push(R9); | 1211 __ Push(R9); |
1331 __ Push(R9); | 1212 __ Push(R9); |
1332 __ Push(R9); | 1213 __ Push(R9); |
1333 __ Push(R9); | 1214 __ Push(R9); |
(...skipping 15 matching lines...) Expand all Loading... |
1349 __ sub(R0, R9, Operand(R3)); // R0 = result = -52. | 1230 __ sub(R0, R9, Operand(R3)); // R0 = result = -52. |
1350 __ Pop(R1); // Remove storage slot. | 1231 __ Pop(R1); // Remove storage slot. |
1351 __ Pop(R9); // Restore R9. | 1232 __ Pop(R9); // Restore R9. |
1352 __ Pop(R9); // Restore R9. | 1233 __ Pop(R9); // Restore R9. |
1353 __ Pop(R9); // Restore R9. | 1234 __ Pop(R9); // Restore R9. |
1354 __ Pop(R9); // Restore R9. | 1235 __ Pop(R9); // Restore R9. |
1355 __ Pop(R9); // Restore R9. | 1236 __ Pop(R9); // Restore R9. |
1356 __ bx(LR); | 1237 __ bx(LR); |
1357 } | 1238 } |
1358 | 1239 |
1359 | |
1360 ASSEMBLER_TEST_RUN(Ldm_stm_da, test) { | 1240 ASSEMBLER_TEST_RUN(Ldm_stm_da, test) { |
1361 EXPECT(test != NULL); | 1241 EXPECT(test != NULL); |
1362 typedef int (*Tst)() DART_UNUSED; | 1242 typedef int (*Tst)() DART_UNUSED; |
1363 EXPECT_EQ(-52, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1243 EXPECT_EQ(-52, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1364 } | 1244 } |
1365 | 1245 |
1366 | |
1367 ASSEMBLER_TEST_GENERATE(AddressShiftStrLSL1NegOffset, assembler) { | 1246 ASSEMBLER_TEST_GENERATE(AddressShiftStrLSL1NegOffset, assembler) { |
1368 __ mov(R2, Operand(42)); | 1247 __ mov(R2, Operand(42)); |
1369 __ mov(R1, Operand(kWordSize)); | 1248 __ mov(R1, Operand(kWordSize)); |
1370 __ str(R2, Address(SP, R1, LSL, 1, Address::NegOffset)); | 1249 __ str(R2, Address(SP, R1, LSL, 1, Address::NegOffset)); |
1371 __ ldr(R0, Address(SP, (-kWordSize * 2), Address::Offset)); | 1250 __ ldr(R0, Address(SP, (-kWordSize * 2), Address::Offset)); |
1372 __ bx(LR); | 1251 __ bx(LR); |
1373 } | 1252 } |
1374 | 1253 |
1375 | |
1376 ASSEMBLER_TEST_RUN(AddressShiftStrLSL1NegOffset, test) { | 1254 ASSEMBLER_TEST_RUN(AddressShiftStrLSL1NegOffset, test) { |
1377 EXPECT(test != NULL); | 1255 EXPECT(test != NULL); |
1378 typedef int (*Tst)() DART_UNUSED; | 1256 typedef int (*Tst)() DART_UNUSED; |
1379 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1257 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1380 } | 1258 } |
1381 | 1259 |
1382 | |
1383 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLSL5NegOffset, assembler) { | 1260 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLSL5NegOffset, assembler) { |
1384 __ mov(R2, Operand(42)); | 1261 __ mov(R2, Operand(42)); |
1385 __ mov(R1, Operand(kWordSize)); | 1262 __ mov(R1, Operand(kWordSize)); |
1386 __ str(R2, Address(SP, (-kWordSize * 32), Address::Offset)); | 1263 __ str(R2, Address(SP, (-kWordSize * 32), Address::Offset)); |
1387 __ ldr(R0, Address(SP, R1, LSL, 5, Address::NegOffset)); | 1264 __ ldr(R0, Address(SP, R1, LSL, 5, Address::NegOffset)); |
1388 __ bx(LR); | 1265 __ bx(LR); |
1389 } | 1266 } |
1390 | 1267 |
1391 | |
1392 ASSEMBLER_TEST_RUN(AddressShiftLdrLSL5NegOffset, test) { | 1268 ASSEMBLER_TEST_RUN(AddressShiftLdrLSL5NegOffset, test) { |
1393 EXPECT(test != NULL); | 1269 EXPECT(test != NULL); |
1394 typedef int (*Tst)() DART_UNUSED; | 1270 typedef int (*Tst)() DART_UNUSED; |
1395 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1271 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1396 } | 1272 } |
1397 | 1273 |
1398 | |
1399 ASSEMBLER_TEST_GENERATE(AddressShiftStrLRS1NegOffset, assembler) { | 1274 ASSEMBLER_TEST_GENERATE(AddressShiftStrLRS1NegOffset, assembler) { |
1400 __ mov(R2, Operand(42)); | 1275 __ mov(R2, Operand(42)); |
1401 __ mov(R1, Operand(kWordSize * 2)); | 1276 __ mov(R1, Operand(kWordSize * 2)); |
1402 __ str(R2, Address(SP, R1, LSR, 1, Address::NegOffset)); | 1277 __ str(R2, Address(SP, R1, LSR, 1, Address::NegOffset)); |
1403 __ ldr(R0, Address(SP, -kWordSize, Address::Offset)); | 1278 __ ldr(R0, Address(SP, -kWordSize, Address::Offset)); |
1404 __ bx(LR); | 1279 __ bx(LR); |
1405 } | 1280 } |
1406 | 1281 |
1407 | |
1408 ASSEMBLER_TEST_RUN(AddressShiftStrLRS1NegOffset, test) { | 1282 ASSEMBLER_TEST_RUN(AddressShiftStrLRS1NegOffset, test) { |
1409 EXPECT(test != NULL); | 1283 EXPECT(test != NULL); |
1410 typedef int (*Tst)() DART_UNUSED; | 1284 typedef int (*Tst)() DART_UNUSED; |
1411 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1285 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1412 } | 1286 } |
1413 | 1287 |
1414 | |
1415 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLRS1NegOffset, assembler) { | 1288 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLRS1NegOffset, assembler) { |
1416 __ mov(R2, Operand(42)); | 1289 __ mov(R2, Operand(42)); |
1417 __ mov(R1, Operand(kWordSize * 2)); | 1290 __ mov(R1, Operand(kWordSize * 2)); |
1418 __ str(R2, Address(SP, -kWordSize, Address::Offset)); | 1291 __ str(R2, Address(SP, -kWordSize, Address::Offset)); |
1419 __ ldr(R0, Address(SP, R1, LSR, 1, Address::NegOffset)); | 1292 __ ldr(R0, Address(SP, R1, LSR, 1, Address::NegOffset)); |
1420 __ bx(LR); | 1293 __ bx(LR); |
1421 } | 1294 } |
1422 | 1295 |
1423 | |
1424 ASSEMBLER_TEST_RUN(AddressShiftLdrLRS1NegOffset, test) { | 1296 ASSEMBLER_TEST_RUN(AddressShiftLdrLRS1NegOffset, test) { |
1425 EXPECT(test != NULL); | 1297 EXPECT(test != NULL); |
1426 typedef int (*Tst)() DART_UNUSED; | 1298 typedef int (*Tst)() DART_UNUSED; |
1427 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1299 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1428 } | 1300 } |
1429 | 1301 |
1430 | |
1431 ASSEMBLER_TEST_GENERATE(AddressShiftStrLSLNegPreIndex, assembler) { | 1302 ASSEMBLER_TEST_GENERATE(AddressShiftStrLSLNegPreIndex, assembler) { |
1432 __ mov(R2, Operand(42)); | 1303 __ mov(R2, Operand(42)); |
1433 __ mov(R1, Operand(kWordSize)); | 1304 __ mov(R1, Operand(kWordSize)); |
1434 __ mov(R3, Operand(SP)); | 1305 __ mov(R3, Operand(SP)); |
1435 __ str(R2, Address(SP, R1, LSL, 5, Address::NegPreIndex)); | 1306 __ str(R2, Address(SP, R1, LSL, 5, Address::NegPreIndex)); |
1436 __ ldr(R0, Address(R3, (-kWordSize * 32), Address::Offset)); | 1307 __ ldr(R0, Address(R3, (-kWordSize * 32), Address::Offset)); |
1437 __ mov(SP, Operand(R3)); | 1308 __ mov(SP, Operand(R3)); |
1438 __ bx(LR); | 1309 __ bx(LR); |
1439 } | 1310 } |
1440 | 1311 |
1441 | |
1442 ASSEMBLER_TEST_RUN(AddressShiftStrLSLNegPreIndex, test) { | 1312 ASSEMBLER_TEST_RUN(AddressShiftStrLSLNegPreIndex, test) { |
1443 EXPECT(test != NULL); | 1313 EXPECT(test != NULL); |
1444 typedef int (*Tst)() DART_UNUSED; | 1314 typedef int (*Tst)() DART_UNUSED; |
1445 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1315 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1446 } | 1316 } |
1447 | 1317 |
1448 | |
1449 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLSLNegPreIndex, assembler) { | 1318 ASSEMBLER_TEST_GENERATE(AddressShiftLdrLSLNegPreIndex, assembler) { |
1450 __ mov(R2, Operand(42)); | 1319 __ mov(R2, Operand(42)); |
1451 __ mov(R1, Operand(kWordSize)); | 1320 __ mov(R1, Operand(kWordSize)); |
1452 __ str(R2, Address(SP, (-kWordSize * 32), Address::PreIndex)); | 1321 __ str(R2, Address(SP, (-kWordSize * 32), Address::PreIndex)); |
1453 __ ldr(R0, Address(SP, R1, LSL, 5, Address::PostIndex)); | 1322 __ ldr(R0, Address(SP, R1, LSL, 5, Address::PostIndex)); |
1454 __ bx(LR); | 1323 __ bx(LR); |
1455 } | 1324 } |
1456 | 1325 |
1457 | |
1458 ASSEMBLER_TEST_RUN(AddressShiftLdrLSLNegPreIndex, test) { | 1326 ASSEMBLER_TEST_RUN(AddressShiftLdrLSLNegPreIndex, test) { |
1459 EXPECT(test != NULL); | 1327 EXPECT(test != NULL); |
1460 typedef int (*Tst)() DART_UNUSED; | 1328 typedef int (*Tst)() DART_UNUSED; |
1461 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1329 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1462 } | 1330 } |
1463 | 1331 |
1464 | |
1465 // Make sure we can store and reload the D registers using vstmd and vldmd | 1332 // Make sure we can store and reload the D registers using vstmd and vldmd |
1466 ASSEMBLER_TEST_GENERATE(VstmdVldmd, assembler) { | 1333 ASSEMBLER_TEST_GENERATE(VstmdVldmd, assembler) { |
1467 if (TargetCPUFeatures::vfp_supported()) { | 1334 if (TargetCPUFeatures::vfp_supported()) { |
1468 __ LoadDImmediate(D0, 0.0, R0); | 1335 __ LoadDImmediate(D0, 0.0, R0); |
1469 __ LoadDImmediate(D1, 1.0, R0); | 1336 __ LoadDImmediate(D1, 1.0, R0); |
1470 __ LoadDImmediate(D2, 2.0, R0); | 1337 __ LoadDImmediate(D2, 2.0, R0); |
1471 __ LoadDImmediate(D3, 3.0, R0); | 1338 __ LoadDImmediate(D3, 3.0, R0); |
1472 __ LoadDImmediate(D4, 4.0, R0); | 1339 __ LoadDImmediate(D4, 4.0, R0); |
1473 __ vstmd(DB_W, SP, D0, 5); // Push D0 - D4 onto the stack, dec SP | 1340 __ vstmd(DB_W, SP, D0, 5); // Push D0 - D4 onto the stack, dec SP |
1474 __ LoadDImmediate(D0, 0.0, R0); | 1341 __ LoadDImmediate(D0, 0.0, R0); |
(...skipping 11 matching lines...) Expand all Loading... |
1486 __ vcmpd(D4, D5); | 1353 __ vcmpd(D4, D5); |
1487 __ vmstat(); | 1354 __ vmstat(); |
1488 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1355 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1489 | 1356 |
1490 // Check that 3.0 is back in D3 | 1357 // Check that 3.0 is back in D3 |
1491 __ LoadDImmediate(D5, 3.0, R1); | 1358 __ LoadDImmediate(D5, 3.0, R1); |
1492 __ vcmpd(D3, D5); | 1359 __ vcmpd(D3, D5); |
1493 __ vmstat(); | 1360 __ vmstat(); |
1494 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1361 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1495 | 1362 |
1496 | |
1497 // Check that 2.0 is back in D2 | 1363 // Check that 2.0 is back in D2 |
1498 __ LoadDImmediate(D5, 2.0, R1); | 1364 __ LoadDImmediate(D5, 2.0, R1); |
1499 __ vcmpd(D2, D5); | 1365 __ vcmpd(D2, D5); |
1500 __ vmstat(); | 1366 __ vmstat(); |
1501 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1367 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1502 | 1368 |
1503 // Check that 1.0 is back in D1 | 1369 // Check that 1.0 is back in D1 |
1504 __ LoadDImmediate(D5, 1.0, R1); | 1370 __ LoadDImmediate(D5, 1.0, R1); |
1505 __ vcmpd(D1, D5); | 1371 __ vcmpd(D1, D5); |
1506 __ vmstat(); | 1372 __ vmstat(); |
1507 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1373 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1508 } | 1374 } |
1509 __ bx(LR); | 1375 __ bx(LR); |
1510 } | 1376 } |
1511 | 1377 |
1512 | |
1513 ASSEMBLER_TEST_RUN(VstmdVldmd, test) { | 1378 ASSEMBLER_TEST_RUN(VstmdVldmd, test) { |
1514 EXPECT(test != NULL); | 1379 EXPECT(test != NULL); |
1515 if (TargetCPUFeatures::vfp_supported()) { | 1380 if (TargetCPUFeatures::vfp_supported()) { |
1516 typedef int (*Tst)() DART_UNUSED; | 1381 typedef int (*Tst)() DART_UNUSED; |
1517 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1382 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1518 } | 1383 } |
1519 } | 1384 } |
1520 | 1385 |
1521 | |
1522 // Make sure we can store and reload the S registers using vstms and vldms | 1386 // Make sure we can store and reload the S registers using vstms and vldms |
1523 ASSEMBLER_TEST_GENERATE(VstmsVldms, assembler) { | 1387 ASSEMBLER_TEST_GENERATE(VstmsVldms, assembler) { |
1524 if (TargetCPUFeatures::vfp_supported()) { | 1388 if (TargetCPUFeatures::vfp_supported()) { |
1525 __ LoadSImmediate(S0, 0.0); | 1389 __ LoadSImmediate(S0, 0.0); |
1526 __ LoadSImmediate(S1, 1.0); | 1390 __ LoadSImmediate(S1, 1.0); |
1527 __ LoadSImmediate(S2, 2.0); | 1391 __ LoadSImmediate(S2, 2.0); |
1528 __ LoadSImmediate(S3, 3.0); | 1392 __ LoadSImmediate(S3, 3.0); |
1529 __ LoadSImmediate(S4, 4.0); | 1393 __ LoadSImmediate(S4, 4.0); |
1530 __ vstms(DB_W, SP, S0, S4); // Push S0 - S4 onto the stack, dec SP | 1394 __ vstms(DB_W, SP, S0, S4); // Push S0 - S4 onto the stack, dec SP |
1531 __ LoadSImmediate(S0, 0.0); | 1395 __ LoadSImmediate(S0, 0.0); |
(...skipping 26 matching lines...) Expand all Loading... |
1558 | 1422 |
1559 // Check that 1.0 is back in S1 | 1423 // Check that 1.0 is back in S1 |
1560 __ LoadSImmediate(S5, 1.0); | 1424 __ LoadSImmediate(S5, 1.0); |
1561 __ vcmps(S1, S5); | 1425 __ vcmps(S1, S5); |
1562 __ vmstat(); | 1426 __ vmstat(); |
1563 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE | 1427 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE |
1564 } | 1428 } |
1565 __ bx(LR); | 1429 __ bx(LR); |
1566 } | 1430 } |
1567 | 1431 |
1568 | |
1569 ASSEMBLER_TEST_RUN(VstmsVldms, test) { | 1432 ASSEMBLER_TEST_RUN(VstmsVldms, test) { |
1570 EXPECT(test != NULL); | 1433 EXPECT(test != NULL); |
1571 if (TargetCPUFeatures::vfp_supported()) { | 1434 if (TargetCPUFeatures::vfp_supported()) { |
1572 typedef int (*Tst)() DART_UNUSED; | 1435 typedef int (*Tst)() DART_UNUSED; |
1573 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1436 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1574 } | 1437 } |
1575 } | 1438 } |
1576 | 1439 |
1577 | |
1578 // Make sure we can start somewhere other than D0 | 1440 // Make sure we can start somewhere other than D0 |
1579 ASSEMBLER_TEST_GENERATE(VstmdVldmd1, assembler) { | 1441 ASSEMBLER_TEST_GENERATE(VstmdVldmd1, assembler) { |
1580 if (TargetCPUFeatures::vfp_supported()) { | 1442 if (TargetCPUFeatures::vfp_supported()) { |
1581 __ LoadDImmediate(D1, 1.0, R0); | 1443 __ LoadDImmediate(D1, 1.0, R0); |
1582 __ LoadDImmediate(D2, 2.0, R0); | 1444 __ LoadDImmediate(D2, 2.0, R0); |
1583 __ LoadDImmediate(D3, 3.0, R0); | 1445 __ LoadDImmediate(D3, 3.0, R0); |
1584 __ LoadDImmediate(D4, 4.0, R0); | 1446 __ LoadDImmediate(D4, 4.0, R0); |
1585 __ vstmd(DB_W, SP, D1, 4); // Push D1 - D4 onto the stack, dec SP | 1447 __ vstmd(DB_W, SP, D1, 4); // Push D1 - D4 onto the stack, dec SP |
1586 __ LoadDImmediate(D1, 0.0, R0); | 1448 __ LoadDImmediate(D1, 0.0, R0); |
1587 __ LoadDImmediate(D2, 0.0, R0); | 1449 __ LoadDImmediate(D2, 0.0, R0); |
1588 __ LoadDImmediate(D3, 0.0, R0); | 1450 __ LoadDImmediate(D3, 0.0, R0); |
1589 __ LoadDImmediate(D4, 0.0, R0); | 1451 __ LoadDImmediate(D4, 0.0, R0); |
1590 __ vldmd(IA_W, SP, D1, 4); // Pop stack into D1 - D4, inc SP | 1452 __ vldmd(IA_W, SP, D1, 4); // Pop stack into D1 - D4, inc SP |
1591 | 1453 |
1592 // Load success value into R0 | 1454 // Load success value into R0 |
1593 __ mov(R0, Operand(42)); | 1455 __ mov(R0, Operand(42)); |
1594 | 1456 |
1595 // Check that 4.0 is back in D4 | 1457 // Check that 4.0 is back in D4 |
1596 __ LoadDImmediate(D5, 4.0, R1); | 1458 __ LoadDImmediate(D5, 4.0, R1); |
1597 __ vcmpd(D4, D5); | 1459 __ vcmpd(D4, D5); |
1598 __ vmstat(); | 1460 __ vmstat(); |
1599 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1461 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1600 | 1462 |
1601 // Check that 3.0 is back in D3 | 1463 // Check that 3.0 is back in D3 |
1602 __ LoadDImmediate(D5, 3.0, R1); | 1464 __ LoadDImmediate(D5, 3.0, R1); |
1603 __ vcmpd(D3, D5); | 1465 __ vcmpd(D3, D5); |
1604 __ vmstat(); | 1466 __ vmstat(); |
1605 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1467 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1606 | 1468 |
1607 | |
1608 // Check that 2.0 is back in D2 | 1469 // Check that 2.0 is back in D2 |
1609 __ LoadDImmediate(D5, 2.0, R1); | 1470 __ LoadDImmediate(D5, 2.0, R1); |
1610 __ vcmpd(D2, D5); | 1471 __ vcmpd(D2, D5); |
1611 __ vmstat(); | 1472 __ vmstat(); |
1612 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1473 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1613 | 1474 |
1614 // Check that 1.0 is back in D1 | 1475 // Check that 1.0 is back in D1 |
1615 __ LoadDImmediate(D5, 1.0, R1); | 1476 __ LoadDImmediate(D5, 1.0, R1); |
1616 __ vcmpd(D1, D5); | 1477 __ vcmpd(D1, D5); |
1617 __ vmstat(); | 1478 __ vmstat(); |
1618 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1479 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1619 } | 1480 } |
1620 __ bx(LR); | 1481 __ bx(LR); |
1621 } | 1482 } |
1622 | 1483 |
1623 | |
1624 ASSEMBLER_TEST_RUN(VstmdVldmd1, test) { | 1484 ASSEMBLER_TEST_RUN(VstmdVldmd1, test) { |
1625 EXPECT(test != NULL); | 1485 EXPECT(test != NULL); |
1626 if (TargetCPUFeatures::vfp_supported()) { | 1486 if (TargetCPUFeatures::vfp_supported()) { |
1627 typedef int (*Tst)() DART_UNUSED; | 1487 typedef int (*Tst)() DART_UNUSED; |
1628 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1488 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1629 } | 1489 } |
1630 } | 1490 } |
1631 | 1491 |
1632 | |
1633 // Make sure we can start somewhere other than S0 | 1492 // Make sure we can start somewhere other than S0 |
1634 ASSEMBLER_TEST_GENERATE(VstmsVldms1, assembler) { | 1493 ASSEMBLER_TEST_GENERATE(VstmsVldms1, assembler) { |
1635 if (TargetCPUFeatures::vfp_supported()) { | 1494 if (TargetCPUFeatures::vfp_supported()) { |
1636 __ LoadSImmediate(S1, 1.0); | 1495 __ LoadSImmediate(S1, 1.0); |
1637 __ LoadSImmediate(S2, 2.0); | 1496 __ LoadSImmediate(S2, 2.0); |
1638 __ LoadSImmediate(S3, 3.0); | 1497 __ LoadSImmediate(S3, 3.0); |
1639 __ LoadSImmediate(S4, 4.0); | 1498 __ LoadSImmediate(S4, 4.0); |
1640 __ vstms(DB_W, SP, S1, S4); // Push S0 - S4 onto the stack, dec SP | 1499 __ vstms(DB_W, SP, S1, S4); // Push S0 - S4 onto the stack, dec SP |
1641 __ LoadSImmediate(S1, 0.0); | 1500 __ LoadSImmediate(S1, 0.0); |
1642 __ LoadSImmediate(S2, 0.0); | 1501 __ LoadSImmediate(S2, 0.0); |
(...skipping 24 matching lines...) Expand all Loading... |
1667 | 1526 |
1668 // Check that 1.0 is back in S1 | 1527 // Check that 1.0 is back in S1 |
1669 __ LoadSImmediate(S5, 1.0); | 1528 __ LoadSImmediate(S5, 1.0); |
1670 __ vcmps(S1, S5); | 1529 __ vcmps(S1, S5); |
1671 __ vmstat(); | 1530 __ vmstat(); |
1672 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE | 1531 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE |
1673 } | 1532 } |
1674 __ bx(LR); | 1533 __ bx(LR); |
1675 } | 1534 } |
1676 | 1535 |
1677 | |
1678 ASSEMBLER_TEST_RUN(VstmsVldms1, test) { | 1536 ASSEMBLER_TEST_RUN(VstmsVldms1, test) { |
1679 EXPECT(test != NULL); | 1537 EXPECT(test != NULL); |
1680 if (TargetCPUFeatures::vfp_supported()) { | 1538 if (TargetCPUFeatures::vfp_supported()) { |
1681 typedef int (*Tst)() DART_UNUSED; | 1539 typedef int (*Tst)() DART_UNUSED; |
1682 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1540 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1683 } | 1541 } |
1684 } | 1542 } |
1685 | 1543 |
1686 | |
1687 // Make sure we can store the D registers using vstmd and | 1544 // Make sure we can store the D registers using vstmd and |
1688 // load them into a different set using vldmd | 1545 // load them into a different set using vldmd |
1689 ASSEMBLER_TEST_GENERATE(VstmdVldmd_off, assembler) { | 1546 ASSEMBLER_TEST_GENERATE(VstmdVldmd_off, assembler) { |
1690 if (TargetCPUFeatures::vfp_supported()) { | 1547 if (TargetCPUFeatures::vfp_supported()) { |
1691 // Save used callee-saved FPU registers. | 1548 // Save used callee-saved FPU registers. |
1692 __ vstmd(DB_W, SP, D8, 3); | 1549 __ vstmd(DB_W, SP, D8, 3); |
1693 __ LoadDImmediate(D0, 0.0, R0); | 1550 __ LoadDImmediate(D0, 0.0, R0); |
1694 __ LoadDImmediate(D1, 1.0, R0); | 1551 __ LoadDImmediate(D1, 1.0, R0); |
1695 __ LoadDImmediate(D2, 2.0, R0); | 1552 __ LoadDImmediate(D2, 2.0, R0); |
1696 __ LoadDImmediate(D3, 3.0, R0); | 1553 __ LoadDImmediate(D3, 3.0, R0); |
(...skipping 10 matching lines...) Expand all Loading... |
1707 __ vcmpd(D9, D10); | 1564 __ vcmpd(D9, D10); |
1708 __ vmstat(); | 1565 __ vmstat(); |
1709 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1566 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1710 | 1567 |
1711 // Check that 3.0 is in D8 | 1568 // Check that 3.0 is in D8 |
1712 __ LoadDImmediate(D10, 3.0, R1); | 1569 __ LoadDImmediate(D10, 3.0, R1); |
1713 __ vcmpd(D8, D10); | 1570 __ vcmpd(D8, D10); |
1714 __ vmstat(); | 1571 __ vmstat(); |
1715 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1572 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1716 | 1573 |
1717 | |
1718 // Check that 2.0 is in D7 | 1574 // Check that 2.0 is in D7 |
1719 __ LoadDImmediate(D10, 2.0, R1); | 1575 __ LoadDImmediate(D10, 2.0, R1); |
1720 __ vcmpd(D7, D10); | 1576 __ vcmpd(D7, D10); |
1721 __ vmstat(); | 1577 __ vmstat(); |
1722 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1578 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1723 | 1579 |
1724 // Check that 1.0 is in D6 | 1580 // Check that 1.0 is in D6 |
1725 __ LoadDImmediate(D10, 1.0, R1); | 1581 __ LoadDImmediate(D10, 1.0, R1); |
1726 __ vcmpd(D6, D10); | 1582 __ vcmpd(D6, D10); |
1727 __ vmstat(); | 1583 __ vmstat(); |
1728 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1584 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1729 | 1585 |
1730 // Check that 0.0 is in D5 | 1586 // Check that 0.0 is in D5 |
1731 __ LoadDImmediate(D10, 0.0, R1); | 1587 __ LoadDImmediate(D10, 0.0, R1); |
1732 __ vcmpd(D5, D10); | 1588 __ vcmpd(D5, D10); |
1733 __ vmstat(); | 1589 __ vmstat(); |
1734 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE | 1590 __ mov(R0, Operand(0), NE); // Put failure into R0 if NE |
1735 | 1591 |
1736 // Restore used callee-saved FPU registers. | 1592 // Restore used callee-saved FPU registers. |
1737 __ vldmd(IA_W, SP, D8, 3); | 1593 __ vldmd(IA_W, SP, D8, 3); |
1738 } | 1594 } |
1739 __ bx(LR); | 1595 __ bx(LR); |
1740 } | 1596 } |
1741 | 1597 |
1742 | |
1743 ASSEMBLER_TEST_RUN(VstmdVldmd_off, test) { | 1598 ASSEMBLER_TEST_RUN(VstmdVldmd_off, test) { |
1744 EXPECT(test != NULL); | 1599 EXPECT(test != NULL); |
1745 if (TargetCPUFeatures::vfp_supported()) { | 1600 if (TargetCPUFeatures::vfp_supported()) { |
1746 typedef int (*Tst)() DART_UNUSED; | 1601 typedef int (*Tst)() DART_UNUSED; |
1747 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1602 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1748 } | 1603 } |
1749 } | 1604 } |
1750 | 1605 |
1751 | |
1752 // Make sure we can start somewhere other than S0 | 1606 // Make sure we can start somewhere other than S0 |
1753 ASSEMBLER_TEST_GENERATE(VstmsVldms_off, assembler) { | 1607 ASSEMBLER_TEST_GENERATE(VstmsVldms_off, assembler) { |
1754 if (TargetCPUFeatures::vfp_supported()) { | 1608 if (TargetCPUFeatures::vfp_supported()) { |
1755 __ LoadSImmediate(S0, 0.0); | 1609 __ LoadSImmediate(S0, 0.0); |
1756 __ LoadSImmediate(S1, 1.0); | 1610 __ LoadSImmediate(S1, 1.0); |
1757 __ LoadSImmediate(S2, 2.0); | 1611 __ LoadSImmediate(S2, 2.0); |
1758 __ LoadSImmediate(S3, 3.0); | 1612 __ LoadSImmediate(S3, 3.0); |
1759 __ LoadSImmediate(S4, 4.0); | 1613 __ LoadSImmediate(S4, 4.0); |
1760 __ LoadSImmediate(S5, 5.0); | 1614 __ LoadSImmediate(S5, 5.0); |
1761 __ vstms(DB_W, SP, S0, S4); // Push S0 - S4 onto the stack, dec SP | 1615 __ vstms(DB_W, SP, S0, S4); // Push S0 - S4 onto the stack, dec SP |
(...skipping 28 matching lines...) Expand all Loading... |
1790 | 1644 |
1791 // Check that 0.0 is back in S5 | 1645 // Check that 0.0 is back in S5 |
1792 __ LoadSImmediate(S10, 0.0); | 1646 __ LoadSImmediate(S10, 0.0); |
1793 __ vcmps(S5, S10); | 1647 __ vcmps(S5, S10); |
1794 __ vmstat(); | 1648 __ vmstat(); |
1795 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE | 1649 __ mov(R0, Operand(0), NE); // Put failure value into R0 if NE |
1796 } | 1650 } |
1797 __ bx(LR); | 1651 __ bx(LR); |
1798 } | 1652 } |
1799 | 1653 |
1800 | |
1801 ASSEMBLER_TEST_RUN(VstmsVldms_off, test) { | 1654 ASSEMBLER_TEST_RUN(VstmsVldms_off, test) { |
1802 EXPECT(test != NULL); | 1655 EXPECT(test != NULL); |
1803 if (TargetCPUFeatures::vfp_supported()) { | 1656 if (TargetCPUFeatures::vfp_supported()) { |
1804 typedef int (*Tst)() DART_UNUSED; | 1657 typedef int (*Tst)() DART_UNUSED; |
1805 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1658 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1806 } | 1659 } |
1807 } | 1660 } |
1808 | 1661 |
1809 | |
1810 ASSEMBLER_TEST_GENERATE(Udiv, assembler) { | 1662 ASSEMBLER_TEST_GENERATE(Udiv, assembler) { |
1811 if (TargetCPUFeatures::integer_division_supported()) { | 1663 if (TargetCPUFeatures::integer_division_supported()) { |
1812 __ mov(R0, Operand(27)); | 1664 __ mov(R0, Operand(27)); |
1813 __ mov(R1, Operand(9)); | 1665 __ mov(R1, Operand(9)); |
1814 __ udiv(R2, R0, R1); | 1666 __ udiv(R2, R0, R1); |
1815 __ mov(R0, Operand(R2)); | 1667 __ mov(R0, Operand(R2)); |
1816 } | 1668 } |
1817 __ bx(LR); | 1669 __ bx(LR); |
1818 } | 1670 } |
1819 | 1671 |
1820 | |
1821 ASSEMBLER_TEST_RUN(Udiv, test) { | 1672 ASSEMBLER_TEST_RUN(Udiv, test) { |
1822 EXPECT(test != NULL); | 1673 EXPECT(test != NULL); |
1823 if (TargetCPUFeatures::integer_division_supported()) { | 1674 if (TargetCPUFeatures::integer_division_supported()) { |
1824 typedef int (*Tst)() DART_UNUSED; | 1675 typedef int (*Tst)() DART_UNUSED; |
1825 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1676 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1826 } | 1677 } |
1827 } | 1678 } |
1828 | 1679 |
1829 | |
1830 ASSEMBLER_TEST_GENERATE(Sdiv, assembler) { | 1680 ASSEMBLER_TEST_GENERATE(Sdiv, assembler) { |
1831 if (TargetCPUFeatures::integer_division_supported()) { | 1681 if (TargetCPUFeatures::integer_division_supported()) { |
1832 __ mov(R0, Operand(27)); | 1682 __ mov(R0, Operand(27)); |
1833 __ LoadImmediate(R1, -9); | 1683 __ LoadImmediate(R1, -9); |
1834 __ sdiv(R2, R0, R1); | 1684 __ sdiv(R2, R0, R1); |
1835 __ mov(R0, Operand(R2)); | 1685 __ mov(R0, Operand(R2)); |
1836 } | 1686 } |
1837 __ bx(LR); | 1687 __ bx(LR); |
1838 } | 1688 } |
1839 | 1689 |
1840 | |
1841 ASSEMBLER_TEST_RUN(Sdiv, test) { | 1690 ASSEMBLER_TEST_RUN(Sdiv, test) { |
1842 EXPECT(test != NULL); | 1691 EXPECT(test != NULL); |
1843 if (TargetCPUFeatures::integer_division_supported()) { | 1692 if (TargetCPUFeatures::integer_division_supported()) { |
1844 typedef int (*Tst)() DART_UNUSED; | 1693 typedef int (*Tst)() DART_UNUSED; |
1845 EXPECT_EQ(-3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1694 EXPECT_EQ(-3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1846 } | 1695 } |
1847 } | 1696 } |
1848 | 1697 |
1849 | |
1850 ASSEMBLER_TEST_GENERATE(Udiv_zero, assembler) { | 1698 ASSEMBLER_TEST_GENERATE(Udiv_zero, assembler) { |
1851 if (TargetCPUFeatures::integer_division_supported()) { | 1699 if (TargetCPUFeatures::integer_division_supported()) { |
1852 __ mov(R0, Operand(27)); | 1700 __ mov(R0, Operand(27)); |
1853 __ mov(R1, Operand(0)); | 1701 __ mov(R1, Operand(0)); |
1854 __ udiv(R2, R0, R1); | 1702 __ udiv(R2, R0, R1); |
1855 __ mov(R0, Operand(R2)); | 1703 __ mov(R0, Operand(R2)); |
1856 } | 1704 } |
1857 __ bx(LR); | 1705 __ bx(LR); |
1858 } | 1706 } |
1859 | 1707 |
1860 | |
1861 ASSEMBLER_TEST_RUN(Udiv_zero, test) { | 1708 ASSEMBLER_TEST_RUN(Udiv_zero, test) { |
1862 EXPECT(test != NULL); | 1709 EXPECT(test != NULL); |
1863 if (TargetCPUFeatures::integer_division_supported()) { | 1710 if (TargetCPUFeatures::integer_division_supported()) { |
1864 typedef int (*Tst)() DART_UNUSED; | 1711 typedef int (*Tst)() DART_UNUSED; |
1865 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1712 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1866 } | 1713 } |
1867 } | 1714 } |
1868 | 1715 |
1869 | |
1870 ASSEMBLER_TEST_GENERATE(Sdiv_zero, assembler) { | 1716 ASSEMBLER_TEST_GENERATE(Sdiv_zero, assembler) { |
1871 if (TargetCPUFeatures::integer_division_supported()) { | 1717 if (TargetCPUFeatures::integer_division_supported()) { |
1872 __ mov(R0, Operand(27)); | 1718 __ mov(R0, Operand(27)); |
1873 __ mov(R1, Operand(0)); | 1719 __ mov(R1, Operand(0)); |
1874 __ sdiv(R2, R0, R1); | 1720 __ sdiv(R2, R0, R1); |
1875 __ mov(R0, Operand(R2)); | 1721 __ mov(R0, Operand(R2)); |
1876 } | 1722 } |
1877 __ bx(LR); | 1723 __ bx(LR); |
1878 } | 1724 } |
1879 | 1725 |
1880 | |
1881 ASSEMBLER_TEST_RUN(Sdiv_zero, test) { | 1726 ASSEMBLER_TEST_RUN(Sdiv_zero, test) { |
1882 EXPECT(test != NULL); | 1727 EXPECT(test != NULL); |
1883 if (TargetCPUFeatures::integer_division_supported()) { | 1728 if (TargetCPUFeatures::integer_division_supported()) { |
1884 typedef int (*Tst)() DART_UNUSED; | 1729 typedef int (*Tst)() DART_UNUSED; |
1885 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1730 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1886 } | 1731 } |
1887 } | 1732 } |
1888 | 1733 |
1889 | |
1890 ASSEMBLER_TEST_GENERATE(Udiv_corner, assembler) { | 1734 ASSEMBLER_TEST_GENERATE(Udiv_corner, assembler) { |
1891 if (TargetCPUFeatures::integer_division_supported()) { | 1735 if (TargetCPUFeatures::integer_division_supported()) { |
1892 __ LoadImmediate(R0, 0x80000000); | 1736 __ LoadImmediate(R0, 0x80000000); |
1893 __ LoadImmediate(R1, 0xffffffff); | 1737 __ LoadImmediate(R1, 0xffffffff); |
1894 __ udiv(R2, R0, R1); | 1738 __ udiv(R2, R0, R1); |
1895 __ mov(R0, Operand(R2)); | 1739 __ mov(R0, Operand(R2)); |
1896 } | 1740 } |
1897 __ bx(LR); | 1741 __ bx(LR); |
1898 } | 1742 } |
1899 | 1743 |
1900 | |
1901 ASSEMBLER_TEST_RUN(Udiv_corner, test) { | 1744 ASSEMBLER_TEST_RUN(Udiv_corner, test) { |
1902 EXPECT(test != NULL); | 1745 EXPECT(test != NULL); |
1903 if (TargetCPUFeatures::integer_division_supported()) { | 1746 if (TargetCPUFeatures::integer_division_supported()) { |
1904 typedef int (*Tst)() DART_UNUSED; | 1747 typedef int (*Tst)() DART_UNUSED; |
1905 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1748 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1906 } | 1749 } |
1907 } | 1750 } |
1908 | 1751 |
1909 | |
1910 ASSEMBLER_TEST_GENERATE(Sdiv_corner, assembler) { | 1752 ASSEMBLER_TEST_GENERATE(Sdiv_corner, assembler) { |
1911 if (TargetCPUFeatures::integer_division_supported()) { | 1753 if (TargetCPUFeatures::integer_division_supported()) { |
1912 __ LoadImmediate(R0, 0x80000000); | 1754 __ LoadImmediate(R0, 0x80000000); |
1913 __ LoadImmediate(R1, 0xffffffff); | 1755 __ LoadImmediate(R1, 0xffffffff); |
1914 __ sdiv(R2, R0, R1); | 1756 __ sdiv(R2, R0, R1); |
1915 __ mov(R0, Operand(R2)); | 1757 __ mov(R0, Operand(R2)); |
1916 } | 1758 } |
1917 __ bx(LR); | 1759 __ bx(LR); |
1918 } | 1760 } |
1919 | 1761 |
1920 | |
1921 ASSEMBLER_TEST_RUN(Sdiv_corner, test) { | 1762 ASSEMBLER_TEST_RUN(Sdiv_corner, test) { |
1922 EXPECT(test != NULL); | 1763 EXPECT(test != NULL); |
1923 if (TargetCPUFeatures::integer_division_supported()) { | 1764 if (TargetCPUFeatures::integer_division_supported()) { |
1924 typedef int (*Tst)() DART_UNUSED; | 1765 typedef int (*Tst)() DART_UNUSED; |
1925 EXPECT_EQ(static_cast<int32_t>(0x80000000), | 1766 EXPECT_EQ(static_cast<int32_t>(0x80000000), |
1926 EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1767 EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1927 } | 1768 } |
1928 } | 1769 } |
1929 | 1770 |
1930 | |
1931 ASSEMBLER_TEST_GENERATE(IntDiv_supported, assembler) { | 1771 ASSEMBLER_TEST_GENERATE(IntDiv_supported, assembler) { |
1932 #if defined(USING_SIMULATOR) | 1772 #if defined(USING_SIMULATOR) |
1933 bool orig = TargetCPUFeatures::integer_division_supported(); | 1773 bool orig = TargetCPUFeatures::integer_division_supported(); |
1934 HostCPUFeatures::set_integer_division_supported(true); | 1774 HostCPUFeatures::set_integer_division_supported(true); |
1935 __ mov(R0, Operand(27)); | 1775 __ mov(R0, Operand(27)); |
1936 __ mov(R1, Operand(9)); | 1776 __ mov(R1, Operand(9)); |
1937 __ IntegerDivide(R0, R0, R1, D0, D1); | 1777 __ IntegerDivide(R0, R0, R1, D0, D1); |
1938 HostCPUFeatures::set_integer_division_supported(orig); | 1778 HostCPUFeatures::set_integer_division_supported(orig); |
1939 __ bx(LR); | 1779 __ bx(LR); |
1940 #else | 1780 #else |
1941 if (TargetCPUFeatures::can_divide()) { | 1781 if (TargetCPUFeatures::can_divide()) { |
1942 __ mov(R0, Operand(27)); | 1782 __ mov(R0, Operand(27)); |
1943 __ mov(R1, Operand(9)); | 1783 __ mov(R1, Operand(9)); |
1944 __ IntegerDivide(R0, R0, R1, D0, D1); | 1784 __ IntegerDivide(R0, R0, R1, D0, D1); |
1945 } | 1785 } |
1946 __ bx(LR); | 1786 __ bx(LR); |
1947 #endif | 1787 #endif |
1948 } | 1788 } |
1949 | 1789 |
1950 | |
1951 ASSEMBLER_TEST_RUN(IntDiv_supported, test) { | 1790 ASSEMBLER_TEST_RUN(IntDiv_supported, test) { |
1952 EXPECT(test != NULL); | 1791 EXPECT(test != NULL); |
1953 #if defined(USING_SIMULATOR) | 1792 #if defined(USING_SIMULATOR) |
1954 bool orig = TargetCPUFeatures::integer_division_supported(); | 1793 bool orig = TargetCPUFeatures::integer_division_supported(); |
1955 HostCPUFeatures::set_integer_division_supported(true); | 1794 HostCPUFeatures::set_integer_division_supported(true); |
1956 if (TargetCPUFeatures::can_divide()) { | 1795 if (TargetCPUFeatures::can_divide()) { |
1957 typedef int (*Tst)() DART_UNUSED; | 1796 typedef int (*Tst)() DART_UNUSED; |
1958 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1797 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1959 } | 1798 } |
1960 HostCPUFeatures::set_integer_division_supported(orig); | 1799 HostCPUFeatures::set_integer_division_supported(orig); |
1961 #else | 1800 #else |
1962 if (TargetCPUFeatures::can_divide()) { | 1801 if (TargetCPUFeatures::can_divide()) { |
1963 typedef int (*Tst)() DART_UNUSED; | 1802 typedef int (*Tst)() DART_UNUSED; |
1964 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1803 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
1965 } | 1804 } |
1966 #endif | 1805 #endif |
1967 } | 1806 } |
1968 | 1807 |
1969 | |
1970 ASSEMBLER_TEST_GENERATE(IntDiv_unsupported, assembler) { | 1808 ASSEMBLER_TEST_GENERATE(IntDiv_unsupported, assembler) { |
1971 #if defined(USING_SIMULATOR) | 1809 #if defined(USING_SIMULATOR) |
1972 if (TargetCPUFeatures::can_divide()) { | 1810 if (TargetCPUFeatures::can_divide()) { |
1973 bool orig = TargetCPUFeatures::integer_division_supported(); | 1811 bool orig = TargetCPUFeatures::integer_division_supported(); |
1974 HostCPUFeatures::set_integer_division_supported(false); | 1812 HostCPUFeatures::set_integer_division_supported(false); |
1975 __ mov(R0, Operand(27)); | 1813 __ mov(R0, Operand(27)); |
1976 __ mov(R1, Operand(9)); | 1814 __ mov(R1, Operand(9)); |
1977 __ IntegerDivide(R0, R0, R1, D0, D1); | 1815 __ IntegerDivide(R0, R0, R1, D0, D1); |
1978 HostCPUFeatures::set_integer_division_supported(orig); | 1816 HostCPUFeatures::set_integer_division_supported(orig); |
1979 } | 1817 } |
1980 __ bx(LR); | 1818 __ bx(LR); |
1981 #else | 1819 #else |
1982 if (TargetCPUFeatures::can_divide()) { | 1820 if (TargetCPUFeatures::can_divide()) { |
1983 __ mov(R0, Operand(27)); | 1821 __ mov(R0, Operand(27)); |
1984 __ mov(R1, Operand(9)); | 1822 __ mov(R1, Operand(9)); |
1985 __ IntegerDivide(R0, R0, R1, D0, D1); | 1823 __ IntegerDivide(R0, R0, R1, D0, D1); |
1986 } | 1824 } |
1987 __ bx(LR); | 1825 __ bx(LR); |
1988 #endif | 1826 #endif |
1989 } | 1827 } |
1990 | 1828 |
1991 | |
1992 ASSEMBLER_TEST_RUN(IntDiv_unsupported, test) { | 1829 ASSEMBLER_TEST_RUN(IntDiv_unsupported, test) { |
1993 EXPECT(test != NULL); | 1830 EXPECT(test != NULL); |
1994 #if defined(USING_SIMULATOR) | 1831 #if defined(USING_SIMULATOR) |
1995 bool orig = TargetCPUFeatures::integer_division_supported(); | 1832 bool orig = TargetCPUFeatures::integer_division_supported(); |
1996 HostCPUFeatures::set_integer_division_supported(false); | 1833 HostCPUFeatures::set_integer_division_supported(false); |
1997 if (TargetCPUFeatures::can_divide()) { | 1834 if (TargetCPUFeatures::can_divide()) { |
1998 typedef int (*Tst)() DART_UNUSED; | 1835 typedef int (*Tst)() DART_UNUSED; |
1999 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1836 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2000 } | 1837 } |
2001 HostCPUFeatures::set_integer_division_supported(orig); | 1838 HostCPUFeatures::set_integer_division_supported(orig); |
2002 #else | 1839 #else |
2003 if (TargetCPUFeatures::can_divide()) { | 1840 if (TargetCPUFeatures::can_divide()) { |
2004 typedef int (*Tst)() DART_UNUSED; | 1841 typedef int (*Tst)() DART_UNUSED; |
2005 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1842 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2006 } | 1843 } |
2007 #endif | 1844 #endif |
2008 } | 1845 } |
2009 | 1846 |
2010 | |
2011 ASSEMBLER_TEST_GENERATE(Muls, assembler) { | 1847 ASSEMBLER_TEST_GENERATE(Muls, assembler) { |
2012 __ mov(R0, Operand(3)); | 1848 __ mov(R0, Operand(3)); |
2013 __ LoadImmediate(R1, -9); | 1849 __ LoadImmediate(R1, -9); |
2014 __ muls(R2, R0, R1); | 1850 __ muls(R2, R0, R1); |
2015 __ mov(R0, Operand(42), MI); | 1851 __ mov(R0, Operand(42), MI); |
2016 __ bx(LR); | 1852 __ bx(LR); |
2017 } | 1853 } |
2018 | 1854 |
2019 | |
2020 ASSEMBLER_TEST_RUN(Muls, test) { | 1855 ASSEMBLER_TEST_RUN(Muls, test) { |
2021 EXPECT(test != NULL); | 1856 EXPECT(test != NULL); |
2022 typedef int (*Tst)() DART_UNUSED; | 1857 typedef int (*Tst)() DART_UNUSED; |
2023 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1858 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2024 } | 1859 } |
2025 | 1860 |
2026 | |
2027 ASSEMBLER_TEST_GENERATE(Vaddqi8, assembler) { | 1861 ASSEMBLER_TEST_GENERATE(Vaddqi8, assembler) { |
2028 if (TargetCPUFeatures::neon_supported()) { | 1862 if (TargetCPUFeatures::neon_supported()) { |
2029 __ mov(R0, Operand(1)); | 1863 __ mov(R0, Operand(1)); |
2030 __ vmovsr(S0, R0); | 1864 __ vmovsr(S0, R0); |
2031 __ mov(R0, Operand(2)); | 1865 __ mov(R0, Operand(2)); |
2032 __ vmovsr(S1, R0); | 1866 __ vmovsr(S1, R0); |
2033 __ mov(R0, Operand(3)); | 1867 __ mov(R0, Operand(3)); |
2034 __ vmovsr(S2, R0); | 1868 __ vmovsr(S2, R0); |
2035 __ mov(R0, Operand(4)); | 1869 __ mov(R0, Operand(4)); |
2036 __ vmovsr(S3, R0); | 1870 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2050 __ vmovrs(R2, S10); | 1884 __ vmovrs(R2, S10); |
2051 __ vmovrs(R3, S11); | 1885 __ vmovrs(R3, S11); |
2052 | 1886 |
2053 __ add(R0, R0, Operand(R1)); | 1887 __ add(R0, R0, Operand(R1)); |
2054 __ add(R0, R0, Operand(R2)); | 1888 __ add(R0, R0, Operand(R2)); |
2055 __ add(R0, R0, Operand(R3)); | 1889 __ add(R0, R0, Operand(R3)); |
2056 } | 1890 } |
2057 __ bx(LR); | 1891 __ bx(LR); |
2058 } | 1892 } |
2059 | 1893 |
2060 | |
2061 ASSEMBLER_TEST_RUN(Vaddqi8, test) { | 1894 ASSEMBLER_TEST_RUN(Vaddqi8, test) { |
2062 EXPECT(test != NULL); | 1895 EXPECT(test != NULL); |
2063 if (TargetCPUFeatures::neon_supported()) { | 1896 if (TargetCPUFeatures::neon_supported()) { |
2064 typedef int (*Tst)() DART_UNUSED; | 1897 typedef int (*Tst)() DART_UNUSED; |
2065 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1898 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2066 } | 1899 } |
2067 } | 1900 } |
2068 | 1901 |
2069 | |
2070 ASSEMBLER_TEST_GENERATE(Vaddqi16, assembler) { | 1902 ASSEMBLER_TEST_GENERATE(Vaddqi16, assembler) { |
2071 if (TargetCPUFeatures::neon_supported()) { | 1903 if (TargetCPUFeatures::neon_supported()) { |
2072 __ mov(R0, Operand(1)); | 1904 __ mov(R0, Operand(1)); |
2073 __ vmovsr(S0, R0); | 1905 __ vmovsr(S0, R0); |
2074 __ mov(R0, Operand(2)); | 1906 __ mov(R0, Operand(2)); |
2075 __ vmovsr(S1, R0); | 1907 __ vmovsr(S1, R0); |
2076 __ mov(R0, Operand(3)); | 1908 __ mov(R0, Operand(3)); |
2077 __ vmovsr(S2, R0); | 1909 __ vmovsr(S2, R0); |
2078 __ mov(R0, Operand(4)); | 1910 __ mov(R0, Operand(4)); |
2079 __ vmovsr(S3, R0); | 1911 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2093 __ vmovrs(R2, S10); | 1925 __ vmovrs(R2, S10); |
2094 __ vmovrs(R3, S11); | 1926 __ vmovrs(R3, S11); |
2095 | 1927 |
2096 __ add(R0, R0, Operand(R1)); | 1928 __ add(R0, R0, Operand(R1)); |
2097 __ add(R0, R0, Operand(R2)); | 1929 __ add(R0, R0, Operand(R2)); |
2098 __ add(R0, R0, Operand(R3)); | 1930 __ add(R0, R0, Operand(R3)); |
2099 } | 1931 } |
2100 __ bx(LR); | 1932 __ bx(LR); |
2101 } | 1933 } |
2102 | 1934 |
2103 | |
2104 ASSEMBLER_TEST_RUN(Vaddqi16, test) { | 1935 ASSEMBLER_TEST_RUN(Vaddqi16, test) { |
2105 EXPECT(test != NULL); | 1936 EXPECT(test != NULL); |
2106 if (TargetCPUFeatures::neon_supported()) { | 1937 if (TargetCPUFeatures::neon_supported()) { |
2107 typedef int (*Tst)() DART_UNUSED; | 1938 typedef int (*Tst)() DART_UNUSED; |
2108 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1939 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2109 } | 1940 } |
2110 } | 1941 } |
2111 | 1942 |
2112 | |
2113 ASSEMBLER_TEST_GENERATE(Vaddqi32, assembler) { | 1943 ASSEMBLER_TEST_GENERATE(Vaddqi32, assembler) { |
2114 if (TargetCPUFeatures::neon_supported()) { | 1944 if (TargetCPUFeatures::neon_supported()) { |
2115 __ mov(R0, Operand(1)); | 1945 __ mov(R0, Operand(1)); |
2116 __ vmovsr(S0, R0); | 1946 __ vmovsr(S0, R0); |
2117 __ mov(R0, Operand(2)); | 1947 __ mov(R0, Operand(2)); |
2118 __ vmovsr(S1, R0); | 1948 __ vmovsr(S1, R0); |
2119 __ mov(R0, Operand(3)); | 1949 __ mov(R0, Operand(3)); |
2120 __ vmovsr(S2, R0); | 1950 __ vmovsr(S2, R0); |
2121 __ mov(R0, Operand(4)); | 1951 __ mov(R0, Operand(4)); |
2122 __ vmovsr(S3, R0); | 1952 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2136 __ vmovrs(R2, S10); | 1966 __ vmovrs(R2, S10); |
2137 __ vmovrs(R3, S11); | 1967 __ vmovrs(R3, S11); |
2138 | 1968 |
2139 __ add(R0, R0, Operand(R1)); | 1969 __ add(R0, R0, Operand(R1)); |
2140 __ add(R0, R0, Operand(R2)); | 1970 __ add(R0, R0, Operand(R2)); |
2141 __ add(R0, R0, Operand(R3)); | 1971 __ add(R0, R0, Operand(R3)); |
2142 } | 1972 } |
2143 __ bx(LR); | 1973 __ bx(LR); |
2144 } | 1974 } |
2145 | 1975 |
2146 | |
2147 ASSEMBLER_TEST_RUN(Vaddqi32, test) { | 1976 ASSEMBLER_TEST_RUN(Vaddqi32, test) { |
2148 EXPECT(test != NULL); | 1977 EXPECT(test != NULL); |
2149 if (TargetCPUFeatures::neon_supported()) { | 1978 if (TargetCPUFeatures::neon_supported()) { |
2150 typedef int (*Tst)() DART_UNUSED; | 1979 typedef int (*Tst)() DART_UNUSED; |
2151 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 1980 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2152 } | 1981 } |
2153 } | 1982 } |
2154 | 1983 |
2155 | |
2156 ASSEMBLER_TEST_GENERATE(Vaddqi64, assembler) { | 1984 ASSEMBLER_TEST_GENERATE(Vaddqi64, assembler) { |
2157 if (TargetCPUFeatures::neon_supported()) { | 1985 if (TargetCPUFeatures::neon_supported()) { |
2158 __ mov(R0, Operand(1)); | 1986 __ mov(R0, Operand(1)); |
2159 __ vmovsr(S0, R0); | 1987 __ vmovsr(S0, R0); |
2160 __ mov(R0, Operand(2)); | 1988 __ mov(R0, Operand(2)); |
2161 __ vmovsr(S2, R0); | 1989 __ vmovsr(S2, R0); |
2162 __ mov(R0, Operand(3)); | 1990 __ mov(R0, Operand(3)); |
2163 __ vmovsr(S4, R0); | 1991 __ vmovsr(S4, R0); |
2164 __ mov(R0, Operand(4)); | 1992 __ mov(R0, Operand(4)); |
2165 __ vmovsr(S6, R0); | 1993 __ vmovsr(S6, R0); |
2166 | 1994 |
2167 __ vaddqi(kWordPair, Q2, Q0, Q1); | 1995 __ vaddqi(kWordPair, Q2, Q0, Q1); |
2168 | 1996 |
2169 __ vmovrs(R0, S8); | 1997 __ vmovrs(R0, S8); |
2170 __ vmovrs(R2, S10); | 1998 __ vmovrs(R2, S10); |
2171 | 1999 |
2172 __ add(R0, R0, Operand(R2)); | 2000 __ add(R0, R0, Operand(R2)); |
2173 } | 2001 } |
2174 __ bx(LR); | 2002 __ bx(LR); |
2175 } | 2003 } |
2176 | 2004 |
2177 | |
2178 ASSEMBLER_TEST_RUN(Vaddqi64, test) { | 2005 ASSEMBLER_TEST_RUN(Vaddqi64, test) { |
2179 EXPECT(test != NULL); | 2006 EXPECT(test != NULL); |
2180 if (TargetCPUFeatures::neon_supported()) { | 2007 if (TargetCPUFeatures::neon_supported()) { |
2181 typedef int (*Tst)() DART_UNUSED; | 2008 typedef int (*Tst)() DART_UNUSED; |
2182 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2009 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2183 } | 2010 } |
2184 } | 2011 } |
2185 | 2012 |
2186 | |
2187 ASSEMBLER_TEST_GENERATE(Vshlqu64, assembler) { | 2013 ASSEMBLER_TEST_GENERATE(Vshlqu64, assembler) { |
2188 if (TargetCPUFeatures::neon_supported()) { | 2014 if (TargetCPUFeatures::neon_supported()) { |
2189 Label fail; | 2015 Label fail; |
2190 __ LoadImmediate(R1, 21); | 2016 __ LoadImmediate(R1, 21); |
2191 __ LoadImmediate(R0, 1); | 2017 __ LoadImmediate(R0, 1); |
2192 __ vmovsr(S0, R1); | 2018 __ vmovsr(S0, R1); |
2193 __ vmovsr(S2, R1); | 2019 __ vmovsr(S2, R1); |
2194 __ vmovsr(S4, R0); | 2020 __ vmovsr(S4, R0); |
2195 __ vmovsr(S6, R0); | 2021 __ vmovsr(S6, R0); |
2196 | 2022 |
2197 __ vshlqu(kWordPair, Q2, Q0, Q1); | 2023 __ vshlqu(kWordPair, Q2, Q0, Q1); |
2198 | 2024 |
2199 __ vmovrs(R0, S8); | 2025 __ vmovrs(R0, S8); |
2200 __ vmovrs(R1, S10); | 2026 __ vmovrs(R1, S10); |
2201 __ CompareImmediate(R0, 42); | 2027 __ CompareImmediate(R0, 42); |
2202 __ LoadImmediate(R0, 0); | 2028 __ LoadImmediate(R0, 0); |
2203 __ b(&fail, NE); | 2029 __ b(&fail, NE); |
2204 __ CompareImmediate(R1, 42); | 2030 __ CompareImmediate(R1, 42); |
2205 __ LoadImmediate(R0, 0); | 2031 __ LoadImmediate(R0, 0); |
2206 __ b(&fail, NE); | 2032 __ b(&fail, NE); |
2207 | 2033 |
2208 __ LoadImmediate(R0, 1); | 2034 __ LoadImmediate(R0, 1); |
2209 __ Bind(&fail); | 2035 __ Bind(&fail); |
2210 } | 2036 } |
2211 __ bx(LR); | 2037 __ bx(LR); |
2212 } | 2038 } |
2213 | 2039 |
2214 | |
2215 ASSEMBLER_TEST_RUN(Vshlqu64, test) { | 2040 ASSEMBLER_TEST_RUN(Vshlqu64, test) { |
2216 EXPECT(test != NULL); | 2041 EXPECT(test != NULL); |
2217 if (TargetCPUFeatures::neon_supported()) { | 2042 if (TargetCPUFeatures::neon_supported()) { |
2218 typedef int (*Tst)() DART_UNUSED; | 2043 typedef int (*Tst)() DART_UNUSED; |
2219 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2044 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2220 } | 2045 } |
2221 } | 2046 } |
2222 | 2047 |
2223 | |
2224 ASSEMBLER_TEST_GENERATE(Vshlqi64, assembler) { | 2048 ASSEMBLER_TEST_GENERATE(Vshlqi64, assembler) { |
2225 if (TargetCPUFeatures::neon_supported()) { | 2049 if (TargetCPUFeatures::neon_supported()) { |
2226 Label fail; | 2050 Label fail; |
2227 __ LoadImmediate(R1, -84); | 2051 __ LoadImmediate(R1, -84); |
2228 __ LoadImmediate(R0, -1); | 2052 __ LoadImmediate(R0, -1); |
2229 __ vmovdrr(D0, R1, R0); | 2053 __ vmovdrr(D0, R1, R0); |
2230 __ vmovdrr(D1, R1, R0); | 2054 __ vmovdrr(D1, R1, R0); |
2231 __ vmovsr(S4, R0); | 2055 __ vmovsr(S4, R0); |
2232 __ vmovsr(S6, R0); | 2056 __ vmovsr(S6, R0); |
2233 | 2057 |
2234 __ vshlqi(kWordPair, Q2, Q0, Q1); | 2058 __ vshlqi(kWordPair, Q2, Q0, Q1); |
2235 | 2059 |
2236 __ vmovrs(R0, S8); | 2060 __ vmovrs(R0, S8); |
2237 __ vmovrs(R1, S10); | 2061 __ vmovrs(R1, S10); |
2238 __ CompareImmediate(R0, -42); | 2062 __ CompareImmediate(R0, -42); |
2239 __ LoadImmediate(R0, 0); | 2063 __ LoadImmediate(R0, 0); |
2240 __ b(&fail, NE); | 2064 __ b(&fail, NE); |
2241 __ CompareImmediate(R1, -42); | 2065 __ CompareImmediate(R1, -42); |
2242 __ LoadImmediate(R0, 0); | 2066 __ LoadImmediate(R0, 0); |
2243 __ b(&fail, NE); | 2067 __ b(&fail, NE); |
2244 | 2068 |
2245 __ LoadImmediate(R0, 1); | 2069 __ LoadImmediate(R0, 1); |
2246 __ Bind(&fail); | 2070 __ Bind(&fail); |
2247 } | 2071 } |
2248 __ bx(LR); | 2072 __ bx(LR); |
2249 } | 2073 } |
2250 | 2074 |
2251 | |
2252 ASSEMBLER_TEST_RUN(Vshlqi64, test) { | 2075 ASSEMBLER_TEST_RUN(Vshlqi64, test) { |
2253 EXPECT(test != NULL); | 2076 EXPECT(test != NULL); |
2254 if (TargetCPUFeatures::neon_supported()) { | 2077 if (TargetCPUFeatures::neon_supported()) { |
2255 typedef int (*Tst)() DART_UNUSED; | 2078 typedef int (*Tst)() DART_UNUSED; |
2256 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2079 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2257 } | 2080 } |
2258 } | 2081 } |
2259 | 2082 |
2260 | |
2261 ASSEMBLER_TEST_GENERATE(Mint_shl_ok, assembler) { | 2083 ASSEMBLER_TEST_GENERATE(Mint_shl_ok, assembler) { |
2262 if (TargetCPUFeatures::neon_supported()) { | 2084 if (TargetCPUFeatures::neon_supported()) { |
2263 const QRegister value = Q0; | 2085 const QRegister value = Q0; |
2264 const QRegister temp = Q1; | 2086 const QRegister temp = Q1; |
2265 const QRegister out = Q2; | 2087 const QRegister out = Q2; |
2266 const Register shift = R1; | 2088 const Register shift = R1; |
2267 const DRegister dtemp0 = EvenDRegisterOf(temp); | 2089 const DRegister dtemp0 = EvenDRegisterOf(temp); |
2268 const SRegister stemp0 = EvenSRegisterOf(dtemp0); | 2090 const SRegister stemp0 = EvenSRegisterOf(dtemp0); |
2269 const DRegister dout0 = EvenDRegisterOf(out); | 2091 const DRegister dout0 = EvenDRegisterOf(out); |
2270 const SRegister sout0 = EvenSRegisterOf(dout0); | 2092 const SRegister sout0 = EvenSRegisterOf(dout0); |
(...skipping 27 matching lines...) Expand all Loading... |
2298 | 2120 |
2299 __ LoadImmediate(R0, 1); | 2121 __ LoadImmediate(R0, 1); |
2300 __ bx(LR); | 2122 __ bx(LR); |
2301 | 2123 |
2302 __ Bind(&fail); | 2124 __ Bind(&fail); |
2303 __ LoadImmediate(R0, 0); | 2125 __ LoadImmediate(R0, 0); |
2304 } | 2126 } |
2305 __ bx(LR); | 2127 __ bx(LR); |
2306 } | 2128 } |
2307 | 2129 |
2308 | |
2309 ASSEMBLER_TEST_RUN(Mint_shl_ok, test) { | 2130 ASSEMBLER_TEST_RUN(Mint_shl_ok, test) { |
2310 EXPECT(test != NULL); | 2131 EXPECT(test != NULL); |
2311 if (TargetCPUFeatures::neon_supported()) { | 2132 if (TargetCPUFeatures::neon_supported()) { |
2312 typedef int (*Tst)() DART_UNUSED; | 2133 typedef int (*Tst)() DART_UNUSED; |
2313 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2134 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2314 } | 2135 } |
2315 } | 2136 } |
2316 | 2137 |
2317 | |
2318 ASSEMBLER_TEST_GENERATE(Mint_shl_overflow, assembler) { | 2138 ASSEMBLER_TEST_GENERATE(Mint_shl_overflow, assembler) { |
2319 if (TargetCPUFeatures::neon_supported()) { | 2139 if (TargetCPUFeatures::neon_supported()) { |
2320 const QRegister value = Q0; | 2140 const QRegister value = Q0; |
2321 const QRegister temp = Q1; | 2141 const QRegister temp = Q1; |
2322 const QRegister out = Q2; | 2142 const QRegister out = Q2; |
2323 const Register shift = R1; | 2143 const Register shift = R1; |
2324 const DRegister dtemp0 = EvenDRegisterOf(temp); | 2144 const DRegister dtemp0 = EvenDRegisterOf(temp); |
2325 const SRegister stemp0 = EvenSRegisterOf(dtemp0); | 2145 const SRegister stemp0 = EvenSRegisterOf(dtemp0); |
2326 const DRegister dout0 = EvenDRegisterOf(out); | 2146 const DRegister dout0 = EvenDRegisterOf(out); |
2327 const SRegister sout0 = EvenSRegisterOf(dout0); | 2147 const SRegister sout0 = EvenSRegisterOf(dout0); |
(...skipping 27 matching lines...) Expand all Loading... |
2355 | 2175 |
2356 __ LoadImmediate(R0, 0); | 2176 __ LoadImmediate(R0, 0); |
2357 __ bx(LR); | 2177 __ bx(LR); |
2358 | 2178 |
2359 __ Bind(&fail); | 2179 __ Bind(&fail); |
2360 __ LoadImmediate(R0, 1); | 2180 __ LoadImmediate(R0, 1); |
2361 } | 2181 } |
2362 __ bx(LR); | 2182 __ bx(LR); |
2363 } | 2183 } |
2364 | 2184 |
2365 | |
2366 ASSEMBLER_TEST_RUN(Mint_shl_overflow, test) { | 2185 ASSEMBLER_TEST_RUN(Mint_shl_overflow, test) { |
2367 EXPECT(test != NULL); | 2186 EXPECT(test != NULL); |
2368 if (TargetCPUFeatures::neon_supported()) { | 2187 if (TargetCPUFeatures::neon_supported()) { |
2369 typedef int (*Tst)() DART_UNUSED; | 2188 typedef int (*Tst)() DART_UNUSED; |
2370 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2189 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2371 } | 2190 } |
2372 } | 2191 } |
2373 | 2192 |
2374 | |
2375 ASSEMBLER_TEST_GENERATE(Vsubqi8, assembler) { | 2193 ASSEMBLER_TEST_GENERATE(Vsubqi8, assembler) { |
2376 if (TargetCPUFeatures::neon_supported()) { | 2194 if (TargetCPUFeatures::neon_supported()) { |
2377 __ mov(R0, Operand(1)); | 2195 __ mov(R0, Operand(1)); |
2378 __ vmovsr(S0, R0); | 2196 __ vmovsr(S0, R0); |
2379 __ mov(R0, Operand(2)); | 2197 __ mov(R0, Operand(2)); |
2380 __ vmovsr(S1, R0); | 2198 __ vmovsr(S1, R0); |
2381 __ mov(R0, Operand(3)); | 2199 __ mov(R0, Operand(3)); |
2382 __ vmovsr(S2, R0); | 2200 __ vmovsr(S2, R0); |
2383 __ mov(R0, Operand(4)); | 2201 __ mov(R0, Operand(4)); |
2384 __ vmovsr(S3, R0); | 2202 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2398 __ vmovrs(R2, S10); | 2216 __ vmovrs(R2, S10); |
2399 __ vmovrs(R3, S11); | 2217 __ vmovrs(R3, S11); |
2400 | 2218 |
2401 __ add(R0, R0, Operand(R1)); | 2219 __ add(R0, R0, Operand(R1)); |
2402 __ add(R0, R0, Operand(R2)); | 2220 __ add(R0, R0, Operand(R2)); |
2403 __ add(R0, R0, Operand(R3)); | 2221 __ add(R0, R0, Operand(R3)); |
2404 } | 2222 } |
2405 __ bx(LR); | 2223 __ bx(LR); |
2406 } | 2224 } |
2407 | 2225 |
2408 | |
2409 ASSEMBLER_TEST_RUN(Vsubqi8, test) { | 2226 ASSEMBLER_TEST_RUN(Vsubqi8, test) { |
2410 EXPECT(test != NULL); | 2227 EXPECT(test != NULL); |
2411 if (TargetCPUFeatures::neon_supported()) { | 2228 if (TargetCPUFeatures::neon_supported()) { |
2412 typedef int (*Tst)() DART_UNUSED; | 2229 typedef int (*Tst)() DART_UNUSED; |
2413 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2230 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2414 } | 2231 } |
2415 } | 2232 } |
2416 | 2233 |
2417 | |
2418 ASSEMBLER_TEST_GENERATE(Vsubqi16, assembler) { | 2234 ASSEMBLER_TEST_GENERATE(Vsubqi16, assembler) { |
2419 if (TargetCPUFeatures::neon_supported()) { | 2235 if (TargetCPUFeatures::neon_supported()) { |
2420 __ mov(R0, Operand(1)); | 2236 __ mov(R0, Operand(1)); |
2421 __ vmovsr(S0, R0); | 2237 __ vmovsr(S0, R0); |
2422 __ mov(R0, Operand(2)); | 2238 __ mov(R0, Operand(2)); |
2423 __ vmovsr(S1, R0); | 2239 __ vmovsr(S1, R0); |
2424 __ mov(R0, Operand(3)); | 2240 __ mov(R0, Operand(3)); |
2425 __ vmovsr(S2, R0); | 2241 __ vmovsr(S2, R0); |
2426 __ mov(R0, Operand(4)); | 2242 __ mov(R0, Operand(4)); |
2427 __ vmovsr(S3, R0); | 2243 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2441 __ vmovrs(R2, S10); | 2257 __ vmovrs(R2, S10); |
2442 __ vmovrs(R3, S11); | 2258 __ vmovrs(R3, S11); |
2443 | 2259 |
2444 __ add(R0, R0, Operand(R1)); | 2260 __ add(R0, R0, Operand(R1)); |
2445 __ add(R0, R0, Operand(R2)); | 2261 __ add(R0, R0, Operand(R2)); |
2446 __ add(R0, R0, Operand(R3)); | 2262 __ add(R0, R0, Operand(R3)); |
2447 } | 2263 } |
2448 __ bx(LR); | 2264 __ bx(LR); |
2449 } | 2265 } |
2450 | 2266 |
2451 | |
2452 ASSEMBLER_TEST_RUN(Vsubqi16, test) { | 2267 ASSEMBLER_TEST_RUN(Vsubqi16, test) { |
2453 EXPECT(test != NULL); | 2268 EXPECT(test != NULL); |
2454 if (TargetCPUFeatures::neon_supported()) { | 2269 if (TargetCPUFeatures::neon_supported()) { |
2455 typedef int (*Tst)() DART_UNUSED; | 2270 typedef int (*Tst)() DART_UNUSED; |
2456 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2271 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2457 } | 2272 } |
2458 } | 2273 } |
2459 | 2274 |
2460 | |
2461 ASSEMBLER_TEST_GENERATE(Vsubqi32, assembler) { | 2275 ASSEMBLER_TEST_GENERATE(Vsubqi32, assembler) { |
2462 if (TargetCPUFeatures::neon_supported()) { | 2276 if (TargetCPUFeatures::neon_supported()) { |
2463 __ mov(R0, Operand(1)); | 2277 __ mov(R0, Operand(1)); |
2464 __ vmovsr(S0, R0); | 2278 __ vmovsr(S0, R0); |
2465 __ mov(R0, Operand(2)); | 2279 __ mov(R0, Operand(2)); |
2466 __ vmovsr(S1, R0); | 2280 __ vmovsr(S1, R0); |
2467 __ mov(R0, Operand(3)); | 2281 __ mov(R0, Operand(3)); |
2468 __ vmovsr(S2, R0); | 2282 __ vmovsr(S2, R0); |
2469 __ mov(R0, Operand(4)); | 2283 __ mov(R0, Operand(4)); |
2470 __ vmovsr(S3, R0); | 2284 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2484 __ vmovrs(R2, S10); | 2298 __ vmovrs(R2, S10); |
2485 __ vmovrs(R3, S11); | 2299 __ vmovrs(R3, S11); |
2486 | 2300 |
2487 __ add(R0, R0, Operand(R1)); | 2301 __ add(R0, R0, Operand(R1)); |
2488 __ add(R0, R0, Operand(R2)); | 2302 __ add(R0, R0, Operand(R2)); |
2489 __ add(R0, R0, Operand(R3)); | 2303 __ add(R0, R0, Operand(R3)); |
2490 } | 2304 } |
2491 __ bx(LR); | 2305 __ bx(LR); |
2492 } | 2306 } |
2493 | 2307 |
2494 | |
2495 ASSEMBLER_TEST_RUN(Vsubqi32, test) { | 2308 ASSEMBLER_TEST_RUN(Vsubqi32, test) { |
2496 EXPECT(test != NULL); | 2309 EXPECT(test != NULL); |
2497 if (TargetCPUFeatures::neon_supported()) { | 2310 if (TargetCPUFeatures::neon_supported()) { |
2498 typedef int (*Tst)() DART_UNUSED; | 2311 typedef int (*Tst)() DART_UNUSED; |
2499 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2312 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2500 } | 2313 } |
2501 } | 2314 } |
2502 | 2315 |
2503 | |
2504 ASSEMBLER_TEST_GENERATE(Vsubqi64, assembler) { | 2316 ASSEMBLER_TEST_GENERATE(Vsubqi64, assembler) { |
2505 if (TargetCPUFeatures::neon_supported()) { | 2317 if (TargetCPUFeatures::neon_supported()) { |
2506 __ mov(R0, Operand(1)); | 2318 __ mov(R0, Operand(1)); |
2507 __ vmovsr(S0, R0); | 2319 __ vmovsr(S0, R0); |
2508 __ mov(R0, Operand(2)); | 2320 __ mov(R0, Operand(2)); |
2509 __ vmovsr(S2, R0); | 2321 __ vmovsr(S2, R0); |
2510 __ mov(R0, Operand(2)); | 2322 __ mov(R0, Operand(2)); |
2511 __ vmovsr(S4, R0); | 2323 __ vmovsr(S4, R0); |
2512 __ mov(R0, Operand(4)); | 2324 __ mov(R0, Operand(4)); |
2513 __ vmovsr(S6, R0); | 2325 __ vmovsr(S6, R0); |
2514 | 2326 |
2515 __ vsubqi(kWordPair, Q2, Q1, Q0); | 2327 __ vsubqi(kWordPair, Q2, Q1, Q0); |
2516 | 2328 |
2517 __ vmovrs(R0, S8); | 2329 __ vmovrs(R0, S8); |
2518 __ vmovrs(R2, S10); | 2330 __ vmovrs(R2, S10); |
2519 | 2331 |
2520 __ add(R0, R0, Operand(R2)); | 2332 __ add(R0, R0, Operand(R2)); |
2521 } | 2333 } |
2522 __ bx(LR); | 2334 __ bx(LR); |
2523 } | 2335 } |
2524 | 2336 |
2525 | |
2526 ASSEMBLER_TEST_RUN(Vsubqi64, test) { | 2337 ASSEMBLER_TEST_RUN(Vsubqi64, test) { |
2527 EXPECT(test != NULL); | 2338 EXPECT(test != NULL); |
2528 if (TargetCPUFeatures::neon_supported()) { | 2339 if (TargetCPUFeatures::neon_supported()) { |
2529 typedef int (*Tst)() DART_UNUSED; | 2340 typedef int (*Tst)() DART_UNUSED; |
2530 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2341 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2531 } | 2342 } |
2532 } | 2343 } |
2533 | 2344 |
2534 | |
2535 ASSEMBLER_TEST_GENERATE(Vmulqi8, assembler) { | 2345 ASSEMBLER_TEST_GENERATE(Vmulqi8, assembler) { |
2536 if (TargetCPUFeatures::neon_supported()) { | 2346 if (TargetCPUFeatures::neon_supported()) { |
2537 __ mov(R0, Operand(1)); | 2347 __ mov(R0, Operand(1)); |
2538 __ vmovsr(S0, R0); | 2348 __ vmovsr(S0, R0); |
2539 __ mov(R0, Operand(2)); | 2349 __ mov(R0, Operand(2)); |
2540 __ vmovsr(S1, R0); | 2350 __ vmovsr(S1, R0); |
2541 __ mov(R0, Operand(3)); | 2351 __ mov(R0, Operand(3)); |
2542 __ vmovsr(S2, R0); | 2352 __ vmovsr(S2, R0); |
2543 __ mov(R0, Operand(4)); | 2353 __ mov(R0, Operand(4)); |
2544 __ vmovsr(S3, R0); | 2354 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2558 __ vmovrs(R2, S10); | 2368 __ vmovrs(R2, S10); |
2559 __ vmovrs(R3, S11); | 2369 __ vmovrs(R3, S11); |
2560 | 2370 |
2561 __ add(R0, R0, Operand(R1)); | 2371 __ add(R0, R0, Operand(R1)); |
2562 __ add(R0, R0, Operand(R2)); | 2372 __ add(R0, R0, Operand(R2)); |
2563 __ add(R0, R0, Operand(R3)); | 2373 __ add(R0, R0, Operand(R3)); |
2564 } | 2374 } |
2565 __ bx(LR); | 2375 __ bx(LR); |
2566 } | 2376 } |
2567 | 2377 |
2568 | |
2569 ASSEMBLER_TEST_RUN(Vmulqi8, test) { | 2378 ASSEMBLER_TEST_RUN(Vmulqi8, test) { |
2570 EXPECT(test != NULL); | 2379 EXPECT(test != NULL); |
2571 if (TargetCPUFeatures::neon_supported()) { | 2380 if (TargetCPUFeatures::neon_supported()) { |
2572 typedef int (*Tst)() DART_UNUSED; | 2381 typedef int (*Tst)() DART_UNUSED; |
2573 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2382 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2574 } | 2383 } |
2575 } | 2384 } |
2576 | 2385 |
2577 | |
2578 ASSEMBLER_TEST_GENERATE(Vmulqi16, assembler) { | 2386 ASSEMBLER_TEST_GENERATE(Vmulqi16, assembler) { |
2579 if (TargetCPUFeatures::neon_supported()) { | 2387 if (TargetCPUFeatures::neon_supported()) { |
2580 __ mov(R0, Operand(1)); | 2388 __ mov(R0, Operand(1)); |
2581 __ vmovsr(S0, R0); | 2389 __ vmovsr(S0, R0); |
2582 __ mov(R0, Operand(2)); | 2390 __ mov(R0, Operand(2)); |
2583 __ vmovsr(S1, R0); | 2391 __ vmovsr(S1, R0); |
2584 __ mov(R0, Operand(3)); | 2392 __ mov(R0, Operand(3)); |
2585 __ vmovsr(S2, R0); | 2393 __ vmovsr(S2, R0); |
2586 __ mov(R0, Operand(4)); | 2394 __ mov(R0, Operand(4)); |
2587 __ vmovsr(S3, R0); | 2395 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2601 __ vmovrs(R2, S10); | 2409 __ vmovrs(R2, S10); |
2602 __ vmovrs(R3, S11); | 2410 __ vmovrs(R3, S11); |
2603 | 2411 |
2604 __ add(R0, R0, Operand(R1)); | 2412 __ add(R0, R0, Operand(R1)); |
2605 __ add(R0, R0, Operand(R2)); | 2413 __ add(R0, R0, Operand(R2)); |
2606 __ add(R0, R0, Operand(R3)); | 2414 __ add(R0, R0, Operand(R3)); |
2607 } | 2415 } |
2608 __ bx(LR); | 2416 __ bx(LR); |
2609 } | 2417 } |
2610 | 2418 |
2611 | |
2612 ASSEMBLER_TEST_RUN(Vmulqi16, test) { | 2419 ASSEMBLER_TEST_RUN(Vmulqi16, test) { |
2613 EXPECT(test != NULL); | 2420 EXPECT(test != NULL); |
2614 if (TargetCPUFeatures::neon_supported()) { | 2421 if (TargetCPUFeatures::neon_supported()) { |
2615 typedef int (*Tst)() DART_UNUSED; | 2422 typedef int (*Tst)() DART_UNUSED; |
2616 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2423 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2617 } | 2424 } |
2618 } | 2425 } |
2619 | 2426 |
2620 | |
2621 ASSEMBLER_TEST_GENERATE(Vmulqi32, assembler) { | 2427 ASSEMBLER_TEST_GENERATE(Vmulqi32, assembler) { |
2622 if (TargetCPUFeatures::neon_supported()) { | 2428 if (TargetCPUFeatures::neon_supported()) { |
2623 __ mov(R0, Operand(1)); | 2429 __ mov(R0, Operand(1)); |
2624 __ vmovsr(S0, R0); | 2430 __ vmovsr(S0, R0); |
2625 __ mov(R0, Operand(2)); | 2431 __ mov(R0, Operand(2)); |
2626 __ vmovsr(S1, R0); | 2432 __ vmovsr(S1, R0); |
2627 __ mov(R0, Operand(3)); | 2433 __ mov(R0, Operand(3)); |
2628 __ vmovsr(S2, R0); | 2434 __ vmovsr(S2, R0); |
2629 __ mov(R0, Operand(4)); | 2435 __ mov(R0, Operand(4)); |
2630 __ vmovsr(S3, R0); | 2436 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
2644 __ vmovrs(R2, S10); | 2450 __ vmovrs(R2, S10); |
2645 __ vmovrs(R3, S11); | 2451 __ vmovrs(R3, S11); |
2646 | 2452 |
2647 __ add(R0, R0, Operand(R1)); | 2453 __ add(R0, R0, Operand(R1)); |
2648 __ add(R0, R0, Operand(R2)); | 2454 __ add(R0, R0, Operand(R2)); |
2649 __ add(R0, R0, Operand(R3)); | 2455 __ add(R0, R0, Operand(R3)); |
2650 } | 2456 } |
2651 __ bx(LR); | 2457 __ bx(LR); |
2652 } | 2458 } |
2653 | 2459 |
2654 | |
2655 ASSEMBLER_TEST_RUN(Vmulqi32, test) { | 2460 ASSEMBLER_TEST_RUN(Vmulqi32, test) { |
2656 EXPECT(test != NULL); | 2461 EXPECT(test != NULL); |
2657 if (TargetCPUFeatures::neon_supported()) { | 2462 if (TargetCPUFeatures::neon_supported()) { |
2658 typedef int (*Tst)() DART_UNUSED; | 2463 typedef int (*Tst)() DART_UNUSED; |
2659 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2464 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2660 } | 2465 } |
2661 } | 2466 } |
2662 | 2467 |
2663 | |
2664 ASSEMBLER_TEST_GENERATE(Vaddqs, assembler) { | 2468 ASSEMBLER_TEST_GENERATE(Vaddqs, assembler) { |
2665 if (TargetCPUFeatures::neon_supported()) { | 2469 if (TargetCPUFeatures::neon_supported()) { |
2666 __ LoadSImmediate(S0, 1.0); | 2470 __ LoadSImmediate(S0, 1.0); |
2667 __ LoadSImmediate(S1, 2.0); | 2471 __ LoadSImmediate(S1, 2.0); |
2668 __ LoadSImmediate(S2, 3.0); | 2472 __ LoadSImmediate(S2, 3.0); |
2669 __ LoadSImmediate(S3, 4.0); | 2473 __ LoadSImmediate(S3, 4.0); |
2670 __ LoadSImmediate(S4, 5.0); | 2474 __ LoadSImmediate(S4, 5.0); |
2671 __ LoadSImmediate(S5, 6.0); | 2475 __ LoadSImmediate(S5, 6.0); |
2672 __ LoadSImmediate(S6, 7.0); | 2476 __ LoadSImmediate(S6, 7.0); |
2673 __ LoadSImmediate(S7, 8.0); | 2477 __ LoadSImmediate(S7, 8.0); |
2674 | 2478 |
2675 __ vaddqs(Q2, Q0, Q1); | 2479 __ vaddqs(Q2, Q0, Q1); |
2676 | 2480 |
2677 __ vadds(S8, S8, S9); | 2481 __ vadds(S8, S8, S9); |
2678 __ vadds(S8, S8, S10); | 2482 __ vadds(S8, S8, S10); |
2679 __ vadds(S8, S8, S11); | 2483 __ vadds(S8, S8, S11); |
2680 | 2484 |
2681 __ vcvtis(S0, S8); | 2485 __ vcvtis(S0, S8); |
2682 __ vmovrs(R0, S0); | 2486 __ vmovrs(R0, S0); |
2683 } | 2487 } |
2684 __ bx(LR); | 2488 __ bx(LR); |
2685 } | 2489 } |
2686 | 2490 |
2687 | |
2688 ASSEMBLER_TEST_RUN(Vaddqs, test) { | 2491 ASSEMBLER_TEST_RUN(Vaddqs, test) { |
2689 EXPECT(test != NULL); | 2492 EXPECT(test != NULL); |
2690 if (TargetCPUFeatures::neon_supported()) { | 2493 if (TargetCPUFeatures::neon_supported()) { |
2691 typedef int (*Tst)() DART_UNUSED; | 2494 typedef int (*Tst)() DART_UNUSED; |
2692 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2495 EXPECT_EQ(36, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2693 } | 2496 } |
2694 } | 2497 } |
2695 | 2498 |
2696 | |
2697 ASSEMBLER_TEST_GENERATE(Vsubqs, assembler) { | 2499 ASSEMBLER_TEST_GENERATE(Vsubqs, assembler) { |
2698 if (TargetCPUFeatures::neon_supported()) { | 2500 if (TargetCPUFeatures::neon_supported()) { |
2699 __ LoadSImmediate(S0, 1.0); | 2501 __ LoadSImmediate(S0, 1.0); |
2700 __ LoadSImmediate(S1, 2.0); | 2502 __ LoadSImmediate(S1, 2.0); |
2701 __ LoadSImmediate(S2, 3.0); | 2503 __ LoadSImmediate(S2, 3.0); |
2702 __ LoadSImmediate(S3, 4.0); | 2504 __ LoadSImmediate(S3, 4.0); |
2703 __ LoadSImmediate(S4, 2.0); | 2505 __ LoadSImmediate(S4, 2.0); |
2704 __ LoadSImmediate(S5, 4.0); | 2506 __ LoadSImmediate(S5, 4.0); |
2705 __ LoadSImmediate(S6, 6.0); | 2507 __ LoadSImmediate(S6, 6.0); |
2706 __ LoadSImmediate(S7, 8.0); | 2508 __ LoadSImmediate(S7, 8.0); |
2707 | 2509 |
2708 __ vsubqs(Q2, Q1, Q0); | 2510 __ vsubqs(Q2, Q1, Q0); |
2709 | 2511 |
2710 __ vadds(S8, S8, S9); | 2512 __ vadds(S8, S8, S9); |
2711 __ vadds(S8, S8, S10); | 2513 __ vadds(S8, S8, S10); |
2712 __ vadds(S8, S8, S11); | 2514 __ vadds(S8, S8, S11); |
2713 | 2515 |
2714 __ vcvtis(S0, S8); | 2516 __ vcvtis(S0, S8); |
2715 __ vmovrs(R0, S0); | 2517 __ vmovrs(R0, S0); |
2716 } | 2518 } |
2717 __ bx(LR); | 2519 __ bx(LR); |
2718 } | 2520 } |
2719 | 2521 |
2720 | |
2721 ASSEMBLER_TEST_RUN(Vsubqs, test) { | 2522 ASSEMBLER_TEST_RUN(Vsubqs, test) { |
2722 EXPECT(test != NULL); | 2523 EXPECT(test != NULL); |
2723 if (TargetCPUFeatures::neon_supported()) { | 2524 if (TargetCPUFeatures::neon_supported()) { |
2724 typedef int (*Tst)() DART_UNUSED; | 2525 typedef int (*Tst)() DART_UNUSED; |
2725 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2526 EXPECT_EQ(10, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2726 } | 2527 } |
2727 } | 2528 } |
2728 | 2529 |
2729 | |
2730 ASSEMBLER_TEST_GENERATE(Vmulqs, assembler) { | 2530 ASSEMBLER_TEST_GENERATE(Vmulqs, assembler) { |
2731 if (TargetCPUFeatures::neon_supported()) { | 2531 if (TargetCPUFeatures::neon_supported()) { |
2732 __ LoadSImmediate(S0, 1.0); | 2532 __ LoadSImmediate(S0, 1.0); |
2733 __ LoadSImmediate(S1, 2.0); | 2533 __ LoadSImmediate(S1, 2.0); |
2734 __ LoadSImmediate(S2, 3.0); | 2534 __ LoadSImmediate(S2, 3.0); |
2735 __ LoadSImmediate(S3, 4.0); | 2535 __ LoadSImmediate(S3, 4.0); |
2736 __ LoadSImmediate(S4, 5.0); | 2536 __ LoadSImmediate(S4, 5.0); |
2737 __ LoadSImmediate(S5, 6.0); | 2537 __ LoadSImmediate(S5, 6.0); |
2738 __ LoadSImmediate(S6, 7.0); | 2538 __ LoadSImmediate(S6, 7.0); |
2739 __ LoadSImmediate(S7, 8.0); | 2539 __ LoadSImmediate(S7, 8.0); |
2740 | 2540 |
2741 __ vmulqs(Q2, Q1, Q0); | 2541 __ vmulqs(Q2, Q1, Q0); |
2742 | 2542 |
2743 __ vadds(S8, S8, S9); | 2543 __ vadds(S8, S8, S9); |
2744 __ vadds(S8, S8, S10); | 2544 __ vadds(S8, S8, S10); |
2745 __ vadds(S8, S8, S11); | 2545 __ vadds(S8, S8, S11); |
2746 | 2546 |
2747 __ vcvtis(S0, S8); | 2547 __ vcvtis(S0, S8); |
2748 __ vmovrs(R0, S0); | 2548 __ vmovrs(R0, S0); |
2749 } | 2549 } |
2750 __ bx(LR); | 2550 __ bx(LR); |
2751 } | 2551 } |
2752 | 2552 |
2753 | |
2754 ASSEMBLER_TEST_RUN(Vmulqs, test) { | 2553 ASSEMBLER_TEST_RUN(Vmulqs, test) { |
2755 EXPECT(test != NULL); | 2554 EXPECT(test != NULL); |
2756 if (TargetCPUFeatures::neon_supported()) { | 2555 if (TargetCPUFeatures::neon_supported()) { |
2757 typedef int (*Tst)() DART_UNUSED; | 2556 typedef int (*Tst)() DART_UNUSED; |
2758 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2557 EXPECT_EQ(70, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2759 } | 2558 } |
2760 } | 2559 } |
2761 | 2560 |
2762 | |
2763 ASSEMBLER_TEST_GENERATE(VtblX, assembler) { | 2561 ASSEMBLER_TEST_GENERATE(VtblX, assembler) { |
2764 if (TargetCPUFeatures::neon_supported()) { | 2562 if (TargetCPUFeatures::neon_supported()) { |
2765 // Index. | 2563 // Index. |
2766 __ LoadImmediate(R0, 0x03020100); | 2564 __ LoadImmediate(R0, 0x03020100); |
2767 __ vmovsr(S0, R0); | 2565 __ vmovsr(S0, R0); |
2768 __ vmovsr(S1, R0); | 2566 __ vmovsr(S1, R0); |
2769 | 2567 |
2770 // Table. | 2568 // Table. |
2771 __ LoadSImmediate(S2, 1.0); | 2569 __ LoadSImmediate(S2, 1.0); |
2772 __ LoadSImmediate(S3, 2.0); | 2570 __ LoadSImmediate(S3, 2.0); |
(...skipping 12 matching lines...) Expand all Loading... |
2785 __ LoadImmediate(R0, 0); | 2583 __ LoadImmediate(R0, 0); |
2786 __ CompareImmediate(R2, 1); | 2584 __ CompareImmediate(R2, 1); |
2787 __ bx(LR, NE); | 2585 __ bx(LR, NE); |
2788 __ CompareImmediate(R3, 1); | 2586 __ CompareImmediate(R3, 1); |
2789 __ bx(LR, NE); | 2587 __ bx(LR, NE); |
2790 __ LoadImmediate(R0, 42); | 2588 __ LoadImmediate(R0, 42); |
2791 } | 2589 } |
2792 __ bx(LR); | 2590 __ bx(LR); |
2793 } | 2591 } |
2794 | 2592 |
2795 | |
2796 ASSEMBLER_TEST_RUN(VtblX, test) { | 2593 ASSEMBLER_TEST_RUN(VtblX, test) { |
2797 EXPECT(test != NULL); | 2594 EXPECT(test != NULL); |
2798 if (TargetCPUFeatures::neon_supported()) { | 2595 if (TargetCPUFeatures::neon_supported()) { |
2799 typedef int (*Tst)() DART_UNUSED; | 2596 typedef int (*Tst)() DART_UNUSED; |
2800 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2597 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2801 } | 2598 } |
2802 } | 2599 } |
2803 | 2600 |
2804 | |
2805 ASSEMBLER_TEST_GENERATE(VtblY, assembler) { | 2601 ASSEMBLER_TEST_GENERATE(VtblY, assembler) { |
2806 if (TargetCPUFeatures::neon_supported()) { | 2602 if (TargetCPUFeatures::neon_supported()) { |
2807 // Index. | 2603 // Index. |
2808 __ LoadImmediate(R0, 0x07060504); | 2604 __ LoadImmediate(R0, 0x07060504); |
2809 __ vmovsr(S0, R0); | 2605 __ vmovsr(S0, R0); |
2810 __ vmovsr(S1, R0); | 2606 __ vmovsr(S1, R0); |
2811 | 2607 |
2812 // Table. | 2608 // Table. |
2813 __ LoadSImmediate(S2, 2.0); | 2609 __ LoadSImmediate(S2, 2.0); |
2814 __ LoadSImmediate(S3, 1.0); | 2610 __ LoadSImmediate(S3, 1.0); |
(...skipping 12 matching lines...) Expand all Loading... |
2827 __ LoadImmediate(R0, 0); | 2623 __ LoadImmediate(R0, 0); |
2828 __ CompareImmediate(R2, 1); | 2624 __ CompareImmediate(R2, 1); |
2829 __ bx(LR, NE); | 2625 __ bx(LR, NE); |
2830 __ CompareImmediate(R3, 1); | 2626 __ CompareImmediate(R3, 1); |
2831 __ bx(LR, NE); | 2627 __ bx(LR, NE); |
2832 __ LoadImmediate(R0, 42); | 2628 __ LoadImmediate(R0, 42); |
2833 } | 2629 } |
2834 __ bx(LR); | 2630 __ bx(LR); |
2835 } | 2631 } |
2836 | 2632 |
2837 | |
2838 ASSEMBLER_TEST_RUN(VtblY, test) { | 2633 ASSEMBLER_TEST_RUN(VtblY, test) { |
2839 EXPECT(test != NULL); | 2634 EXPECT(test != NULL); |
2840 if (TargetCPUFeatures::neon_supported()) { | 2635 if (TargetCPUFeatures::neon_supported()) { |
2841 typedef int (*Tst)() DART_UNUSED; | 2636 typedef int (*Tst)() DART_UNUSED; |
2842 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2637 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2843 } | 2638 } |
2844 } | 2639 } |
2845 | 2640 |
2846 | |
2847 ASSEMBLER_TEST_GENERATE(VtblZ, assembler) { | 2641 ASSEMBLER_TEST_GENERATE(VtblZ, assembler) { |
2848 if (TargetCPUFeatures::neon_supported()) { | 2642 if (TargetCPUFeatures::neon_supported()) { |
2849 // Index. | 2643 // Index. |
2850 __ LoadImmediate(R0, 0x0b0a0908); | 2644 __ LoadImmediate(R0, 0x0b0a0908); |
2851 __ vmovsr(S0, R0); | 2645 __ vmovsr(S0, R0); |
2852 __ vmovsr(S1, R0); | 2646 __ vmovsr(S1, R0); |
2853 | 2647 |
2854 // Table. | 2648 // Table. |
2855 __ LoadSImmediate(S2, 2.0); | 2649 __ LoadSImmediate(S2, 2.0); |
2856 __ LoadSImmediate(S3, 3.0); | 2650 __ LoadSImmediate(S3, 3.0); |
(...skipping 12 matching lines...) Expand all Loading... |
2869 __ LoadImmediate(R0, 0); | 2663 __ LoadImmediate(R0, 0); |
2870 __ CompareImmediate(R2, 1); | 2664 __ CompareImmediate(R2, 1); |
2871 __ bx(LR, NE); | 2665 __ bx(LR, NE); |
2872 __ CompareImmediate(R3, 1); | 2666 __ CompareImmediate(R3, 1); |
2873 __ bx(LR, NE); | 2667 __ bx(LR, NE); |
2874 __ LoadImmediate(R0, 42); | 2668 __ LoadImmediate(R0, 42); |
2875 } | 2669 } |
2876 __ bx(LR); | 2670 __ bx(LR); |
2877 } | 2671 } |
2878 | 2672 |
2879 | |
2880 ASSEMBLER_TEST_RUN(VtblZ, test) { | 2673 ASSEMBLER_TEST_RUN(VtblZ, test) { |
2881 EXPECT(test != NULL); | 2674 EXPECT(test != NULL); |
2882 if (TargetCPUFeatures::neon_supported()) { | 2675 if (TargetCPUFeatures::neon_supported()) { |
2883 typedef int (*Tst)() DART_UNUSED; | 2676 typedef int (*Tst)() DART_UNUSED; |
2884 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2677 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2885 } | 2678 } |
2886 } | 2679 } |
2887 | 2680 |
2888 | |
2889 ASSEMBLER_TEST_GENERATE(VtblW, assembler) { | 2681 ASSEMBLER_TEST_GENERATE(VtblW, assembler) { |
2890 if (TargetCPUFeatures::neon_supported()) { | 2682 if (TargetCPUFeatures::neon_supported()) { |
2891 // Index. | 2683 // Index. |
2892 __ LoadImmediate(R0, 0x0f0e0d0c); | 2684 __ LoadImmediate(R0, 0x0f0e0d0c); |
2893 __ vmovsr(S0, R0); | 2685 __ vmovsr(S0, R0); |
2894 __ vmovsr(S1, R0); | 2686 __ vmovsr(S1, R0); |
2895 | 2687 |
2896 // Table. | 2688 // Table. |
2897 __ LoadSImmediate(S2, 2.0); | 2689 __ LoadSImmediate(S2, 2.0); |
2898 __ LoadSImmediate(S3, 3.0); | 2690 __ LoadSImmediate(S3, 3.0); |
(...skipping 12 matching lines...) Expand all Loading... |
2911 __ LoadImmediate(R0, 0); | 2703 __ LoadImmediate(R0, 0); |
2912 __ CompareImmediate(R2, 1); | 2704 __ CompareImmediate(R2, 1); |
2913 __ bx(LR, NE); | 2705 __ bx(LR, NE); |
2914 __ CompareImmediate(R3, 1); | 2706 __ CompareImmediate(R3, 1); |
2915 __ bx(LR, NE); | 2707 __ bx(LR, NE); |
2916 __ LoadImmediate(R0, 42); | 2708 __ LoadImmediate(R0, 42); |
2917 } | 2709 } |
2918 __ bx(LR); | 2710 __ bx(LR); |
2919 } | 2711 } |
2920 | 2712 |
2921 | |
2922 ASSEMBLER_TEST_RUN(VtblW, test) { | 2713 ASSEMBLER_TEST_RUN(VtblW, test) { |
2923 EXPECT(test != NULL); | 2714 EXPECT(test != NULL); |
2924 if (TargetCPUFeatures::neon_supported()) { | 2715 if (TargetCPUFeatures::neon_supported()) { |
2925 typedef int (*Tst)() DART_UNUSED; | 2716 typedef int (*Tst)() DART_UNUSED; |
2926 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2717 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2927 } | 2718 } |
2928 } | 2719 } |
2929 | 2720 |
2930 | |
2931 ASSEMBLER_TEST_GENERATE(Veorq, assembler) { | 2721 ASSEMBLER_TEST_GENERATE(Veorq, assembler) { |
2932 if (TargetCPUFeatures::neon_supported()) { | 2722 if (TargetCPUFeatures::neon_supported()) { |
2933 // Q0 | 2723 // Q0 |
2934 __ LoadImmediate(R0, 0xaaaaaaab); | 2724 __ LoadImmediate(R0, 0xaaaaaaab); |
2935 __ vmovsr(S0, R0); | 2725 __ vmovsr(S0, R0); |
2936 __ vmovsr(S1, R0); | 2726 __ vmovsr(S1, R0); |
2937 __ vmovsr(S2, R0); | 2727 __ vmovsr(S2, R0); |
2938 __ vmovsr(S3, R0); | 2728 __ vmovsr(S3, R0); |
2939 | 2729 |
2940 // Q1 | 2730 // Q1 |
(...skipping 11 matching lines...) Expand all Loading... |
2952 __ vmovrs(R2, S10); | 2742 __ vmovrs(R2, S10); |
2953 __ vmovrs(R3, S11); | 2743 __ vmovrs(R3, S11); |
2954 | 2744 |
2955 __ add(R0, R0, Operand(R1)); | 2745 __ add(R0, R0, Operand(R1)); |
2956 __ add(R0, R0, Operand(R2)); | 2746 __ add(R0, R0, Operand(R2)); |
2957 __ add(R0, R0, Operand(R3)); | 2747 __ add(R0, R0, Operand(R3)); |
2958 } | 2748 } |
2959 __ bx(LR); | 2749 __ bx(LR); |
2960 } | 2750 } |
2961 | 2751 |
2962 | |
2963 ASSEMBLER_TEST_RUN(Veorq, test) { | 2752 ASSEMBLER_TEST_RUN(Veorq, test) { |
2964 EXPECT(test != NULL); | 2753 EXPECT(test != NULL); |
2965 if (TargetCPUFeatures::neon_supported()) { | 2754 if (TargetCPUFeatures::neon_supported()) { |
2966 typedef int (*Tst)() DART_UNUSED; | 2755 typedef int (*Tst)() DART_UNUSED; |
2967 EXPECT_EQ(-8, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2756 EXPECT_EQ(-8, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
2968 } | 2757 } |
2969 } | 2758 } |
2970 | 2759 |
2971 | |
2972 ASSEMBLER_TEST_GENERATE(Vornq, assembler) { | 2760 ASSEMBLER_TEST_GENERATE(Vornq, assembler) { |
2973 if (TargetCPUFeatures::neon_supported()) { | 2761 if (TargetCPUFeatures::neon_supported()) { |
2974 // Q0 | 2762 // Q0 |
2975 __ LoadImmediate(R0, 0xfffffff0); | 2763 __ LoadImmediate(R0, 0xfffffff0); |
2976 __ vmovsr(S0, R0); | 2764 __ vmovsr(S0, R0); |
2977 __ vmovsr(S1, R0); | 2765 __ vmovsr(S1, R0); |
2978 __ vmovsr(S2, R0); | 2766 __ vmovsr(S2, R0); |
2979 __ vmovsr(S3, R0); | 2767 __ vmovsr(S3, R0); |
2980 | 2768 |
2981 // Q1 | 2769 // Q1 |
(...skipping 11 matching lines...) Expand all Loading... |
2993 __ vmovrs(R2, S10); | 2781 __ vmovrs(R2, S10); |
2994 __ vmovrs(R3, S11); | 2782 __ vmovrs(R3, S11); |
2995 | 2783 |
2996 __ add(R0, R0, Operand(R1)); | 2784 __ add(R0, R0, Operand(R1)); |
2997 __ add(R0, R0, Operand(R2)); | 2785 __ add(R0, R0, Operand(R2)); |
2998 __ add(R0, R0, Operand(R3)); | 2786 __ add(R0, R0, Operand(R3)); |
2999 } | 2787 } |
3000 __ bx(LR); | 2788 __ bx(LR); |
3001 } | 2789 } |
3002 | 2790 |
3003 | |
3004 ASSEMBLER_TEST_RUN(Vornq, test) { | 2791 ASSEMBLER_TEST_RUN(Vornq, test) { |
3005 EXPECT(test != NULL); | 2792 EXPECT(test != NULL); |
3006 if (TargetCPUFeatures::neon_supported()) { | 2793 if (TargetCPUFeatures::neon_supported()) { |
3007 typedef int (*Tst)() DART_UNUSED; | 2794 typedef int (*Tst)() DART_UNUSED; |
3008 EXPECT_EQ(60, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2795 EXPECT_EQ(60, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3009 } | 2796 } |
3010 } | 2797 } |
3011 | 2798 |
3012 | |
3013 ASSEMBLER_TEST_GENERATE(Vorrq, assembler) { | 2799 ASSEMBLER_TEST_GENERATE(Vorrq, assembler) { |
3014 if (TargetCPUFeatures::neon_supported()) { | 2800 if (TargetCPUFeatures::neon_supported()) { |
3015 // Q0 | 2801 // Q0 |
3016 __ LoadImmediate(R0, 0xaaaaaaaa); | 2802 __ LoadImmediate(R0, 0xaaaaaaaa); |
3017 __ vmovsr(S0, R0); | 2803 __ vmovsr(S0, R0); |
3018 __ vmovsr(S1, R0); | 2804 __ vmovsr(S1, R0); |
3019 __ vmovsr(S2, R0); | 2805 __ vmovsr(S2, R0); |
3020 __ vmovsr(S3, R0); | 2806 __ vmovsr(S3, R0); |
3021 | 2807 |
3022 // Q1 | 2808 // Q1 |
(...skipping 11 matching lines...) Expand all Loading... |
3034 __ vmovrs(R2, S10); | 2820 __ vmovrs(R2, S10); |
3035 __ vmovrs(R3, S11); | 2821 __ vmovrs(R3, S11); |
3036 | 2822 |
3037 __ add(R0, R0, Operand(R1)); | 2823 __ add(R0, R0, Operand(R1)); |
3038 __ add(R0, R0, Operand(R2)); | 2824 __ add(R0, R0, Operand(R2)); |
3039 __ add(R0, R0, Operand(R3)); | 2825 __ add(R0, R0, Operand(R3)); |
3040 } | 2826 } |
3041 __ bx(LR); | 2827 __ bx(LR); |
3042 } | 2828 } |
3043 | 2829 |
3044 | |
3045 ASSEMBLER_TEST_RUN(Vorrq, test) { | 2830 ASSEMBLER_TEST_RUN(Vorrq, test) { |
3046 EXPECT(test != NULL); | 2831 EXPECT(test != NULL); |
3047 if (TargetCPUFeatures::neon_supported()) { | 2832 if (TargetCPUFeatures::neon_supported()) { |
3048 typedef int (*Tst)() DART_UNUSED; | 2833 typedef int (*Tst)() DART_UNUSED; |
3049 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2834 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3050 } | 2835 } |
3051 } | 2836 } |
3052 | 2837 |
3053 | |
3054 ASSEMBLER_TEST_GENERATE(Vandq, assembler) { | 2838 ASSEMBLER_TEST_GENERATE(Vandq, assembler) { |
3055 if (TargetCPUFeatures::neon_supported()) { | 2839 if (TargetCPUFeatures::neon_supported()) { |
3056 // Q0 | 2840 // Q0 |
3057 __ LoadImmediate(R0, 0xaaaaaaab); | 2841 __ LoadImmediate(R0, 0xaaaaaaab); |
3058 __ vmovsr(S0, R0); | 2842 __ vmovsr(S0, R0); |
3059 __ vmovsr(S1, R0); | 2843 __ vmovsr(S1, R0); |
3060 __ vmovsr(S2, R0); | 2844 __ vmovsr(S2, R0); |
3061 __ vmovsr(S3, R0); | 2845 __ vmovsr(S3, R0); |
3062 | 2846 |
3063 // Q1 | 2847 // Q1 |
(...skipping 11 matching lines...) Expand all Loading... |
3075 __ vmovrs(R2, S10); | 2859 __ vmovrs(R2, S10); |
3076 __ vmovrs(R3, S11); | 2860 __ vmovrs(R3, S11); |
3077 | 2861 |
3078 __ add(R0, R0, Operand(R1)); | 2862 __ add(R0, R0, Operand(R1)); |
3079 __ add(R0, R0, Operand(R2)); | 2863 __ add(R0, R0, Operand(R2)); |
3080 __ add(R0, R0, Operand(R3)); | 2864 __ add(R0, R0, Operand(R3)); |
3081 } | 2865 } |
3082 __ bx(LR); | 2866 __ bx(LR); |
3083 } | 2867 } |
3084 | 2868 |
3085 | |
3086 ASSEMBLER_TEST_RUN(Vandq, test) { | 2869 ASSEMBLER_TEST_RUN(Vandq, test) { |
3087 EXPECT(test != NULL); | 2870 EXPECT(test != NULL); |
3088 if (TargetCPUFeatures::neon_supported()) { | 2871 if (TargetCPUFeatures::neon_supported()) { |
3089 typedef int (*Tst)() DART_UNUSED; | 2872 typedef int (*Tst)() DART_UNUSED; |
3090 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2873 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3091 } | 2874 } |
3092 } | 2875 } |
3093 | 2876 |
3094 | |
3095 ASSEMBLER_TEST_GENERATE(Vmovq, assembler) { | 2877 ASSEMBLER_TEST_GENERATE(Vmovq, assembler) { |
3096 if (TargetCPUFeatures::neon_supported()) { | 2878 if (TargetCPUFeatures::neon_supported()) { |
3097 // Q0 | 2879 // Q0 |
3098 __ LoadSImmediate(S0, 1.0); | 2880 __ LoadSImmediate(S0, 1.0); |
3099 __ vmovs(S1, S0); | 2881 __ vmovs(S1, S0); |
3100 __ vmovs(S2, S0); | 2882 __ vmovs(S2, S0); |
3101 __ vmovs(S3, S0); | 2883 __ vmovs(S3, S0); |
3102 | 2884 |
3103 // Q0 | 2885 // Q0 |
3104 __ LoadSImmediate(S4, -1.0); | 2886 __ LoadSImmediate(S4, -1.0); |
3105 __ vmovs(S5, S0); | 2887 __ vmovs(S5, S0); |
3106 __ vmovs(S6, S0); | 2888 __ vmovs(S6, S0); |
3107 __ vmovs(S7, S0); | 2889 __ vmovs(S7, S0); |
3108 | 2890 |
3109 // Q1 = Q2 | 2891 // Q1 = Q2 |
3110 __ vmovq(Q1, Q0); | 2892 __ vmovq(Q1, Q0); |
3111 | 2893 |
3112 __ vadds(S4, S4, S5); | 2894 __ vadds(S4, S4, S5); |
3113 __ vadds(S4, S4, S6); | 2895 __ vadds(S4, S4, S6); |
3114 __ vadds(S4, S4, S7); | 2896 __ vadds(S4, S4, S7); |
3115 __ vcvtis(S0, S4); | 2897 __ vcvtis(S0, S4); |
3116 __ vmovrs(R0, S0); | 2898 __ vmovrs(R0, S0); |
3117 } | 2899 } |
3118 __ bx(LR); | 2900 __ bx(LR); |
3119 } | 2901 } |
3120 | 2902 |
3121 | |
3122 ASSEMBLER_TEST_RUN(Vmovq, test) { | 2903 ASSEMBLER_TEST_RUN(Vmovq, test) { |
3123 EXPECT(test != NULL); | 2904 EXPECT(test != NULL); |
3124 if (TargetCPUFeatures::neon_supported()) { | 2905 if (TargetCPUFeatures::neon_supported()) { |
3125 typedef int (*Tst)() DART_UNUSED; | 2906 typedef int (*Tst)() DART_UNUSED; |
3126 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2907 EXPECT_EQ(4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3127 } | 2908 } |
3128 } | 2909 } |
3129 | 2910 |
3130 | |
3131 ASSEMBLER_TEST_GENERATE(Vmvnq, assembler) { | 2911 ASSEMBLER_TEST_GENERATE(Vmvnq, assembler) { |
3132 if (TargetCPUFeatures::neon_supported()) { | 2912 if (TargetCPUFeatures::neon_supported()) { |
3133 __ LoadImmediate(R1, 42); // R1 <- 42. | 2913 __ LoadImmediate(R1, 42); // R1 <- 42. |
3134 __ vmovsr(S2, R1); // S2 <- R1. | 2914 __ vmovsr(S2, R1); // S2 <- R1. |
3135 __ vmvnq(Q1, Q0); // Q1 <- ~Q0. | 2915 __ vmvnq(Q1, Q0); // Q1 <- ~Q0. |
3136 __ vmvnq(Q2, Q1); // Q2 <- ~Q1. | 2916 __ vmvnq(Q2, Q1); // Q2 <- ~Q1. |
3137 __ vmovrs(R0, S10); // Now R0 should be 42 again. | 2917 __ vmovrs(R0, S10); // Now R0 should be 42 again. |
3138 } | 2918 } |
3139 __ bx(LR); | 2919 __ bx(LR); |
3140 } | 2920 } |
3141 | 2921 |
3142 | |
3143 ASSEMBLER_TEST_RUN(Vmvnq, test) { | 2922 ASSEMBLER_TEST_RUN(Vmvnq, test) { |
3144 EXPECT(test != NULL); | 2923 EXPECT(test != NULL); |
3145 if (TargetCPUFeatures::neon_supported()) { | 2924 if (TargetCPUFeatures::neon_supported()) { |
3146 typedef int (*Tst)() DART_UNUSED; | 2925 typedef int (*Tst)() DART_UNUSED; |
3147 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2926 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3148 } | 2927 } |
3149 } | 2928 } |
3150 | 2929 |
3151 | |
3152 ASSEMBLER_TEST_GENERATE(Vdupb, assembler) { | 2930 ASSEMBLER_TEST_GENERATE(Vdupb, assembler) { |
3153 if (TargetCPUFeatures::neon_supported()) { | 2931 if (TargetCPUFeatures::neon_supported()) { |
3154 __ LoadImmediate(R0, 0x00000000); | 2932 __ LoadImmediate(R0, 0x00000000); |
3155 __ LoadImmediate(R1, 0x00ff0000); | 2933 __ LoadImmediate(R1, 0x00ff0000); |
3156 __ vmovsr(S4, R0); | 2934 __ vmovsr(S4, R0); |
3157 __ vmovsr(S5, R1); | 2935 __ vmovsr(S5, R1); |
3158 | 2936 |
3159 // Should copy 0xff to each byte of Q0. | 2937 // Should copy 0xff to each byte of Q0. |
3160 __ vdup(kByte, Q0, D2, 6); | 2938 __ vdup(kByte, Q0, D2, 6); |
3161 | 2939 |
3162 __ vmovrs(R0, S0); | 2940 __ vmovrs(R0, S0); |
3163 __ vmovrs(R1, S1); | 2941 __ vmovrs(R1, S1); |
3164 __ vmovrs(R2, S2); | 2942 __ vmovrs(R2, S2); |
3165 __ vmovrs(R3, S3); | 2943 __ vmovrs(R3, S3); |
3166 | 2944 |
3167 __ add(R0, R0, Operand(R1)); | 2945 __ add(R0, R0, Operand(R1)); |
3168 __ add(R0, R0, Operand(R2)); | 2946 __ add(R0, R0, Operand(R2)); |
3169 __ add(R0, R0, Operand(R3)); | 2947 __ add(R0, R0, Operand(R3)); |
3170 } | 2948 } |
3171 __ bx(LR); | 2949 __ bx(LR); |
3172 } | 2950 } |
3173 | 2951 |
3174 | |
3175 ASSEMBLER_TEST_RUN(Vdupb, test) { | 2952 ASSEMBLER_TEST_RUN(Vdupb, test) { |
3176 EXPECT(test != NULL); | 2953 EXPECT(test != NULL); |
3177 if (TargetCPUFeatures::neon_supported()) { | 2954 if (TargetCPUFeatures::neon_supported()) { |
3178 typedef int (*Tst)() DART_UNUSED; | 2955 typedef int (*Tst)() DART_UNUSED; |
3179 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2956 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3180 } | 2957 } |
3181 } | 2958 } |
3182 | 2959 |
3183 | |
3184 ASSEMBLER_TEST_GENERATE(Vduph, assembler) { | 2960 ASSEMBLER_TEST_GENERATE(Vduph, assembler) { |
3185 if (TargetCPUFeatures::neon_supported()) { | 2961 if (TargetCPUFeatures::neon_supported()) { |
3186 __ LoadImmediate(R0, 0xffff0000); | 2962 __ LoadImmediate(R0, 0xffff0000); |
3187 __ LoadImmediate(R1, 0x00000000); | 2963 __ LoadImmediate(R1, 0x00000000); |
3188 __ vmovsr(S4, R0); | 2964 __ vmovsr(S4, R0); |
3189 __ vmovsr(S5, R1); | 2965 __ vmovsr(S5, R1); |
3190 | 2966 |
3191 // Should copy 0xff to each byte of Q0. | 2967 // Should copy 0xff to each byte of Q0. |
3192 __ vdup(kHalfword, Q0, D2, 1); | 2968 __ vdup(kHalfword, Q0, D2, 1); |
3193 | 2969 |
3194 __ vmovrs(R0, S0); | 2970 __ vmovrs(R0, S0); |
3195 __ vmovrs(R1, S1); | 2971 __ vmovrs(R1, S1); |
3196 __ vmovrs(R2, S2); | 2972 __ vmovrs(R2, S2); |
3197 __ vmovrs(R3, S3); | 2973 __ vmovrs(R3, S3); |
3198 | 2974 |
3199 __ add(R0, R0, Operand(R1)); | 2975 __ add(R0, R0, Operand(R1)); |
3200 __ add(R0, R0, Operand(R2)); | 2976 __ add(R0, R0, Operand(R2)); |
3201 __ add(R0, R0, Operand(R3)); | 2977 __ add(R0, R0, Operand(R3)); |
3202 } | 2978 } |
3203 __ bx(LR); | 2979 __ bx(LR); |
3204 } | 2980 } |
3205 | 2981 |
3206 | |
3207 ASSEMBLER_TEST_RUN(Vduph, test) { | 2982 ASSEMBLER_TEST_RUN(Vduph, test) { |
3208 EXPECT(test != NULL); | 2983 EXPECT(test != NULL); |
3209 if (TargetCPUFeatures::neon_supported()) { | 2984 if (TargetCPUFeatures::neon_supported()) { |
3210 typedef int (*Tst)() DART_UNUSED; | 2985 typedef int (*Tst)() DART_UNUSED; |
3211 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 2986 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3212 } | 2987 } |
3213 } | 2988 } |
3214 | 2989 |
3215 | |
3216 ASSEMBLER_TEST_GENERATE(Vdupw, assembler) { | 2990 ASSEMBLER_TEST_GENERATE(Vdupw, assembler) { |
3217 if (TargetCPUFeatures::neon_supported()) { | 2991 if (TargetCPUFeatures::neon_supported()) { |
3218 __ LoadImmediate(R0, 0x00000000); | 2992 __ LoadImmediate(R0, 0x00000000); |
3219 __ LoadImmediate(R1, 0xffffffff); | 2993 __ LoadImmediate(R1, 0xffffffff); |
3220 __ vmovsr(S4, R0); | 2994 __ vmovsr(S4, R0); |
3221 __ vmovsr(S5, R1); | 2995 __ vmovsr(S5, R1); |
3222 | 2996 |
3223 // Should copy 0xff to each byte of Q0. | 2997 // Should copy 0xff to each byte of Q0. |
3224 __ vdup(kWord, Q0, D2, 1); | 2998 __ vdup(kWord, Q0, D2, 1); |
3225 | 2999 |
3226 __ vmovrs(R0, S0); | 3000 __ vmovrs(R0, S0); |
3227 __ vmovrs(R1, S1); | 3001 __ vmovrs(R1, S1); |
3228 __ vmovrs(R2, S2); | 3002 __ vmovrs(R2, S2); |
3229 __ vmovrs(R3, S3); | 3003 __ vmovrs(R3, S3); |
3230 | 3004 |
3231 __ add(R0, R0, Operand(R1)); | 3005 __ add(R0, R0, Operand(R1)); |
3232 __ add(R0, R0, Operand(R2)); | 3006 __ add(R0, R0, Operand(R2)); |
3233 __ add(R0, R0, Operand(R3)); | 3007 __ add(R0, R0, Operand(R3)); |
3234 } | 3008 } |
3235 __ bx(LR); | 3009 __ bx(LR); |
3236 } | 3010 } |
3237 | 3011 |
3238 | |
3239 ASSEMBLER_TEST_RUN(Vdupw, test) { | 3012 ASSEMBLER_TEST_RUN(Vdupw, test) { |
3240 EXPECT(test != NULL); | 3013 EXPECT(test != NULL); |
3241 if (TargetCPUFeatures::neon_supported()) { | 3014 if (TargetCPUFeatures::neon_supported()) { |
3242 typedef int (*Tst)() DART_UNUSED; | 3015 typedef int (*Tst)() DART_UNUSED; |
3243 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3016 EXPECT_EQ(-4, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3244 } | 3017 } |
3245 } | 3018 } |
3246 | 3019 |
3247 | |
3248 ASSEMBLER_TEST_GENERATE(Vzipqw, assembler) { | 3020 ASSEMBLER_TEST_GENERATE(Vzipqw, assembler) { |
3249 if (TargetCPUFeatures::neon_supported()) { | 3021 if (TargetCPUFeatures::neon_supported()) { |
3250 __ LoadSImmediate(S0, 0.0); | 3022 __ LoadSImmediate(S0, 0.0); |
3251 __ LoadSImmediate(S1, 1.0); | 3023 __ LoadSImmediate(S1, 1.0); |
3252 __ LoadSImmediate(S2, 2.0); | 3024 __ LoadSImmediate(S2, 2.0); |
3253 __ LoadSImmediate(S3, 3.0); | 3025 __ LoadSImmediate(S3, 3.0); |
3254 __ LoadSImmediate(S4, 4.0); | 3026 __ LoadSImmediate(S4, 4.0); |
3255 __ LoadSImmediate(S5, 5.0); | 3027 __ LoadSImmediate(S5, 5.0); |
3256 __ LoadSImmediate(S6, 6.0); | 3028 __ LoadSImmediate(S6, 6.0); |
3257 __ LoadSImmediate(S7, 7.0); | 3029 __ LoadSImmediate(S7, 7.0); |
3258 | 3030 |
3259 __ vzipqw(Q0, Q1); | 3031 __ vzipqw(Q0, Q1); |
3260 | 3032 |
3261 __ vsubqs(Q0, Q1, Q0); | 3033 __ vsubqs(Q0, Q1, Q0); |
3262 | 3034 |
3263 __ vadds(S0, S0, S1); | 3035 __ vadds(S0, S0, S1); |
3264 __ vadds(S0, S0, S2); | 3036 __ vadds(S0, S0, S2); |
3265 __ vadds(S0, S0, S3); | 3037 __ vadds(S0, S0, S3); |
3266 } | 3038 } |
3267 __ bx(LR); | 3039 __ bx(LR); |
3268 } | 3040 } |
3269 | 3041 |
3270 | |
3271 ASSEMBLER_TEST_RUN(Vzipqw, test) { | 3042 ASSEMBLER_TEST_RUN(Vzipqw, test) { |
3272 EXPECT(test != NULL); | 3043 EXPECT(test != NULL); |
3273 if (TargetCPUFeatures::neon_supported()) { | 3044 if (TargetCPUFeatures::neon_supported()) { |
3274 typedef float (*Vzipqw)() DART_UNUSED; | 3045 typedef float (*Vzipqw)() DART_UNUSED; |
3275 float res = EXECUTE_TEST_CODE_FLOAT(Vzipqw, test->entry()); | 3046 float res = EXECUTE_TEST_CODE_FLOAT(Vzipqw, test->entry()); |
3276 EXPECT_FLOAT_EQ(8.0, res, 0.0001f); | 3047 EXPECT_FLOAT_EQ(8.0, res, 0.0001f); |
3277 } | 3048 } |
3278 } | 3049 } |
3279 | 3050 |
3280 | |
3281 ASSEMBLER_TEST_GENERATE(Vceqqi32, assembler) { | 3051 ASSEMBLER_TEST_GENERATE(Vceqqi32, assembler) { |
3282 if (TargetCPUFeatures::neon_supported()) { | 3052 if (TargetCPUFeatures::neon_supported()) { |
3283 __ mov(R0, Operand(1)); | 3053 __ mov(R0, Operand(1)); |
3284 __ vmovsr(S0, R0); | 3054 __ vmovsr(S0, R0); |
3285 __ mov(R0, Operand(2)); | 3055 __ mov(R0, Operand(2)); |
3286 __ vmovsr(S1, R0); | 3056 __ vmovsr(S1, R0); |
3287 __ mov(R0, Operand(3)); | 3057 __ mov(R0, Operand(3)); |
3288 __ vmovsr(S2, R0); | 3058 __ vmovsr(S2, R0); |
3289 __ mov(R0, Operand(4)); | 3059 __ mov(R0, Operand(4)); |
3290 __ vmovsr(S3, R0); | 3060 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
3304 __ vmovrs(R2, S10); | 3074 __ vmovrs(R2, S10); |
3305 __ vmovrs(R3, S11); | 3075 __ vmovrs(R3, S11); |
3306 | 3076 |
3307 __ add(R0, R0, Operand(R1)); | 3077 __ add(R0, R0, Operand(R1)); |
3308 __ add(R0, R0, Operand(R2)); | 3078 __ add(R0, R0, Operand(R2)); |
3309 __ add(R0, R0, Operand(R3)); | 3079 __ add(R0, R0, Operand(R3)); |
3310 } | 3080 } |
3311 __ bx(LR); | 3081 __ bx(LR); |
3312 } | 3082 } |
3313 | 3083 |
3314 | |
3315 ASSEMBLER_TEST_RUN(Vceqqi32, test) { | 3084 ASSEMBLER_TEST_RUN(Vceqqi32, test) { |
3316 EXPECT(test != NULL); | 3085 EXPECT(test != NULL); |
3317 if (TargetCPUFeatures::neon_supported()) { | 3086 if (TargetCPUFeatures::neon_supported()) { |
3318 typedef int (*Tst)() DART_UNUSED; | 3087 typedef int (*Tst)() DART_UNUSED; |
3319 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3088 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3320 } | 3089 } |
3321 } | 3090 } |
3322 | 3091 |
3323 | |
3324 ASSEMBLER_TEST_GENERATE(Vceqqs, assembler) { | 3092 ASSEMBLER_TEST_GENERATE(Vceqqs, assembler) { |
3325 if (TargetCPUFeatures::neon_supported()) { | 3093 if (TargetCPUFeatures::neon_supported()) { |
3326 __ LoadSImmediate(S0, 1.0); | 3094 __ LoadSImmediate(S0, 1.0); |
3327 __ LoadSImmediate(S1, 2.0); | 3095 __ LoadSImmediate(S1, 2.0); |
3328 __ LoadSImmediate(S2, 3.0); | 3096 __ LoadSImmediate(S2, 3.0); |
3329 __ LoadSImmediate(S3, 4.0); | 3097 __ LoadSImmediate(S3, 4.0); |
3330 __ LoadSImmediate(S4, 1.0); | 3098 __ LoadSImmediate(S4, 1.0); |
3331 __ LoadSImmediate(S5, 4.0); | 3099 __ LoadSImmediate(S5, 4.0); |
3332 __ LoadSImmediate(S6, 3.0); | 3100 __ LoadSImmediate(S6, 3.0); |
3333 __ LoadSImmediate(S7, 8.0); | 3101 __ LoadSImmediate(S7, 8.0); |
3334 | 3102 |
3335 __ vceqqs(Q2, Q1, Q0); | 3103 __ vceqqs(Q2, Q1, Q0); |
3336 | 3104 |
3337 __ vmovrs(R0, S8); | 3105 __ vmovrs(R0, S8); |
3338 __ vmovrs(R1, S9); | 3106 __ vmovrs(R1, S9); |
3339 __ vmovrs(R2, S10); | 3107 __ vmovrs(R2, S10); |
3340 __ vmovrs(R3, S11); | 3108 __ vmovrs(R3, S11); |
3341 | 3109 |
3342 __ add(R0, R0, Operand(R1)); | 3110 __ add(R0, R0, Operand(R1)); |
3343 __ add(R0, R0, Operand(R2)); | 3111 __ add(R0, R0, Operand(R2)); |
3344 __ add(R0, R0, Operand(R3)); | 3112 __ add(R0, R0, Operand(R3)); |
3345 } | 3113 } |
3346 __ bx(LR); | 3114 __ bx(LR); |
3347 } | 3115 } |
3348 | 3116 |
3349 | |
3350 ASSEMBLER_TEST_RUN(Vceqqs, test) { | 3117 ASSEMBLER_TEST_RUN(Vceqqs, test) { |
3351 EXPECT(test != NULL); | 3118 EXPECT(test != NULL); |
3352 if (TargetCPUFeatures::neon_supported()) { | 3119 if (TargetCPUFeatures::neon_supported()) { |
3353 typedef int (*Tst)() DART_UNUSED; | 3120 typedef int (*Tst)() DART_UNUSED; |
3354 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3121 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3355 } | 3122 } |
3356 } | 3123 } |
3357 | 3124 |
3358 | |
3359 ASSEMBLER_TEST_GENERATE(Vcgeqi32, assembler) { | 3125 ASSEMBLER_TEST_GENERATE(Vcgeqi32, assembler) { |
3360 if (TargetCPUFeatures::neon_supported()) { | 3126 if (TargetCPUFeatures::neon_supported()) { |
3361 __ mov(R0, Operand(1)); | 3127 __ mov(R0, Operand(1)); |
3362 __ vmovsr(S0, R0); | 3128 __ vmovsr(S0, R0); |
3363 __ mov(R0, Operand(2)); | 3129 __ mov(R0, Operand(2)); |
3364 __ vmovsr(S1, R0); | 3130 __ vmovsr(S1, R0); |
3365 __ mov(R0, Operand(3)); | 3131 __ mov(R0, Operand(3)); |
3366 __ vmovsr(S2, R0); | 3132 __ vmovsr(S2, R0); |
3367 __ mov(R0, Operand(4)); | 3133 __ mov(R0, Operand(4)); |
3368 __ vmovsr(S3, R0); | 3134 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
3382 __ vmovrs(R2, S10); | 3148 __ vmovrs(R2, S10); |
3383 __ vmovrs(R3, S11); | 3149 __ vmovrs(R3, S11); |
3384 | 3150 |
3385 __ add(R0, R0, Operand(R1)); | 3151 __ add(R0, R0, Operand(R1)); |
3386 __ add(R0, R0, Operand(R2)); | 3152 __ add(R0, R0, Operand(R2)); |
3387 __ add(R0, R0, Operand(R3)); | 3153 __ add(R0, R0, Operand(R3)); |
3388 } | 3154 } |
3389 __ bx(LR); | 3155 __ bx(LR); |
3390 } | 3156 } |
3391 | 3157 |
3392 | |
3393 ASSEMBLER_TEST_RUN(Vcgeqi32, test) { | 3158 ASSEMBLER_TEST_RUN(Vcgeqi32, test) { |
3394 EXPECT(test != NULL); | 3159 EXPECT(test != NULL); |
3395 if (TargetCPUFeatures::neon_supported()) { | 3160 if (TargetCPUFeatures::neon_supported()) { |
3396 typedef int (*Tst)() DART_UNUSED; | 3161 typedef int (*Tst)() DART_UNUSED; |
3397 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3162 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3398 } | 3163 } |
3399 } | 3164 } |
3400 | 3165 |
3401 | |
3402 ASSEMBLER_TEST_GENERATE(Vcugeqi32, assembler) { | 3166 ASSEMBLER_TEST_GENERATE(Vcugeqi32, assembler) { |
3403 if (TargetCPUFeatures::neon_supported()) { | 3167 if (TargetCPUFeatures::neon_supported()) { |
3404 __ mov(R0, Operand(1)); | 3168 __ mov(R0, Operand(1)); |
3405 __ vmovsr(S0, R0); | 3169 __ vmovsr(S0, R0); |
3406 __ mov(R0, Operand(2)); | 3170 __ mov(R0, Operand(2)); |
3407 __ vmovsr(S1, R0); | 3171 __ vmovsr(S1, R0); |
3408 __ mov(R0, Operand(3)); | 3172 __ mov(R0, Operand(3)); |
3409 __ vmovsr(S2, R0); | 3173 __ vmovsr(S2, R0); |
3410 __ mov(R0, Operand(4)); | 3174 __ mov(R0, Operand(4)); |
3411 __ vmovsr(S3, R0); | 3175 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
3425 __ vmovrs(R2, S10); | 3189 __ vmovrs(R2, S10); |
3426 __ vmovrs(R3, S11); | 3190 __ vmovrs(R3, S11); |
3427 | 3191 |
3428 __ add(R0, R0, Operand(R1)); | 3192 __ add(R0, R0, Operand(R1)); |
3429 __ add(R0, R0, Operand(R2)); | 3193 __ add(R0, R0, Operand(R2)); |
3430 __ add(R0, R0, Operand(R3)); | 3194 __ add(R0, R0, Operand(R3)); |
3431 } | 3195 } |
3432 __ bx(LR); | 3196 __ bx(LR); |
3433 } | 3197 } |
3434 | 3198 |
3435 | |
3436 ASSEMBLER_TEST_RUN(Vcugeqi32, test) { | 3199 ASSEMBLER_TEST_RUN(Vcugeqi32, test) { |
3437 EXPECT(test != NULL); | 3200 EXPECT(test != NULL); |
3438 if (TargetCPUFeatures::neon_supported()) { | 3201 if (TargetCPUFeatures::neon_supported()) { |
3439 typedef int (*Tst)() DART_UNUSED; | 3202 typedef int (*Tst)() DART_UNUSED; |
3440 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3203 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3441 } | 3204 } |
3442 } | 3205 } |
3443 | 3206 |
3444 | |
3445 ASSEMBLER_TEST_GENERATE(Vcgeqs, assembler) { | 3207 ASSEMBLER_TEST_GENERATE(Vcgeqs, assembler) { |
3446 if (TargetCPUFeatures::neon_supported()) { | 3208 if (TargetCPUFeatures::neon_supported()) { |
3447 __ LoadSImmediate(S0, 1.0); | 3209 __ LoadSImmediate(S0, 1.0); |
3448 __ LoadSImmediate(S1, 2.0); | 3210 __ LoadSImmediate(S1, 2.0); |
3449 __ LoadSImmediate(S2, 3.0); | 3211 __ LoadSImmediate(S2, 3.0); |
3450 __ LoadSImmediate(S3, 4.0); | 3212 __ LoadSImmediate(S3, 4.0); |
3451 __ LoadSImmediate(S4, 1.0); | 3213 __ LoadSImmediate(S4, 1.0); |
3452 __ LoadSImmediate(S5, 1.0); | 3214 __ LoadSImmediate(S5, 1.0); |
3453 __ LoadSImmediate(S6, 3.0); | 3215 __ LoadSImmediate(S6, 3.0); |
3454 __ LoadSImmediate(S7, 1.0); | 3216 __ LoadSImmediate(S7, 1.0); |
3455 | 3217 |
3456 __ vcgeqs(Q2, Q1, Q0); | 3218 __ vcgeqs(Q2, Q1, Q0); |
3457 | 3219 |
3458 __ vmovrs(R0, S8); | 3220 __ vmovrs(R0, S8); |
3459 __ vmovrs(R1, S9); | 3221 __ vmovrs(R1, S9); |
3460 __ vmovrs(R2, S10); | 3222 __ vmovrs(R2, S10); |
3461 __ vmovrs(R3, S11); | 3223 __ vmovrs(R3, S11); |
3462 | 3224 |
3463 __ add(R0, R0, Operand(R1)); | 3225 __ add(R0, R0, Operand(R1)); |
3464 __ add(R0, R0, Operand(R2)); | 3226 __ add(R0, R0, Operand(R2)); |
3465 __ add(R0, R0, Operand(R3)); | 3227 __ add(R0, R0, Operand(R3)); |
3466 } | 3228 } |
3467 __ bx(LR); | 3229 __ bx(LR); |
3468 } | 3230 } |
3469 | 3231 |
3470 | |
3471 ASSEMBLER_TEST_RUN(Vcgeqs, test) { | 3232 ASSEMBLER_TEST_RUN(Vcgeqs, test) { |
3472 EXPECT(test != NULL); | 3233 EXPECT(test != NULL); |
3473 if (TargetCPUFeatures::neon_supported()) { | 3234 if (TargetCPUFeatures::neon_supported()) { |
3474 typedef int (*Tst)() DART_UNUSED; | 3235 typedef int (*Tst)() DART_UNUSED; |
3475 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3236 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3476 } | 3237 } |
3477 } | 3238 } |
3478 | 3239 |
3479 | |
3480 ASSEMBLER_TEST_GENERATE(Vcgtqi32, assembler) { | 3240 ASSEMBLER_TEST_GENERATE(Vcgtqi32, assembler) { |
3481 if (TargetCPUFeatures::neon_supported()) { | 3241 if (TargetCPUFeatures::neon_supported()) { |
3482 __ mov(R0, Operand(1)); | 3242 __ mov(R0, Operand(1)); |
3483 __ vmovsr(S0, R0); | 3243 __ vmovsr(S0, R0); |
3484 __ mov(R0, Operand(2)); | 3244 __ mov(R0, Operand(2)); |
3485 __ vmovsr(S1, R0); | 3245 __ vmovsr(S1, R0); |
3486 __ mov(R0, Operand(3)); | 3246 __ mov(R0, Operand(3)); |
3487 __ vmovsr(S2, R0); | 3247 __ vmovsr(S2, R0); |
3488 __ mov(R0, Operand(4)); | 3248 __ mov(R0, Operand(4)); |
3489 __ vmovsr(S3, R0); | 3249 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
3503 __ vmovrs(R2, S10); | 3263 __ vmovrs(R2, S10); |
3504 __ vmovrs(R3, S11); | 3264 __ vmovrs(R3, S11); |
3505 | 3265 |
3506 __ add(R0, R0, Operand(R1)); | 3266 __ add(R0, R0, Operand(R1)); |
3507 __ add(R0, R0, Operand(R2)); | 3267 __ add(R0, R0, Operand(R2)); |
3508 __ add(R0, R0, Operand(R3)); | 3268 __ add(R0, R0, Operand(R3)); |
3509 } | 3269 } |
3510 __ bx(LR); | 3270 __ bx(LR); |
3511 } | 3271 } |
3512 | 3272 |
3513 | |
3514 ASSEMBLER_TEST_RUN(Vcgtqi32, test) { | 3273 ASSEMBLER_TEST_RUN(Vcgtqi32, test) { |
3515 EXPECT(test != NULL); | 3274 EXPECT(test != NULL); |
3516 if (TargetCPUFeatures::neon_supported()) { | 3275 if (TargetCPUFeatures::neon_supported()) { |
3517 typedef int (*Tst)() DART_UNUSED; | 3276 typedef int (*Tst)() DART_UNUSED; |
3518 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3277 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3519 } | 3278 } |
3520 } | 3279 } |
3521 | 3280 |
3522 | |
3523 ASSEMBLER_TEST_GENERATE(Vcugtqi32, assembler) { | 3281 ASSEMBLER_TEST_GENERATE(Vcugtqi32, assembler) { |
3524 if (TargetCPUFeatures::neon_supported()) { | 3282 if (TargetCPUFeatures::neon_supported()) { |
3525 __ mov(R0, Operand(1)); | 3283 __ mov(R0, Operand(1)); |
3526 __ vmovsr(S0, R0); | 3284 __ vmovsr(S0, R0); |
3527 __ mov(R0, Operand(2)); | 3285 __ mov(R0, Operand(2)); |
3528 __ vmovsr(S1, R0); | 3286 __ vmovsr(S1, R0); |
3529 __ mov(R0, Operand(3)); | 3287 __ mov(R0, Operand(3)); |
3530 __ vmovsr(S2, R0); | 3288 __ vmovsr(S2, R0); |
3531 __ mov(R0, Operand(4)); | 3289 __ mov(R0, Operand(4)); |
3532 __ vmovsr(S3, R0); | 3290 __ vmovsr(S3, R0); |
(...skipping 13 matching lines...) Expand all Loading... |
3546 __ vmovrs(R2, S10); | 3304 __ vmovrs(R2, S10); |
3547 __ vmovrs(R3, S11); | 3305 __ vmovrs(R3, S11); |
3548 | 3306 |
3549 __ add(R0, R0, Operand(R1)); | 3307 __ add(R0, R0, Operand(R1)); |
3550 __ add(R0, R0, Operand(R2)); | 3308 __ add(R0, R0, Operand(R2)); |
3551 __ add(R0, R0, Operand(R3)); | 3309 __ add(R0, R0, Operand(R3)); |
3552 } | 3310 } |
3553 __ bx(LR); | 3311 __ bx(LR); |
3554 } | 3312 } |
3555 | 3313 |
3556 | |
3557 ASSEMBLER_TEST_RUN(Vcugtqi32, test) { | 3314 ASSEMBLER_TEST_RUN(Vcugtqi32, test) { |
3558 EXPECT(test != NULL); | 3315 EXPECT(test != NULL); |
3559 if (TargetCPUFeatures::neon_supported()) { | 3316 if (TargetCPUFeatures::neon_supported()) { |
3560 typedef int (*Tst)() DART_UNUSED; | 3317 typedef int (*Tst)() DART_UNUSED; |
3561 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3318 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3562 } | 3319 } |
3563 } | 3320 } |
3564 | 3321 |
3565 | |
3566 ASSEMBLER_TEST_GENERATE(Vcgtqs, assembler) { | 3322 ASSEMBLER_TEST_GENERATE(Vcgtqs, assembler) { |
3567 if (TargetCPUFeatures::neon_supported()) { | 3323 if (TargetCPUFeatures::neon_supported()) { |
3568 __ LoadSImmediate(S0, 1.0); | 3324 __ LoadSImmediate(S0, 1.0); |
3569 __ LoadSImmediate(S1, 2.0); | 3325 __ LoadSImmediate(S1, 2.0); |
3570 __ LoadSImmediate(S2, 3.0); | 3326 __ LoadSImmediate(S2, 3.0); |
3571 __ LoadSImmediate(S3, 4.0); | 3327 __ LoadSImmediate(S3, 4.0); |
3572 __ LoadSImmediate(S4, 2.0); | 3328 __ LoadSImmediate(S4, 2.0); |
3573 __ LoadSImmediate(S5, 1.0); | 3329 __ LoadSImmediate(S5, 1.0); |
3574 __ LoadSImmediate(S6, 4.0); | 3330 __ LoadSImmediate(S6, 4.0); |
3575 __ LoadSImmediate(S7, 1.0); | 3331 __ LoadSImmediate(S7, 1.0); |
3576 | 3332 |
3577 __ vcgtqs(Q2, Q1, Q0); | 3333 __ vcgtqs(Q2, Q1, Q0); |
3578 | 3334 |
3579 __ vmovrs(R0, S8); | 3335 __ vmovrs(R0, S8); |
3580 __ vmovrs(R1, S9); | 3336 __ vmovrs(R1, S9); |
3581 __ vmovrs(R2, S10); | 3337 __ vmovrs(R2, S10); |
3582 __ vmovrs(R3, S11); | 3338 __ vmovrs(R3, S11); |
3583 | 3339 |
3584 __ add(R0, R0, Operand(R1)); | 3340 __ add(R0, R0, Operand(R1)); |
3585 __ add(R0, R0, Operand(R2)); | 3341 __ add(R0, R0, Operand(R2)); |
3586 __ add(R0, R0, Operand(R3)); | 3342 __ add(R0, R0, Operand(R3)); |
3587 } | 3343 } |
3588 __ bx(LR); | 3344 __ bx(LR); |
3589 } | 3345 } |
3590 | 3346 |
3591 | |
3592 ASSEMBLER_TEST_RUN(Vcgtqs, test) { | 3347 ASSEMBLER_TEST_RUN(Vcgtqs, test) { |
3593 EXPECT(test != NULL); | 3348 EXPECT(test != NULL); |
3594 if (TargetCPUFeatures::neon_supported()) { | 3349 if (TargetCPUFeatures::neon_supported()) { |
3595 typedef int (*Tst)() DART_UNUSED; | 3350 typedef int (*Tst)() DART_UNUSED; |
3596 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3351 EXPECT_EQ(-2, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3597 } | 3352 } |
3598 } | 3353 } |
3599 | 3354 |
3600 | |
3601 ASSEMBLER_TEST_GENERATE(Vminqs, assembler) { | 3355 ASSEMBLER_TEST_GENERATE(Vminqs, assembler) { |
3602 if (TargetCPUFeatures::neon_supported()) { | 3356 if (TargetCPUFeatures::neon_supported()) { |
3603 __ LoadSImmediate(S0, 1.0); | 3357 __ LoadSImmediate(S0, 1.0); |
3604 __ LoadSImmediate(S1, 2.0); | 3358 __ LoadSImmediate(S1, 2.0); |
3605 __ LoadSImmediate(S2, 3.0); | 3359 __ LoadSImmediate(S2, 3.0); |
3606 __ LoadSImmediate(S3, 4.0); | 3360 __ LoadSImmediate(S3, 4.0); |
3607 | 3361 |
3608 __ LoadSImmediate(S4, 2.0); | 3362 __ LoadSImmediate(S4, 2.0); |
3609 __ LoadSImmediate(S5, 1.0); | 3363 __ LoadSImmediate(S5, 1.0); |
3610 __ LoadSImmediate(S6, 6.0); | 3364 __ LoadSImmediate(S6, 6.0); |
3611 __ LoadSImmediate(S7, 3.0); | 3365 __ LoadSImmediate(S7, 3.0); |
3612 | 3366 |
3613 __ vminqs(Q2, Q1, Q0); | 3367 __ vminqs(Q2, Q1, Q0); |
3614 | 3368 |
3615 __ vadds(S8, S8, S9); | 3369 __ vadds(S8, S8, S9); |
3616 __ vadds(S8, S8, S10); | 3370 __ vadds(S8, S8, S10); |
3617 __ vadds(S8, S8, S11); | 3371 __ vadds(S8, S8, S11); |
3618 | 3372 |
3619 __ vcvtis(S0, S8); | 3373 __ vcvtis(S0, S8); |
3620 __ vmovrs(R0, S0); | 3374 __ vmovrs(R0, S0); |
3621 } | 3375 } |
3622 __ bx(LR); | 3376 __ bx(LR); |
3623 } | 3377 } |
3624 | 3378 |
3625 | |
3626 ASSEMBLER_TEST_RUN(Vminqs, test) { | 3379 ASSEMBLER_TEST_RUN(Vminqs, test) { |
3627 EXPECT(test != NULL); | 3380 EXPECT(test != NULL); |
3628 if (TargetCPUFeatures::neon_supported()) { | 3381 if (TargetCPUFeatures::neon_supported()) { |
3629 typedef int (*Tst)() DART_UNUSED; | 3382 typedef int (*Tst)() DART_UNUSED; |
3630 EXPECT_EQ(8, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3383 EXPECT_EQ(8, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3631 } | 3384 } |
3632 } | 3385 } |
3633 | 3386 |
3634 | |
3635 ASSEMBLER_TEST_GENERATE(Vmaxqs, assembler) { | 3387 ASSEMBLER_TEST_GENERATE(Vmaxqs, assembler) { |
3636 if (TargetCPUFeatures::neon_supported()) { | 3388 if (TargetCPUFeatures::neon_supported()) { |
3637 __ LoadSImmediate(S0, 1.0); | 3389 __ LoadSImmediate(S0, 1.0); |
3638 __ LoadSImmediate(S1, 2.0); | 3390 __ LoadSImmediate(S1, 2.0); |
3639 __ LoadSImmediate(S2, 3.0); | 3391 __ LoadSImmediate(S2, 3.0); |
3640 __ LoadSImmediate(S3, 4.0); | 3392 __ LoadSImmediate(S3, 4.0); |
3641 | 3393 |
3642 __ LoadSImmediate(S4, 2.0); | 3394 __ LoadSImmediate(S4, 2.0); |
3643 __ LoadSImmediate(S5, 1.0); | 3395 __ LoadSImmediate(S5, 1.0); |
3644 __ LoadSImmediate(S6, 6.0); | 3396 __ LoadSImmediate(S6, 6.0); |
3645 __ LoadSImmediate(S7, 3.0); | 3397 __ LoadSImmediate(S7, 3.0); |
3646 | 3398 |
3647 __ vmaxqs(Q2, Q1, Q0); | 3399 __ vmaxqs(Q2, Q1, Q0); |
3648 | 3400 |
3649 __ vadds(S8, S8, S9); | 3401 __ vadds(S8, S8, S9); |
3650 __ vadds(S8, S8, S10); | 3402 __ vadds(S8, S8, S10); |
3651 __ vadds(S8, S8, S11); | 3403 __ vadds(S8, S8, S11); |
3652 | 3404 |
3653 __ vcvtis(S0, S8); | 3405 __ vcvtis(S0, S8); |
3654 __ vmovrs(R0, S0); | 3406 __ vmovrs(R0, S0); |
3655 } | 3407 } |
3656 __ bx(LR); | 3408 __ bx(LR); |
3657 } | 3409 } |
3658 | 3410 |
3659 | |
3660 ASSEMBLER_TEST_RUN(Vmaxqs, test) { | 3411 ASSEMBLER_TEST_RUN(Vmaxqs, test) { |
3661 EXPECT(test != NULL); | 3412 EXPECT(test != NULL); |
3662 if (TargetCPUFeatures::neon_supported()) { | 3413 if (TargetCPUFeatures::neon_supported()) { |
3663 typedef int (*Tst)() DART_UNUSED; | 3414 typedef int (*Tst)() DART_UNUSED; |
3664 EXPECT_EQ(14, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); | 3415 EXPECT_EQ(14, EXECUTE_TEST_CODE_INT32(Tst, test->entry())); |
3665 } | 3416 } |
3666 } | 3417 } |
3667 | 3418 |
3668 | |
3669 // This is the same function as in the Simulator. | 3419 // This is the same function as in the Simulator. |
3670 static float arm_recip_estimate(float a) { | 3420 static float arm_recip_estimate(float a) { |
3671 // From the ARM Architecture Reference Manual A2-85. | 3421 // From the ARM Architecture Reference Manual A2-85. |
3672 if (isinf(a) || (fabs(a) >= exp2f(126))) | 3422 if (isinf(a) || (fabs(a) >= exp2f(126))) |
3673 return 0.0; | 3423 return 0.0; |
3674 else if (a == 0.0) | 3424 else if (a == 0.0) |
3675 return kPosInfinity; | 3425 return kPosInfinity; |
3676 else if (isnan(a)) | 3426 else if (isnan(a)) |
3677 return a; | 3427 return a; |
3678 | 3428 |
(...skipping 17 matching lines...) Expand all Loading... |
3696 double estimate = static_cast<double>(s) / 256.0; | 3446 double estimate = static_cast<double>(s) / 256.0; |
3697 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); | 3447 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); |
3698 | 3448 |
3699 // result = sign : result_exp<7:0> : estimate<51:29> | 3449 // result = sign : result_exp<7:0> : estimate<51:29> |
3700 int32_t result_bits = | 3450 int32_t result_bits = |
3701 (a_bits & 0x80000000) | ((result_exp & 0xff) << 23) | | 3451 (a_bits & 0x80000000) | ((result_exp & 0xff) << 23) | |
3702 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); | 3452 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); |
3703 return bit_cast<float, int32_t>(result_bits); | 3453 return bit_cast<float, int32_t>(result_bits); |
3704 } | 3454 } |
3705 | 3455 |
3706 | |
3707 ASSEMBLER_TEST_GENERATE(Vrecpeqs, assembler) { | 3456 ASSEMBLER_TEST_GENERATE(Vrecpeqs, assembler) { |
3708 if (TargetCPUFeatures::neon_supported()) { | 3457 if (TargetCPUFeatures::neon_supported()) { |
3709 __ LoadSImmediate(S4, 147.0); | 3458 __ LoadSImmediate(S4, 147.0); |
3710 __ vmovs(S5, S4); | 3459 __ vmovs(S5, S4); |
3711 __ vmovs(S6, S4); | 3460 __ vmovs(S6, S4); |
3712 __ vmovs(S7, S4); | 3461 __ vmovs(S7, S4); |
3713 __ vrecpeqs(Q0, Q1); | 3462 __ vrecpeqs(Q0, Q1); |
3714 } | 3463 } |
3715 __ bx(LR); | 3464 __ bx(LR); |
3716 } | 3465 } |
3717 | 3466 |
3718 | |
3719 ASSEMBLER_TEST_RUN(Vrecpeqs, test) { | 3467 ASSEMBLER_TEST_RUN(Vrecpeqs, test) { |
3720 EXPECT(test != NULL); | 3468 EXPECT(test != NULL); |
3721 if (TargetCPUFeatures::neon_supported()) { | 3469 if (TargetCPUFeatures::neon_supported()) { |
3722 typedef float (*Vrecpeqs)() DART_UNUSED; | 3470 typedef float (*Vrecpeqs)() DART_UNUSED; |
3723 float res = EXECUTE_TEST_CODE_FLOAT(Vrecpeqs, test->entry()); | 3471 float res = EXECUTE_TEST_CODE_FLOAT(Vrecpeqs, test->entry()); |
3724 EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001f); | 3472 EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001f); |
3725 } | 3473 } |
3726 } | 3474 } |
3727 | 3475 |
3728 | |
3729 ASSEMBLER_TEST_GENERATE(Vrecpsqs, assembler) { | 3476 ASSEMBLER_TEST_GENERATE(Vrecpsqs, assembler) { |
3730 if (TargetCPUFeatures::neon_supported()) { | 3477 if (TargetCPUFeatures::neon_supported()) { |
3731 __ LoadSImmediate(S4, 5.0); | 3478 __ LoadSImmediate(S4, 5.0); |
3732 __ LoadSImmediate(S5, 2.0); | 3479 __ LoadSImmediate(S5, 2.0); |
3733 __ LoadSImmediate(S6, 3.0); | 3480 __ LoadSImmediate(S6, 3.0); |
3734 __ LoadSImmediate(S7, 4.0); | 3481 __ LoadSImmediate(S7, 4.0); |
3735 | 3482 |
3736 __ LoadSImmediate(S8, 10.0); | 3483 __ LoadSImmediate(S8, 10.0); |
3737 __ LoadSImmediate(S9, 1.0); | 3484 __ LoadSImmediate(S9, 1.0); |
3738 __ LoadSImmediate(S10, 6.0); | 3485 __ LoadSImmediate(S10, 6.0); |
3739 __ LoadSImmediate(S11, 3.0); | 3486 __ LoadSImmediate(S11, 3.0); |
3740 | 3487 |
3741 __ vrecpsqs(Q0, Q1, Q2); | 3488 __ vrecpsqs(Q0, Q1, Q2); |
3742 } | 3489 } |
3743 __ bx(LR); | 3490 __ bx(LR); |
3744 } | 3491 } |
3745 | 3492 |
3746 | |
3747 ASSEMBLER_TEST_RUN(Vrecpsqs, test) { | 3493 ASSEMBLER_TEST_RUN(Vrecpsqs, test) { |
3748 EXPECT(test != NULL); | 3494 EXPECT(test != NULL); |
3749 if (TargetCPUFeatures::neon_supported()) { | 3495 if (TargetCPUFeatures::neon_supported()) { |
3750 typedef float (*Vrecpsqs)() DART_UNUSED; | 3496 typedef float (*Vrecpsqs)() DART_UNUSED; |
3751 float res = EXECUTE_TEST_CODE_FLOAT(Vrecpsqs, test->entry()); | 3497 float res = EXECUTE_TEST_CODE_FLOAT(Vrecpsqs, test->entry()); |
3752 EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001f); | 3498 EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001f); |
3753 } | 3499 } |
3754 } | 3500 } |
3755 | 3501 |
3756 | |
3757 ASSEMBLER_TEST_GENERATE(Reciprocal, assembler) { | 3502 ASSEMBLER_TEST_GENERATE(Reciprocal, assembler) { |
3758 if (TargetCPUFeatures::neon_supported()) { | 3503 if (TargetCPUFeatures::neon_supported()) { |
3759 __ LoadSImmediate(S4, 147000.0); | 3504 __ LoadSImmediate(S4, 147000.0); |
3760 __ vmovs(S5, S4); | 3505 __ vmovs(S5, S4); |
3761 __ vmovs(S6, S4); | 3506 __ vmovs(S6, S4); |
3762 __ vmovs(S7, S4); | 3507 __ vmovs(S7, S4); |
3763 | 3508 |
3764 // Reciprocal estimate. | 3509 // Reciprocal estimate. |
3765 __ vrecpeqs(Q0, Q1); | 3510 __ vrecpeqs(Q0, Q1); |
3766 // 2 Newton-Raphson steps. | 3511 // 2 Newton-Raphson steps. |
3767 __ vrecpsqs(Q2, Q1, Q0); | 3512 __ vrecpsqs(Q2, Q1, Q0); |
3768 __ vmulqs(Q0, Q0, Q2); | 3513 __ vmulqs(Q0, Q0, Q2); |
3769 __ vrecpsqs(Q2, Q1, Q0); | 3514 __ vrecpsqs(Q2, Q1, Q0); |
3770 __ vmulqs(Q0, Q0, Q2); | 3515 __ vmulqs(Q0, Q0, Q2); |
3771 } | 3516 } |
3772 __ bx(LR); | 3517 __ bx(LR); |
3773 } | 3518 } |
3774 | 3519 |
3775 | |
3776 ASSEMBLER_TEST_RUN(Reciprocal, test) { | 3520 ASSEMBLER_TEST_RUN(Reciprocal, test) { |
3777 EXPECT(test != NULL); | 3521 EXPECT(test != NULL); |
3778 if (TargetCPUFeatures::neon_supported()) { | 3522 if (TargetCPUFeatures::neon_supported()) { |
3779 typedef float (*Reciprocal)() DART_UNUSED; | 3523 typedef float (*Reciprocal)() DART_UNUSED; |
3780 float res = EXECUTE_TEST_CODE_FLOAT(Reciprocal, test->entry()); | 3524 float res = EXECUTE_TEST_CODE_FLOAT(Reciprocal, test->entry()); |
3781 EXPECT_FLOAT_EQ(1.0 / 147000.0, res, 0.0001f); | 3525 EXPECT_FLOAT_EQ(1.0 / 147000.0, res, 0.0001f); |
3782 } | 3526 } |
3783 } | 3527 } |
3784 | 3528 |
3785 | |
3786 static float arm_reciprocal_sqrt_estimate(float a) { | 3529 static float arm_reciprocal_sqrt_estimate(float a) { |
3787 // From the ARM Architecture Reference Manual A2-87. | 3530 // From the ARM Architecture Reference Manual A2-87. |
3788 if (isinf(a) || (fabs(a) >= exp2f(126))) | 3531 if (isinf(a) || (fabs(a) >= exp2f(126))) |
3789 return 0.0; | 3532 return 0.0; |
3790 else if (a == 0.0) | 3533 else if (a == 0.0) |
3791 return kPosInfinity; | 3534 return kPosInfinity; |
3792 else if (isnan(a)) | 3535 else if (isnan(a)) |
3793 return a; | 3536 return a; |
3794 | 3537 |
3795 uint32_t a_bits = bit_cast<uint32_t, float>(a); | 3538 uint32_t a_bits = bit_cast<uint32_t, float>(a); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3830 double estimate = static_cast<double>(s) / 256.0; | 3573 double estimate = static_cast<double>(s) / 256.0; |
3831 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); | 3574 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); |
3832 | 3575 |
3833 // result = 0 : result_exp<7:0> : estimate<51:29> | 3576 // result = 0 : result_exp<7:0> : estimate<51:29> |
3834 int32_t result_bits = | 3577 int32_t result_bits = |
3835 ((result_exp & 0xff) << 23) | | 3578 ((result_exp & 0xff) << 23) | |
3836 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); | 3579 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); |
3837 return bit_cast<float, int32_t>(result_bits); | 3580 return bit_cast<float, int32_t>(result_bits); |
3838 } | 3581 } |
3839 | 3582 |
3840 | |
3841 ASSEMBLER_TEST_GENERATE(Vrsqrteqs, assembler) { | 3583 ASSEMBLER_TEST_GENERATE(Vrsqrteqs, assembler) { |
3842 if (TargetCPUFeatures::neon_supported()) { | 3584 if (TargetCPUFeatures::neon_supported()) { |
3843 __ LoadSImmediate(S4, 147.0); | 3585 __ LoadSImmediate(S4, 147.0); |
3844 __ vmovs(S5, S4); | 3586 __ vmovs(S5, S4); |
3845 __ vmovs(S6, S4); | 3587 __ vmovs(S6, S4); |
3846 __ vmovs(S7, S4); | 3588 __ vmovs(S7, S4); |
3847 | 3589 |
3848 __ vrsqrteqs(Q0, Q1); | 3590 __ vrsqrteqs(Q0, Q1); |
3849 } | 3591 } |
3850 __ bx(LR); | 3592 __ bx(LR); |
3851 } | 3593 } |
3852 | 3594 |
3853 | |
3854 ASSEMBLER_TEST_RUN(Vrsqrteqs, test) { | 3595 ASSEMBLER_TEST_RUN(Vrsqrteqs, test) { |
3855 EXPECT(test != NULL); | 3596 EXPECT(test != NULL); |
3856 if (TargetCPUFeatures::neon_supported()) { | 3597 if (TargetCPUFeatures::neon_supported()) { |
3857 typedef float (*Vrsqrteqs)() DART_UNUSED; | 3598 typedef float (*Vrsqrteqs)() DART_UNUSED; |
3858 float res = EXECUTE_TEST_CODE_FLOAT(Vrsqrteqs, test->entry()); | 3599 float res = EXECUTE_TEST_CODE_FLOAT(Vrsqrteqs, test->entry()); |
3859 EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001f); | 3600 EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001f); |
3860 } | 3601 } |
3861 } | 3602 } |
3862 | 3603 |
3863 | |
3864 ASSEMBLER_TEST_GENERATE(Vrsqrtsqs, assembler) { | 3604 ASSEMBLER_TEST_GENERATE(Vrsqrtsqs, assembler) { |
3865 if (TargetCPUFeatures::neon_supported()) { | 3605 if (TargetCPUFeatures::neon_supported()) { |
3866 __ LoadSImmediate(S4, 5.0); | 3606 __ LoadSImmediate(S4, 5.0); |
3867 __ LoadSImmediate(S5, 2.0); | 3607 __ LoadSImmediate(S5, 2.0); |
3868 __ LoadSImmediate(S6, 3.0); | 3608 __ LoadSImmediate(S6, 3.0); |
3869 __ LoadSImmediate(S7, 4.0); | 3609 __ LoadSImmediate(S7, 4.0); |
3870 | 3610 |
3871 __ LoadSImmediate(S8, 10.0); | 3611 __ LoadSImmediate(S8, 10.0); |
3872 __ LoadSImmediate(S9, 1.0); | 3612 __ LoadSImmediate(S9, 1.0); |
3873 __ LoadSImmediate(S10, 6.0); | 3613 __ LoadSImmediate(S10, 6.0); |
3874 __ LoadSImmediate(S11, 3.0); | 3614 __ LoadSImmediate(S11, 3.0); |
3875 | 3615 |
3876 __ vrsqrtsqs(Q0, Q1, Q2); | 3616 __ vrsqrtsqs(Q0, Q1, Q2); |
3877 } | 3617 } |
3878 __ bx(LR); | 3618 __ bx(LR); |
3879 } | 3619 } |
3880 | 3620 |
3881 | |
3882 ASSEMBLER_TEST_RUN(Vrsqrtsqs, test) { | 3621 ASSEMBLER_TEST_RUN(Vrsqrtsqs, test) { |
3883 EXPECT(test != NULL); | 3622 EXPECT(test != NULL); |
3884 if (TargetCPUFeatures::neon_supported()) { | 3623 if (TargetCPUFeatures::neon_supported()) { |
3885 typedef float (*Vrsqrtsqs)() DART_UNUSED; | 3624 typedef float (*Vrsqrtsqs)() DART_UNUSED; |
3886 float res = EXECUTE_TEST_CODE_FLOAT(Vrsqrtsqs, test->entry()); | 3625 float res = EXECUTE_TEST_CODE_FLOAT(Vrsqrtsqs, test->entry()); |
3887 EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0) / 2.0, res, 0.0001f); | 3626 EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0) / 2.0, res, 0.0001f); |
3888 } | 3627 } |
3889 } | 3628 } |
3890 | 3629 |
3891 | |
3892 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) { | 3630 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) { |
3893 if (TargetCPUFeatures::neon_supported()) { | 3631 if (TargetCPUFeatures::neon_supported()) { |
3894 __ LoadSImmediate(S4, 147000.0); | 3632 __ LoadSImmediate(S4, 147000.0); |
3895 __ vmovs(S5, S4); | 3633 __ vmovs(S5, S4); |
3896 __ vmovs(S6, S4); | 3634 __ vmovs(S6, S4); |
3897 __ vmovs(S7, S4); | 3635 __ vmovs(S7, S4); |
3898 | 3636 |
3899 // Reciprocal square root estimate. | 3637 // Reciprocal square root estimate. |
3900 __ vrsqrteqs(Q0, Q1); | 3638 __ vrsqrteqs(Q0, Q1); |
3901 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. | 3639 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. |
3902 // First step. | 3640 // First step. |
3903 __ vmulqs(Q2, Q0, Q0); // Q2 <- xn^2 | 3641 __ vmulqs(Q2, Q0, Q0); // Q2 <- xn^2 |
3904 __ vrsqrtsqs(Q2, Q1, Q2); // Q2 <- (3 - Q1*Q2) / 2. | 3642 __ vrsqrtsqs(Q2, Q1, Q2); // Q2 <- (3 - Q1*Q2) / 2. |
3905 __ vmulqs(Q0, Q0, Q2); // xn+1 <- xn * Q2 | 3643 __ vmulqs(Q0, Q0, Q2); // xn+1 <- xn * Q2 |
3906 // Second step. | 3644 // Second step. |
3907 __ vmulqs(Q2, Q0, Q0); | 3645 __ vmulqs(Q2, Q0, Q0); |
3908 __ vrsqrtsqs(Q2, Q1, Q2); | 3646 __ vrsqrtsqs(Q2, Q1, Q2); |
3909 __ vmulqs(Q0, Q0, Q2); | 3647 __ vmulqs(Q0, Q0, Q2); |
3910 } | 3648 } |
3911 __ bx(LR); | 3649 __ bx(LR); |
3912 } | 3650 } |
3913 | 3651 |
3914 | |
3915 ASSEMBLER_TEST_RUN(ReciprocalSqrt, test) { | 3652 ASSEMBLER_TEST_RUN(ReciprocalSqrt, test) { |
3916 EXPECT(test != NULL); | 3653 EXPECT(test != NULL); |
3917 if (TargetCPUFeatures::neon_supported()) { | 3654 if (TargetCPUFeatures::neon_supported()) { |
3918 typedef float (*ReciprocalSqrt)() DART_UNUSED; | 3655 typedef float (*ReciprocalSqrt)() DART_UNUSED; |
3919 float res = EXECUTE_TEST_CODE_FLOAT(ReciprocalSqrt, test->entry()); | 3656 float res = EXECUTE_TEST_CODE_FLOAT(ReciprocalSqrt, test->entry()); |
3920 EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001f); | 3657 EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001f); |
3921 } | 3658 } |
3922 } | 3659 } |
3923 | 3660 |
3924 | |
3925 ASSEMBLER_TEST_GENERATE(SIMDSqrt, assembler) { | 3661 ASSEMBLER_TEST_GENERATE(SIMDSqrt, assembler) { |
3926 if (TargetCPUFeatures::neon_supported()) { | 3662 if (TargetCPUFeatures::neon_supported()) { |
3927 __ LoadSImmediate(S4, 147000.0); | 3663 __ LoadSImmediate(S4, 147000.0); |
3928 __ vmovs(S5, S4); | 3664 __ vmovs(S5, S4); |
3929 __ vmovs(S6, S4); | 3665 __ vmovs(S6, S4); |
3930 __ vmovs(S7, S4); | 3666 __ vmovs(S7, S4); |
3931 | 3667 |
3932 // Reciprocal square root estimate. | 3668 // Reciprocal square root estimate. |
3933 __ vrsqrteqs(Q0, Q1); | 3669 __ vrsqrteqs(Q0, Q1); |
3934 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. | 3670 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. |
(...skipping 12 matching lines...) Expand all Loading... |
3947 __ vrecpeqs(Q0, Q1); | 3683 __ vrecpeqs(Q0, Q1); |
3948 // 2 Newton-Raphson steps. | 3684 // 2 Newton-Raphson steps. |
3949 __ vrecpsqs(Q2, Q1, Q0); | 3685 __ vrecpsqs(Q2, Q1, Q0); |
3950 __ vmulqs(Q0, Q0, Q2); | 3686 __ vmulqs(Q0, Q0, Q2); |
3951 __ vrecpsqs(Q2, Q1, Q0); | 3687 __ vrecpsqs(Q2, Q1, Q0); |
3952 __ vmulqs(Q0, Q0, Q2); | 3688 __ vmulqs(Q0, Q0, Q2); |
3953 } | 3689 } |
3954 __ bx(LR); | 3690 __ bx(LR); |
3955 } | 3691 } |
3956 | 3692 |
3957 | |
3958 ASSEMBLER_TEST_RUN(SIMDSqrt, test) { | 3693 ASSEMBLER_TEST_RUN(SIMDSqrt, test) { |
3959 EXPECT(test != NULL); | 3694 EXPECT(test != NULL); |
3960 if (TargetCPUFeatures::neon_supported()) { | 3695 if (TargetCPUFeatures::neon_supported()) { |
3961 typedef float (*SIMDSqrt)() DART_UNUSED; | 3696 typedef float (*SIMDSqrt)() DART_UNUSED; |
3962 float res = EXECUTE_TEST_CODE_FLOAT(SIMDSqrt, test->entry()); | 3697 float res = EXECUTE_TEST_CODE_FLOAT(SIMDSqrt, test->entry()); |
3963 EXPECT_FLOAT_EQ(sqrt(147000.0), res, 0.0001f); | 3698 EXPECT_FLOAT_EQ(sqrt(147000.0), res, 0.0001f); |
3964 } | 3699 } |
3965 } | 3700 } |
3966 | 3701 |
3967 | |
3968 ASSEMBLER_TEST_GENERATE(SIMDSqrt2, assembler) { | 3702 ASSEMBLER_TEST_GENERATE(SIMDSqrt2, assembler) { |
3969 if (TargetCPUFeatures::neon_supported()) { | 3703 if (TargetCPUFeatures::neon_supported()) { |
3970 __ LoadSImmediate(S4, 1.0); | 3704 __ LoadSImmediate(S4, 1.0); |
3971 __ LoadSImmediate(S5, 4.0); | 3705 __ LoadSImmediate(S5, 4.0); |
3972 __ LoadSImmediate(S6, 9.0); | 3706 __ LoadSImmediate(S6, 9.0); |
3973 __ LoadSImmediate(S7, 16.0); | 3707 __ LoadSImmediate(S7, 16.0); |
3974 | 3708 |
3975 // Reciprocal square root estimate. | 3709 // Reciprocal square root estimate. |
3976 __ vrsqrteqs(Q0, Q1); | 3710 __ vrsqrteqs(Q0, Q1); |
3977 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. | 3711 // 2 Newton-Raphson steps. xn+1 = xn * (3 - Q1*xn^2) / 2. |
(...skipping 16 matching lines...) Expand all Loading... |
3994 __ vrecpsqs(Q2, Q1, Q0); | 3728 __ vrecpsqs(Q2, Q1, Q0); |
3995 __ vmulqs(Q0, Q0, Q2); | 3729 __ vmulqs(Q0, Q0, Q2); |
3996 | 3730 |
3997 __ vadds(S0, S0, S1); | 3731 __ vadds(S0, S0, S1); |
3998 __ vadds(S0, S0, S2); | 3732 __ vadds(S0, S0, S2); |
3999 __ vadds(S0, S0, S3); | 3733 __ vadds(S0, S0, S3); |
4000 } | 3734 } |
4001 __ bx(LR); | 3735 __ bx(LR); |
4002 } | 3736 } |
4003 | 3737 |
4004 | |
4005 ASSEMBLER_TEST_RUN(SIMDSqrt2, test) { | 3738 ASSEMBLER_TEST_RUN(SIMDSqrt2, test) { |
4006 EXPECT(test != NULL); | 3739 EXPECT(test != NULL); |
4007 if (TargetCPUFeatures::neon_supported()) { | 3740 if (TargetCPUFeatures::neon_supported()) { |
4008 typedef float (*SIMDSqrt2)() DART_UNUSED; | 3741 typedef float (*SIMDSqrt2)() DART_UNUSED; |
4009 float res = EXECUTE_TEST_CODE_FLOAT(SIMDSqrt2, test->entry()); | 3742 float res = EXECUTE_TEST_CODE_FLOAT(SIMDSqrt2, test->entry()); |
4010 EXPECT_FLOAT_EQ(10.0, res, 0.0001f); | 3743 EXPECT_FLOAT_EQ(10.0, res, 0.0001f); |
4011 } | 3744 } |
4012 } | 3745 } |
4013 | 3746 |
4014 | |
4015 ASSEMBLER_TEST_GENERATE(SIMDDiv, assembler) { | 3747 ASSEMBLER_TEST_GENERATE(SIMDDiv, assembler) { |
4016 if (TargetCPUFeatures::neon_supported()) { | 3748 if (TargetCPUFeatures::neon_supported()) { |
4017 __ LoadSImmediate(S4, 1.0); | 3749 __ LoadSImmediate(S4, 1.0); |
4018 __ LoadSImmediate(S5, 4.0); | 3750 __ LoadSImmediate(S5, 4.0); |
4019 __ LoadSImmediate(S6, 9.0); | 3751 __ LoadSImmediate(S6, 9.0); |
4020 __ LoadSImmediate(S7, 16.0); | 3752 __ LoadSImmediate(S7, 16.0); |
4021 | 3753 |
4022 __ LoadSImmediate(S12, 4.0); | 3754 __ LoadSImmediate(S12, 4.0); |
4023 __ LoadSImmediate(S13, 16.0); | 3755 __ LoadSImmediate(S13, 16.0); |
4024 __ LoadSImmediate(S14, 36.0); | 3756 __ LoadSImmediate(S14, 36.0); |
4025 __ LoadSImmediate(S15, 64.0); | 3757 __ LoadSImmediate(S15, 64.0); |
4026 | 3758 |
4027 // Reciprocal estimate. | 3759 // Reciprocal estimate. |
4028 __ vrecpeqs(Q0, Q1); | 3760 __ vrecpeqs(Q0, Q1); |
4029 // 2 Newton-Raphson steps. | 3761 // 2 Newton-Raphson steps. |
4030 __ vrecpsqs(Q2, Q1, Q0); | 3762 __ vrecpsqs(Q2, Q1, Q0); |
4031 __ vmulqs(Q0, Q0, Q2); | 3763 __ vmulqs(Q0, Q0, Q2); |
4032 __ vrecpsqs(Q2, Q1, Q0); | 3764 __ vrecpsqs(Q2, Q1, Q0); |
4033 __ vmulqs(Q0, Q0, Q2); | 3765 __ vmulqs(Q0, Q0, Q2); |
4034 | 3766 |
4035 __ vmulqs(Q0, Q3, Q0); | 3767 __ vmulqs(Q0, Q3, Q0); |
4036 __ vadds(S0, S0, S1); | 3768 __ vadds(S0, S0, S1); |
4037 __ vadds(S0, S0, S2); | 3769 __ vadds(S0, S0, S2); |
4038 __ vadds(S0, S0, S3); | 3770 __ vadds(S0, S0, S3); |
4039 } | 3771 } |
4040 __ bx(LR); | 3772 __ bx(LR); |
4041 } | 3773 } |
4042 | 3774 |
4043 | |
4044 ASSEMBLER_TEST_RUN(SIMDDiv, test) { | 3775 ASSEMBLER_TEST_RUN(SIMDDiv, test) { |
4045 EXPECT(test != NULL); | 3776 EXPECT(test != NULL); |
4046 if (TargetCPUFeatures::neon_supported()) { | 3777 if (TargetCPUFeatures::neon_supported()) { |
4047 typedef float (*SIMDDiv)() DART_UNUSED; | 3778 typedef float (*SIMDDiv)() DART_UNUSED; |
4048 float res = EXECUTE_TEST_CODE_FLOAT(SIMDDiv, test->entry()); | 3779 float res = EXECUTE_TEST_CODE_FLOAT(SIMDDiv, test->entry()); |
4049 EXPECT_FLOAT_EQ(16.0, res, 0.0001f); | 3780 EXPECT_FLOAT_EQ(16.0, res, 0.0001f); |
4050 } | 3781 } |
4051 } | 3782 } |
4052 | 3783 |
4053 | |
4054 ASSEMBLER_TEST_GENERATE(Vabsqs, assembler) { | 3784 ASSEMBLER_TEST_GENERATE(Vabsqs, assembler) { |
4055 if (TargetCPUFeatures::neon_supported()) { | 3785 if (TargetCPUFeatures::neon_supported()) { |
4056 __ LoadSImmediate(S4, 1.0); | 3786 __ LoadSImmediate(S4, 1.0); |
4057 __ LoadSImmediate(S5, -1.0); | 3787 __ LoadSImmediate(S5, -1.0); |
4058 __ LoadSImmediate(S6, 1.0); | 3788 __ LoadSImmediate(S6, 1.0); |
4059 __ LoadSImmediate(S7, -1.0); | 3789 __ LoadSImmediate(S7, -1.0); |
4060 | 3790 |
4061 __ vabsqs(Q0, Q1); | 3791 __ vabsqs(Q0, Q1); |
4062 | 3792 |
4063 __ vadds(S0, S0, S1); | 3793 __ vadds(S0, S0, S1); |
4064 __ vadds(S0, S0, S2); | 3794 __ vadds(S0, S0, S2); |
4065 __ vadds(S0, S0, S3); | 3795 __ vadds(S0, S0, S3); |
4066 } | 3796 } |
4067 __ bx(LR); | 3797 __ bx(LR); |
4068 } | 3798 } |
4069 | 3799 |
4070 | |
4071 ASSEMBLER_TEST_RUN(Vabsqs, test) { | 3800 ASSEMBLER_TEST_RUN(Vabsqs, test) { |
4072 EXPECT(test != NULL); | 3801 EXPECT(test != NULL); |
4073 if (TargetCPUFeatures::neon_supported()) { | 3802 if (TargetCPUFeatures::neon_supported()) { |
4074 typedef float (*Vabsqs)() DART_UNUSED; | 3803 typedef float (*Vabsqs)() DART_UNUSED; |
4075 float res = EXECUTE_TEST_CODE_FLOAT(Vabsqs, test->entry()); | 3804 float res = EXECUTE_TEST_CODE_FLOAT(Vabsqs, test->entry()); |
4076 EXPECT_FLOAT_EQ(4.0, res, 0.0001f); | 3805 EXPECT_FLOAT_EQ(4.0, res, 0.0001f); |
4077 } | 3806 } |
4078 } | 3807 } |
4079 | 3808 |
4080 | |
4081 ASSEMBLER_TEST_GENERATE(Vnegqs, assembler) { | 3809 ASSEMBLER_TEST_GENERATE(Vnegqs, assembler) { |
4082 if (TargetCPUFeatures::neon_supported()) { | 3810 if (TargetCPUFeatures::neon_supported()) { |
4083 __ LoadSImmediate(S4, 1.0); | 3811 __ LoadSImmediate(S4, 1.0); |
4084 __ LoadSImmediate(S5, -2.0); | 3812 __ LoadSImmediate(S5, -2.0); |
4085 __ LoadSImmediate(S6, 1.0); | 3813 __ LoadSImmediate(S6, 1.0); |
4086 __ LoadSImmediate(S7, -2.0); | 3814 __ LoadSImmediate(S7, -2.0); |
4087 | 3815 |
4088 __ vnegqs(Q0, Q1); | 3816 __ vnegqs(Q0, Q1); |
4089 | 3817 |
4090 __ vadds(S0, S0, S1); | 3818 __ vadds(S0, S0, S1); |
4091 __ vadds(S0, S0, S2); | 3819 __ vadds(S0, S0, S2); |
4092 __ vadds(S0, S0, S3); | 3820 __ vadds(S0, S0, S3); |
4093 } | 3821 } |
4094 __ bx(LR); | 3822 __ bx(LR); |
4095 } | 3823 } |
4096 | 3824 |
4097 | |
4098 ASSEMBLER_TEST_RUN(Vnegqs, test) { | 3825 ASSEMBLER_TEST_RUN(Vnegqs, test) { |
4099 EXPECT(test != NULL); | 3826 EXPECT(test != NULL); |
4100 if (TargetCPUFeatures::neon_supported()) { | 3827 if (TargetCPUFeatures::neon_supported()) { |
4101 typedef float (*Vnegqs)() DART_UNUSED; | 3828 typedef float (*Vnegqs)() DART_UNUSED; |
4102 float res = EXECUTE_TEST_CODE_FLOAT(Vnegqs, test->entry()); | 3829 float res = EXECUTE_TEST_CODE_FLOAT(Vnegqs, test->entry()); |
4103 EXPECT_FLOAT_EQ(2.0, res, 0.0001f); | 3830 EXPECT_FLOAT_EQ(2.0, res, 0.0001f); |
4104 } | 3831 } |
4105 } | 3832 } |
4106 | 3833 |
4107 | |
4108 // Called from assembler_test.cc. | 3834 // Called from assembler_test.cc. |
4109 // LR: return address. | 3835 // LR: return address. |
4110 // R0: value. | 3836 // R0: value. |
4111 // R1: growable array. | 3837 // R1: growable array. |
4112 // R2: current thread. | 3838 // R2: current thread. |
4113 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) { | 3839 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) { |
4114 __ PushList((1 << LR) | (1 << THR)); | 3840 __ PushList((1 << LR) | (1 << THR)); |
4115 __ mov(THR, Operand(R2)); | 3841 __ mov(THR, Operand(R2)); |
4116 __ StoreIntoObject(R1, FieldAddress(R1, GrowableObjectArray::data_offset()), | 3842 __ StoreIntoObject(R1, FieldAddress(R1, GrowableObjectArray::data_offset()), |
4117 R0); | 3843 R0); |
4118 __ PopList((1 << LR) | (1 << THR)); | 3844 __ PopList((1 << LR) | (1 << THR)); |
4119 __ Ret(); | 3845 __ Ret(); |
4120 } | 3846 } |
4121 | 3847 |
4122 } // namespace dart | 3848 } // namespace dart |
4123 | 3849 |
4124 #endif // defined TARGET_ARCH_ARM | 3850 #endif // defined TARGET_ARCH_ARM |
OLD | NEW |