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_ARM64) | 6 #if defined(TARGET_ARCH_ARM64) |
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 ASSEMBLER_TEST_GENERATE(Simple, assembler) { | 18 ASSEMBLER_TEST_GENERATE(Simple, assembler) { |
19 __ add(R0, ZR, Operand(ZR)); | 19 __ add(R0, ZR, Operand(ZR)); |
20 __ add(R0, R0, Operand(42)); | 20 __ add(R0, R0, Operand(42)); |
21 __ ret(); | 21 __ ret(); |
22 } | 22 } |
23 | 23 |
24 | |
25 ASSEMBLER_TEST_RUN(Simple, test) { | 24 ASSEMBLER_TEST_RUN(Simple, test) { |
26 typedef int64_t (*Int64Return)() DART_UNUSED; | 25 typedef int64_t (*Int64Return)() DART_UNUSED; |
27 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 26 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
28 } | 27 } |
29 | 28 |
30 | |
31 // Move wide immediate tests. | 29 // Move wide immediate tests. |
32 // movz | 30 // movz |
33 ASSEMBLER_TEST_GENERATE(Movz0, assembler) { | 31 ASSEMBLER_TEST_GENERATE(Movz0, assembler) { |
34 __ movz(R0, Immediate(42), 0); | 32 __ movz(R0, Immediate(42), 0); |
35 __ ret(); | 33 __ ret(); |
36 } | 34 } |
37 | 35 |
38 | |
39 ASSEMBLER_TEST_RUN(Movz0, test) { | 36 ASSEMBLER_TEST_RUN(Movz0, test) { |
40 typedef int64_t (*Int64Return)() DART_UNUSED; | 37 typedef int64_t (*Int64Return)() DART_UNUSED; |
41 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 38 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
42 } | 39 } |
43 | 40 |
44 | |
45 ASSEMBLER_TEST_GENERATE(Movz1, assembler) { | 41 ASSEMBLER_TEST_GENERATE(Movz1, assembler) { |
46 __ movz(R0, Immediate(42), 0); // Overwritten by next instruction. | 42 __ movz(R0, Immediate(42), 0); // Overwritten by next instruction. |
47 __ movz(R0, Immediate(42), 1); | 43 __ movz(R0, Immediate(42), 1); |
48 __ ret(); | 44 __ ret(); |
49 } | 45 } |
50 | 46 |
51 | |
52 ASSEMBLER_TEST_RUN(Movz1, test) { | 47 ASSEMBLER_TEST_RUN(Movz1, test) { |
53 typedef int64_t (*Int64Return)() DART_UNUSED; | 48 typedef int64_t (*Int64Return)() DART_UNUSED; |
54 EXPECT_EQ(42LL << 16, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 49 EXPECT_EQ(42LL << 16, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
55 } | 50 } |
56 | 51 |
57 | |
58 ASSEMBLER_TEST_GENERATE(Movz2, assembler) { | 52 ASSEMBLER_TEST_GENERATE(Movz2, assembler) { |
59 __ movz(R0, Immediate(42), 2); | 53 __ movz(R0, Immediate(42), 2); |
60 __ ret(); | 54 __ ret(); |
61 } | 55 } |
62 | 56 |
63 | |
64 ASSEMBLER_TEST_RUN(Movz2, test) { | 57 ASSEMBLER_TEST_RUN(Movz2, test) { |
65 typedef int64_t (*Int64Return)() DART_UNUSED; | 58 typedef int64_t (*Int64Return)() DART_UNUSED; |
66 EXPECT_EQ(42LL << 32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 59 EXPECT_EQ(42LL << 32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
67 } | 60 } |
68 | 61 |
69 | |
70 ASSEMBLER_TEST_GENERATE(Movz3, assembler) { | 62 ASSEMBLER_TEST_GENERATE(Movz3, assembler) { |
71 __ movz(R0, Immediate(42), 3); | 63 __ movz(R0, Immediate(42), 3); |
72 __ ret(); | 64 __ ret(); |
73 } | 65 } |
74 | 66 |
75 | |
76 ASSEMBLER_TEST_RUN(Movz3, test) { | 67 ASSEMBLER_TEST_RUN(Movz3, test) { |
77 typedef int64_t (*Int64Return)() DART_UNUSED; | 68 typedef int64_t (*Int64Return)() DART_UNUSED; |
78 EXPECT_EQ(42LL << 48, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 69 EXPECT_EQ(42LL << 48, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
79 } | 70 } |
80 | 71 |
81 | |
82 // movn | 72 // movn |
83 ASSEMBLER_TEST_GENERATE(Movn0, assembler) { | 73 ASSEMBLER_TEST_GENERATE(Movn0, assembler) { |
84 __ movn(R0, Immediate(42), 0); | 74 __ movn(R0, Immediate(42), 0); |
85 __ ret(); | 75 __ ret(); |
86 } | 76 } |
87 | 77 |
88 | |
89 ASSEMBLER_TEST_RUN(Movn0, test) { | 78 ASSEMBLER_TEST_RUN(Movn0, test) { |
90 typedef int64_t (*Int64Return)() DART_UNUSED; | 79 typedef int64_t (*Int64Return)() DART_UNUSED; |
91 EXPECT_EQ(~42LL, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 80 EXPECT_EQ(~42LL, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
92 } | 81 } |
93 | 82 |
94 | |
95 ASSEMBLER_TEST_GENERATE(Movn1, assembler) { | 83 ASSEMBLER_TEST_GENERATE(Movn1, assembler) { |
96 __ movn(R0, Immediate(42), 1); | 84 __ movn(R0, Immediate(42), 1); |
97 __ ret(); | 85 __ ret(); |
98 } | 86 } |
99 | 87 |
100 | |
101 ASSEMBLER_TEST_RUN(Movn1, test) { | 88 ASSEMBLER_TEST_RUN(Movn1, test) { |
102 typedef int64_t (*Int64Return)() DART_UNUSED; | 89 typedef int64_t (*Int64Return)() DART_UNUSED; |
103 EXPECT_EQ(~(42LL << 16), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 90 EXPECT_EQ(~(42LL << 16), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
104 } | 91 } |
105 | 92 |
106 | |
107 ASSEMBLER_TEST_GENERATE(Movn2, assembler) { | 93 ASSEMBLER_TEST_GENERATE(Movn2, assembler) { |
108 __ movn(R0, Immediate(42), 2); | 94 __ movn(R0, Immediate(42), 2); |
109 __ ret(); | 95 __ ret(); |
110 } | 96 } |
111 | 97 |
112 | |
113 ASSEMBLER_TEST_RUN(Movn2, test) { | 98 ASSEMBLER_TEST_RUN(Movn2, test) { |
114 typedef int64_t (*Int64Return)() DART_UNUSED; | 99 typedef int64_t (*Int64Return)() DART_UNUSED; |
115 EXPECT_EQ(~(42LL << 32), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 100 EXPECT_EQ(~(42LL << 32), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
116 } | 101 } |
117 | 102 |
118 | |
119 ASSEMBLER_TEST_GENERATE(Movn3, assembler) { | 103 ASSEMBLER_TEST_GENERATE(Movn3, assembler) { |
120 __ movn(R0, Immediate(42), 3); | 104 __ movn(R0, Immediate(42), 3); |
121 __ ret(); | 105 __ ret(); |
122 } | 106 } |
123 | 107 |
124 | |
125 ASSEMBLER_TEST_RUN(Movn3, test) { | 108 ASSEMBLER_TEST_RUN(Movn3, test) { |
126 typedef int64_t (*Int64Return)() DART_UNUSED; | 109 typedef int64_t (*Int64Return)() DART_UNUSED; |
127 EXPECT_EQ(~(42LL << 48), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 110 EXPECT_EQ(~(42LL << 48), EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
128 } | 111 } |
129 | 112 |
130 // movk | 113 // movk |
131 ASSEMBLER_TEST_GENERATE(Movk0, assembler) { | 114 ASSEMBLER_TEST_GENERATE(Movk0, assembler) { |
132 __ movz(R0, Immediate(1), 3); | 115 __ movz(R0, Immediate(1), 3); |
133 __ movk(R0, Immediate(42), 0); | 116 __ movk(R0, Immediate(42), 0); |
134 __ ret(); | 117 __ ret(); |
135 } | 118 } |
136 | 119 |
137 | |
138 ASSEMBLER_TEST_RUN(Movk0, test) { | 120 ASSEMBLER_TEST_RUN(Movk0, test) { |
139 typedef int64_t (*Int64Return)() DART_UNUSED; | 121 typedef int64_t (*Int64Return)() DART_UNUSED; |
140 EXPECT_EQ(42LL | (1LL << 48), | 122 EXPECT_EQ(42LL | (1LL << 48), |
141 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 123 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
142 } | 124 } |
143 | 125 |
144 | |
145 ASSEMBLER_TEST_GENERATE(Movk1, assembler) { | 126 ASSEMBLER_TEST_GENERATE(Movk1, assembler) { |
146 __ movz(R0, Immediate(1), 0); | 127 __ movz(R0, Immediate(1), 0); |
147 __ movk(R0, Immediate(42), 1); | 128 __ movk(R0, Immediate(42), 1); |
148 __ ret(); | 129 __ ret(); |
149 } | 130 } |
150 | 131 |
151 | |
152 ASSEMBLER_TEST_RUN(Movk1, test) { | 132 ASSEMBLER_TEST_RUN(Movk1, test) { |
153 typedef int64_t (*Int64Return)() DART_UNUSED; | 133 typedef int64_t (*Int64Return)() DART_UNUSED; |
154 EXPECT_EQ((42LL << 16) | 1, | 134 EXPECT_EQ((42LL << 16) | 1, |
155 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 135 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
156 } | 136 } |
157 | 137 |
158 | |
159 ASSEMBLER_TEST_GENERATE(Movk2, assembler) { | 138 ASSEMBLER_TEST_GENERATE(Movk2, assembler) { |
160 __ movz(R0, Immediate(1), 0); | 139 __ movz(R0, Immediate(1), 0); |
161 __ movk(R0, Immediate(42), 2); | 140 __ movk(R0, Immediate(42), 2); |
162 __ ret(); | 141 __ ret(); |
163 } | 142 } |
164 | 143 |
165 | |
166 ASSEMBLER_TEST_RUN(Movk2, test) { | 144 ASSEMBLER_TEST_RUN(Movk2, test) { |
167 typedef int64_t (*Int64Return)() DART_UNUSED; | 145 typedef int64_t (*Int64Return)() DART_UNUSED; |
168 EXPECT_EQ((42LL << 32) | 1, | 146 EXPECT_EQ((42LL << 32) | 1, |
169 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 147 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
170 } | 148 } |
171 | 149 |
172 | |
173 ASSEMBLER_TEST_GENERATE(Movk3, assembler) { | 150 ASSEMBLER_TEST_GENERATE(Movk3, assembler) { |
174 __ movz(R0, Immediate(1), 0); | 151 __ movz(R0, Immediate(1), 0); |
175 __ movk(R0, Immediate(42), 3); | 152 __ movk(R0, Immediate(42), 3); |
176 __ ret(); | 153 __ ret(); |
177 } | 154 } |
178 | 155 |
179 | |
180 ASSEMBLER_TEST_RUN(Movk3, test) { | 156 ASSEMBLER_TEST_RUN(Movk3, test) { |
181 typedef int64_t (*Int64Return)() DART_UNUSED; | 157 typedef int64_t (*Int64Return)() DART_UNUSED; |
182 EXPECT_EQ((42LL << 48) | 1, | 158 EXPECT_EQ((42LL << 48) | 1, |
183 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 159 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
184 } | 160 } |
185 | 161 |
186 | |
187 ASSEMBLER_TEST_GENERATE(MovzBig, assembler) { | 162 ASSEMBLER_TEST_GENERATE(MovzBig, assembler) { |
188 __ movz(R0, Immediate(0x8000), 0); | 163 __ movz(R0, Immediate(0x8000), 0); |
189 __ ret(); | 164 __ ret(); |
190 } | 165 } |
191 | 166 |
192 | |
193 ASSEMBLER_TEST_RUN(MovzBig, test) { | 167 ASSEMBLER_TEST_RUN(MovzBig, test) { |
194 typedef int64_t (*Int64Return)() DART_UNUSED; | 168 typedef int64_t (*Int64Return)() DART_UNUSED; |
195 EXPECT_EQ(0x8000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 169 EXPECT_EQ(0x8000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
196 } | 170 } |
197 | 171 |
198 | |
199 // add tests. | 172 // add tests. |
200 ASSEMBLER_TEST_GENERATE(AddReg, assembler) { | 173 ASSEMBLER_TEST_GENERATE(AddReg, assembler) { |
201 __ movz(R0, Immediate(20), 0); | 174 __ movz(R0, Immediate(20), 0); |
202 __ movz(R1, Immediate(22), 0); | 175 __ movz(R1, Immediate(22), 0); |
203 __ add(R0, R0, Operand(R1)); | 176 __ add(R0, R0, Operand(R1)); |
204 __ ret(); | 177 __ ret(); |
205 } | 178 } |
206 | 179 |
207 | |
208 ASSEMBLER_TEST_RUN(AddReg, test) { | 180 ASSEMBLER_TEST_RUN(AddReg, test) { |
209 typedef int64_t (*Int64Return)() DART_UNUSED; | 181 typedef int64_t (*Int64Return)() DART_UNUSED; |
210 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 182 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
211 } | 183 } |
212 | 184 |
213 | |
214 ASSEMBLER_TEST_GENERATE(AddLSLReg, assembler) { | 185 ASSEMBLER_TEST_GENERATE(AddLSLReg, assembler) { |
215 __ movz(R0, Immediate(20), 0); | 186 __ movz(R0, Immediate(20), 0); |
216 __ movz(R1, Immediate(11), 0); | 187 __ movz(R1, Immediate(11), 0); |
217 __ add(R0, R0, Operand(R1, LSL, 1)); | 188 __ add(R0, R0, Operand(R1, LSL, 1)); |
218 __ ret(); | 189 __ ret(); |
219 } | 190 } |
220 | 191 |
221 | |
222 ASSEMBLER_TEST_RUN(AddLSLReg, test) { | 192 ASSEMBLER_TEST_RUN(AddLSLReg, test) { |
223 typedef int64_t (*Int64Return)() DART_UNUSED; | 193 typedef int64_t (*Int64Return)() DART_UNUSED; |
224 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 194 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
225 } | 195 } |
226 | 196 |
227 | |
228 ASSEMBLER_TEST_GENERATE(AddLSRReg, assembler) { | 197 ASSEMBLER_TEST_GENERATE(AddLSRReg, assembler) { |
229 __ movz(R0, Immediate(20), 0); | 198 __ movz(R0, Immediate(20), 0); |
230 __ movz(R1, Immediate(44), 0); | 199 __ movz(R1, Immediate(44), 0); |
231 __ add(R0, R0, Operand(R1, LSR, 1)); | 200 __ add(R0, R0, Operand(R1, LSR, 1)); |
232 __ ret(); | 201 __ ret(); |
233 } | 202 } |
234 | 203 |
235 | |
236 ASSEMBLER_TEST_RUN(AddLSRReg, test) { | 204 ASSEMBLER_TEST_RUN(AddLSRReg, test) { |
237 typedef int64_t (*Int64Return)() DART_UNUSED; | 205 typedef int64_t (*Int64Return)() DART_UNUSED; |
238 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 206 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
239 } | 207 } |
240 | 208 |
241 | |
242 ASSEMBLER_TEST_GENERATE(AddASRReg, assembler) { | 209 ASSEMBLER_TEST_GENERATE(AddASRReg, assembler) { |
243 __ movz(R0, Immediate(20), 0); | 210 __ movz(R0, Immediate(20), 0); |
244 __ movz(R1, Immediate(44), 0); | 211 __ movz(R1, Immediate(44), 0); |
245 __ add(R0, R0, Operand(R1, ASR, 1)); | 212 __ add(R0, R0, Operand(R1, ASR, 1)); |
246 __ ret(); | 213 __ ret(); |
247 } | 214 } |
248 | 215 |
249 | |
250 ASSEMBLER_TEST_RUN(AddASRReg, test) { | 216 ASSEMBLER_TEST_RUN(AddASRReg, test) { |
251 typedef int64_t (*Int64Return)() DART_UNUSED; | 217 typedef int64_t (*Int64Return)() DART_UNUSED; |
252 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 218 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
253 } | 219 } |
254 | 220 |
255 | |
256 ASSEMBLER_TEST_GENERATE(AddASRNegReg, assembler) { | 221 ASSEMBLER_TEST_GENERATE(AddASRNegReg, assembler) { |
257 __ movz(R0, Immediate(43), 0); | 222 __ movz(R0, Immediate(43), 0); |
258 __ movn(R1, Immediate(0), 0); // R1 <- -1 | 223 __ movn(R1, Immediate(0), 0); // R1 <- -1 |
259 __ add(R1, ZR, Operand(R1, LSL, 3)); // R1 <- -8 | 224 __ add(R1, ZR, Operand(R1, LSL, 3)); // R1 <- -8 |
260 __ add(R0, R0, Operand(R1, ASR, 3)); // R0 <- 43 + (-8 >> 3) | 225 __ add(R0, R0, Operand(R1, ASR, 3)); // R0 <- 43 + (-8 >> 3) |
261 __ ret(); | 226 __ ret(); |
262 } | 227 } |
263 | 228 |
264 | |
265 ASSEMBLER_TEST_RUN(AddASRNegReg, test) { | 229 ASSEMBLER_TEST_RUN(AddASRNegReg, test) { |
266 typedef int64_t (*Int64Return)() DART_UNUSED; | 230 typedef int64_t (*Int64Return)() DART_UNUSED; |
267 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 231 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
268 } | 232 } |
269 | 233 |
270 | |
271 // TODO(zra): test other sign extension modes. | 234 // TODO(zra): test other sign extension modes. |
272 ASSEMBLER_TEST_GENERATE(AddExtReg, assembler) { | 235 ASSEMBLER_TEST_GENERATE(AddExtReg, assembler) { |
273 __ movz(R0, Immediate(43), 0); | 236 __ movz(R0, Immediate(43), 0); |
274 __ movz(R1, Immediate(0xffff), 0); | 237 __ movz(R1, Immediate(0xffff), 0); |
275 __ movk(R1, Immediate(0xffff), 1); // R1 <- -1 (32-bit) | 238 __ movk(R1, Immediate(0xffff), 1); // R1 <- -1 (32-bit) |
276 __ add(R0, R0, Operand(R1, SXTW, 0)); // R0 <- R0 + (sign extended R1) | 239 __ add(R0, R0, Operand(R1, SXTW, 0)); // R0 <- R0 + (sign extended R1) |
277 __ ret(); | 240 __ ret(); |
278 } | 241 } |
279 | 242 |
280 | |
281 ASSEMBLER_TEST_RUN(AddExtReg, test) { | 243 ASSEMBLER_TEST_RUN(AddExtReg, test) { |
282 typedef int64_t (*Int64Return)() DART_UNUSED; | 244 typedef int64_t (*Int64Return)() DART_UNUSED; |
283 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 245 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
284 } | 246 } |
285 | 247 |
286 | |
287 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) { | 248 ASSEMBLER_TEST_GENERATE(AddCarryInOut, assembler) { |
288 __ LoadImmediate(R2, -1); | 249 __ LoadImmediate(R2, -1); |
289 __ LoadImmediate(R1, 1); | 250 __ LoadImmediate(R1, 1); |
290 __ LoadImmediate(R0, 0); | 251 __ LoadImmediate(R0, 0); |
291 __ adds(IP0, R2, Operand(R1)); // c_out = 1. | 252 __ adds(IP0, R2, Operand(R1)); // c_out = 1. |
292 __ adcs(IP0, R2, R0); // c_in = 1, c_out = 1. | 253 __ adcs(IP0, R2, R0); // c_in = 1, c_out = 1. |
293 __ adc(R0, R0, R0); // c_in = 1. | 254 __ adc(R0, R0, R0); // c_in = 1. |
294 __ ret(); | 255 __ ret(); |
295 } | 256 } |
296 | 257 |
297 | |
298 ASSEMBLER_TEST_RUN(AddCarryInOut, test) { | 258 ASSEMBLER_TEST_RUN(AddCarryInOut, test) { |
299 typedef int64_t (*Int64Return)() DART_UNUSED; | 259 typedef int64_t (*Int64Return)() DART_UNUSED; |
300 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 260 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
301 } | 261 } |
302 | 262 |
303 | |
304 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) { | 263 ASSEMBLER_TEST_GENERATE(SubCarryInOut, assembler) { |
305 __ LoadImmediate(R1, 1); | 264 __ LoadImmediate(R1, 1); |
306 __ LoadImmediate(R0, 0); | 265 __ LoadImmediate(R0, 0); |
307 __ subs(IP0, R0, Operand(R1)); // c_out = 1. | 266 __ subs(IP0, R0, Operand(R1)); // c_out = 1. |
308 __ sbcs(IP0, R0, R0); // c_in = 1, c_out = 1. | 267 __ sbcs(IP0, R0, R0); // c_in = 1, c_out = 1. |
309 __ sbc(R0, R0, R0); // c_in = 1. | 268 __ sbc(R0, R0, R0); // c_in = 1. |
310 __ ret(); | 269 __ ret(); |
311 } | 270 } |
312 | 271 |
313 | |
314 ASSEMBLER_TEST_RUN(SubCarryInOut, test) { | 272 ASSEMBLER_TEST_RUN(SubCarryInOut, test) { |
315 typedef int64_t (*Int64Return)() DART_UNUSED; | 273 typedef int64_t (*Int64Return)() DART_UNUSED; |
316 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 274 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
317 } | 275 } |
318 | 276 |
319 | |
320 ASSEMBLER_TEST_GENERATE(Overflow, assembler) { | 277 ASSEMBLER_TEST_GENERATE(Overflow, assembler) { |
321 __ LoadImmediate(R0, 0); | 278 __ LoadImmediate(R0, 0); |
322 __ LoadImmediate(R1, 1); | 279 __ LoadImmediate(R1, 1); |
323 __ LoadImmediate(R2, 0xFFFFFFFFFFFFFFFF); | 280 __ LoadImmediate(R2, 0xFFFFFFFFFFFFFFFF); |
324 __ LoadImmediate(R3, 0x7FFFFFFFFFFFFFFF); | 281 __ LoadImmediate(R3, 0x7FFFFFFFFFFFFFFF); |
325 __ adds(IP0, R2, Operand(R1)); // c_out = 1. | 282 __ adds(IP0, R2, Operand(R1)); // c_out = 1. |
326 __ adcs(IP0, R3, R0); // c_in = 1, c_out = 1, v = 1. | 283 __ adcs(IP0, R3, R0); // c_in = 1, c_out = 1, v = 1. |
327 __ csinc(R0, R0, R0, VS); // R0 = v ? R0 : R0 + 1. | 284 __ csinc(R0, R0, R0, VS); // R0 = v ? R0 : R0 + 1. |
328 __ ret(); | 285 __ ret(); |
329 } | 286 } |
330 | 287 |
331 | |
332 ASSEMBLER_TEST_RUN(Overflow, test) { | 288 ASSEMBLER_TEST_RUN(Overflow, test) { |
333 typedef int64_t (*Int64Return)() DART_UNUSED; | 289 typedef int64_t (*Int64Return)() DART_UNUSED; |
334 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 290 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
335 } | 291 } |
336 | 292 |
337 | |
338 ASSEMBLER_TEST_GENERATE(WordAddCarryInOut, assembler) { | 293 ASSEMBLER_TEST_GENERATE(WordAddCarryInOut, assembler) { |
339 __ LoadImmediate(R2, -1); | 294 __ LoadImmediate(R2, -1); |
340 __ LoadImmediate(R1, 1); | 295 __ LoadImmediate(R1, 1); |
341 __ LoadImmediate(R0, 0); | 296 __ LoadImmediate(R0, 0); |
342 __ addsw(IP0, R2, Operand(R1)); // c_out = 1. | 297 __ addsw(IP0, R2, Operand(R1)); // c_out = 1. |
343 __ adcsw(IP0, R2, R0); // c_in = 1, c_out = 1. | 298 __ adcsw(IP0, R2, R0); // c_in = 1, c_out = 1. |
344 __ adcw(R0, R0, R0); // c_in = 1. | 299 __ adcw(R0, R0, R0); // c_in = 1. |
345 __ ret(); | 300 __ ret(); |
346 } | 301 } |
347 | 302 |
348 | |
349 ASSEMBLER_TEST_RUN(WordAddCarryInOut, test) { | 303 ASSEMBLER_TEST_RUN(WordAddCarryInOut, test) { |
350 typedef int64_t (*Int64Return)() DART_UNUSED; | 304 typedef int64_t (*Int64Return)() DART_UNUSED; |
351 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 305 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
352 } | 306 } |
353 | 307 |
354 | |
355 ASSEMBLER_TEST_GENERATE(WordSubCarryInOut, assembler) { | 308 ASSEMBLER_TEST_GENERATE(WordSubCarryInOut, assembler) { |
356 __ LoadImmediate(R1, 1); | 309 __ LoadImmediate(R1, 1); |
357 __ LoadImmediate(R0, 0); | 310 __ LoadImmediate(R0, 0); |
358 __ subsw(IP0, R0, Operand(R1)); // c_out = 1. | 311 __ subsw(IP0, R0, Operand(R1)); // c_out = 1. |
359 __ sbcsw(IP0, R0, R0); // c_in = 1, c_out = 1. | 312 __ sbcsw(IP0, R0, R0); // c_in = 1, c_out = 1. |
360 __ sbcw(R0, R0, R0); // c_in = 1. | 313 __ sbcw(R0, R0, R0); // c_in = 1. |
361 __ ret(); | 314 __ ret(); |
362 } | 315 } |
363 | 316 |
364 | |
365 ASSEMBLER_TEST_RUN(WordSubCarryInOut, test) { | 317 ASSEMBLER_TEST_RUN(WordSubCarryInOut, test) { |
366 typedef int64_t (*Int64Return)() DART_UNUSED; | 318 typedef int64_t (*Int64Return)() DART_UNUSED; |
367 EXPECT_EQ(0x0FFFFFFFF, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 319 EXPECT_EQ(0x0FFFFFFFF, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
368 } | 320 } |
369 | 321 |
370 | |
371 ASSEMBLER_TEST_GENERATE(WordOverflow, assembler) { | 322 ASSEMBLER_TEST_GENERATE(WordOverflow, assembler) { |
372 __ LoadImmediate(R0, 0); | 323 __ LoadImmediate(R0, 0); |
373 __ LoadImmediate(R1, 1); | 324 __ LoadImmediate(R1, 1); |
374 __ LoadImmediate(R2, 0xFFFFFFFF); | 325 __ LoadImmediate(R2, 0xFFFFFFFF); |
375 __ LoadImmediate(R3, 0x7FFFFFFF); | 326 __ LoadImmediate(R3, 0x7FFFFFFF); |
376 __ addsw(IP0, R2, Operand(R1)); // c_out = 1. | 327 __ addsw(IP0, R2, Operand(R1)); // c_out = 1. |
377 __ adcsw(IP0, R3, R0); // c_in = 1, c_out = 1, v = 1. | 328 __ adcsw(IP0, R3, R0); // c_in = 1, c_out = 1, v = 1. |
378 __ csinc(R0, R0, R0, VS); // R0 = v ? R0 : R0 + 1. | 329 __ csinc(R0, R0, R0, VS); // R0 = v ? R0 : R0 + 1. |
379 __ ret(); | 330 __ ret(); |
380 } | 331 } |
381 | 332 |
382 | |
383 ASSEMBLER_TEST_RUN(WordOverflow, test) { | 333 ASSEMBLER_TEST_RUN(WordOverflow, test) { |
384 typedef int64_t (*Int64Return)() DART_UNUSED; | 334 typedef int64_t (*Int64Return)() DART_UNUSED; |
385 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 335 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
386 } | 336 } |
387 | 337 |
388 | |
389 // Loads and Stores. | 338 // Loads and Stores. |
390 ASSEMBLER_TEST_GENERATE(SimpleLoadStore, assembler) { | 339 ASSEMBLER_TEST_GENERATE(SimpleLoadStore, assembler) { |
391 __ SetupDartSP(); | 340 __ SetupDartSP(); |
392 __ movz(R0, Immediate(43), 0); | 341 __ movz(R0, Immediate(43), 0); |
393 __ movz(R1, Immediate(42), 0); | 342 __ movz(R1, Immediate(42), 0); |
394 __ str(R1, Address(SP, -1 * kWordSize, Address::PreIndex)); | 343 __ str(R1, Address(SP, -1 * kWordSize, Address::PreIndex)); |
395 __ ldr(R0, Address(SP, 1 * kWordSize, Address::PostIndex)); | 344 __ ldr(R0, Address(SP, 1 * kWordSize, Address::PostIndex)); |
396 __ RestoreCSP(); | 345 __ RestoreCSP(); |
397 __ ret(); | 346 __ ret(); |
398 } | 347 } |
399 | 348 |
400 | |
401 ASSEMBLER_TEST_RUN(SimpleLoadStore, test) { | 349 ASSEMBLER_TEST_RUN(SimpleLoadStore, test) { |
402 typedef int64_t (*Int64Return)() DART_UNUSED; | 350 typedef int64_t (*Int64Return)() DART_UNUSED; |
403 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 351 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
404 } | 352 } |
405 | 353 |
406 | |
407 ASSEMBLER_TEST_GENERATE(SimpleLoadStoreHeapTag, assembler) { | 354 ASSEMBLER_TEST_GENERATE(SimpleLoadStoreHeapTag, assembler) { |
408 __ SetupDartSP(); | 355 __ SetupDartSP(); |
409 __ movz(R0, Immediate(43), 0); | 356 __ movz(R0, Immediate(43), 0); |
410 __ movz(R1, Immediate(42), 0); | 357 __ movz(R1, Immediate(42), 0); |
411 __ add(R2, SP, Operand(1)); | 358 __ add(R2, SP, Operand(1)); |
412 __ str(R1, Address(R2, -1)); | 359 __ str(R1, Address(R2, -1)); |
413 __ ldr(R0, Address(R2, -1)); | 360 __ ldr(R0, Address(R2, -1)); |
414 __ RestoreCSP(); | 361 __ RestoreCSP(); |
415 __ ret(); | 362 __ ret(); |
416 } | 363 } |
417 | 364 |
418 | |
419 ASSEMBLER_TEST_RUN(SimpleLoadStoreHeapTag, test) { | 365 ASSEMBLER_TEST_RUN(SimpleLoadStoreHeapTag, test) { |
420 typedef int64_t (*Int64Return)() DART_UNUSED; | 366 typedef int64_t (*Int64Return)() DART_UNUSED; |
421 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 367 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
422 } | 368 } |
423 | 369 |
424 | |
425 ASSEMBLER_TEST_GENERATE(LoadStoreLargeIndex, assembler) { | 370 ASSEMBLER_TEST_GENERATE(LoadStoreLargeIndex, assembler) { |
426 __ SetupDartSP(); | 371 __ SetupDartSP(); |
427 __ movz(R0, Immediate(43), 0); | 372 __ movz(R0, Immediate(43), 0); |
428 __ movz(R1, Immediate(42), 0); | 373 __ movz(R1, Immediate(42), 0); |
429 // Largest negative offset that can fit in the signed 9-bit immediate field. | 374 // Largest negative offset that can fit in the signed 9-bit immediate field. |
430 __ str(R1, Address(SP, -32 * kWordSize, Address::PreIndex)); | 375 __ str(R1, Address(SP, -32 * kWordSize, Address::PreIndex)); |
431 // Largest positive kWordSize aligned offset that we can fit. | 376 // Largest positive kWordSize aligned offset that we can fit. |
432 __ ldr(R0, Address(SP, 31 * kWordSize, Address::PostIndex)); | 377 __ ldr(R0, Address(SP, 31 * kWordSize, Address::PostIndex)); |
433 // Correction. | 378 // Correction. |
434 __ add(SP, SP, Operand(kWordSize)); // Restore SP. | 379 __ add(SP, SP, Operand(kWordSize)); // Restore SP. |
435 __ RestoreCSP(); | 380 __ RestoreCSP(); |
436 __ ret(); | 381 __ ret(); |
437 } | 382 } |
438 | 383 |
439 | |
440 ASSEMBLER_TEST_RUN(LoadStoreLargeIndex, test) { | 384 ASSEMBLER_TEST_RUN(LoadStoreLargeIndex, test) { |
441 typedef int64_t (*Int64Return)() DART_UNUSED; | 385 typedef int64_t (*Int64Return)() DART_UNUSED; |
442 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 386 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
443 } | 387 } |
444 | 388 |
445 | |
446 ASSEMBLER_TEST_GENERATE(LoadStoreLargeOffset, assembler) { | 389 ASSEMBLER_TEST_GENERATE(LoadStoreLargeOffset, assembler) { |
447 __ SetupDartSP(); | 390 __ SetupDartSP(); |
448 __ movz(R0, Immediate(43), 0); | 391 __ movz(R0, Immediate(43), 0); |
449 __ movz(R1, Immediate(42), 0); | 392 __ movz(R1, Immediate(42), 0); |
450 __ sub(SP, SP, Operand(512 * kWordSize)); | 393 __ sub(SP, SP, Operand(512 * kWordSize)); |
451 __ str(R1, Address(SP, 512 * kWordSize, Address::Offset)); | 394 __ str(R1, Address(SP, 512 * kWordSize, Address::Offset)); |
452 __ add(SP, SP, Operand(512 * kWordSize)); | 395 __ add(SP, SP, Operand(512 * kWordSize)); |
453 __ ldr(R0, Address(SP)); | 396 __ ldr(R0, Address(SP)); |
454 __ RestoreCSP(); | 397 __ RestoreCSP(); |
455 __ ret(); | 398 __ ret(); |
456 } | 399 } |
457 | 400 |
458 | |
459 ASSEMBLER_TEST_RUN(LoadStoreLargeOffset, test) { | 401 ASSEMBLER_TEST_RUN(LoadStoreLargeOffset, test) { |
460 typedef int64_t (*Int64Return)() DART_UNUSED; | 402 typedef int64_t (*Int64Return)() DART_UNUSED; |
461 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 403 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
462 } | 404 } |
463 | 405 |
464 | |
465 ASSEMBLER_TEST_GENERATE(LoadStoreExtReg, assembler) { | 406 ASSEMBLER_TEST_GENERATE(LoadStoreExtReg, assembler) { |
466 __ SetupDartSP(); | 407 __ SetupDartSP(); |
467 __ movz(R0, Immediate(43), 0); | 408 __ movz(R0, Immediate(43), 0); |
468 __ movz(R1, Immediate(42), 0); | 409 __ movz(R1, Immediate(42), 0); |
469 __ movz(R2, Immediate(0xfff8), 0); | 410 __ movz(R2, Immediate(0xfff8), 0); |
470 __ movk(R2, Immediate(0xffff), 1); // R2 <- -8 (int32_t). | 411 __ movk(R2, Immediate(0xffff), 1); // R2 <- -8 (int32_t). |
471 // This should sign extend R2, and add to SP to get address, | 412 // This should sign extend R2, and add to SP to get address, |
472 // i.e. SP - kWordSize. | 413 // i.e. SP - kWordSize. |
473 __ str(R1, Address(SP, R2, SXTW)); | 414 __ str(R1, Address(SP, R2, SXTW)); |
474 __ sub(SP, SP, Operand(kWordSize)); | 415 __ sub(SP, SP, Operand(kWordSize)); |
475 __ ldr(R0, Address(SP)); | 416 __ ldr(R0, Address(SP)); |
476 __ add(SP, SP, Operand(kWordSize)); | 417 __ add(SP, SP, Operand(kWordSize)); |
477 __ RestoreCSP(); | 418 __ RestoreCSP(); |
478 __ ret(); | 419 __ ret(); |
479 } | 420 } |
480 | 421 |
481 | |
482 ASSEMBLER_TEST_RUN(LoadStoreExtReg, test) { | 422 ASSEMBLER_TEST_RUN(LoadStoreExtReg, test) { |
483 typedef int64_t (*Int64Return)() DART_UNUSED; | 423 typedef int64_t (*Int64Return)() DART_UNUSED; |
484 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 424 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
485 } | 425 } |
486 | 426 |
487 | |
488 ASSEMBLER_TEST_GENERATE(LoadStoreScaledReg, assembler) { | 427 ASSEMBLER_TEST_GENERATE(LoadStoreScaledReg, assembler) { |
489 __ SetupDartSP(); | 428 __ SetupDartSP(); |
490 __ movz(R0, Immediate(43), 0); | 429 __ movz(R0, Immediate(43), 0); |
491 __ movz(R1, Immediate(42), 0); | 430 __ movz(R1, Immediate(42), 0); |
492 __ movz(R2, Immediate(10), 0); | 431 __ movz(R2, Immediate(10), 0); |
493 __ sub(SP, SP, Operand(10 * kWordSize)); | 432 __ sub(SP, SP, Operand(10 * kWordSize)); |
494 // Store R1 into SP + R2 * kWordSize. | 433 // Store R1 into SP + R2 * kWordSize. |
495 __ str(R1, Address(SP, R2, UXTX, Address::Scaled)); | 434 __ str(R1, Address(SP, R2, UXTX, Address::Scaled)); |
496 __ ldr(R0, Address(SP, R2, UXTX, Address::Scaled)); | 435 __ ldr(R0, Address(SP, R2, UXTX, Address::Scaled)); |
497 __ add(SP, SP, Operand(10 * kWordSize)); | 436 __ add(SP, SP, Operand(10 * kWordSize)); |
498 __ RestoreCSP(); | 437 __ RestoreCSP(); |
499 __ ret(); | 438 __ ret(); |
500 } | 439 } |
501 | 440 |
502 | |
503 ASSEMBLER_TEST_RUN(LoadStoreScaledReg, test) { | 441 ASSEMBLER_TEST_RUN(LoadStoreScaledReg, test) { |
504 typedef int64_t (*Int64Return)() DART_UNUSED; | 442 typedef int64_t (*Int64Return)() DART_UNUSED; |
505 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 443 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
506 } | 444 } |
507 | 445 |
508 | |
509 ASSEMBLER_TEST_GENERATE(LoadSigned32Bit, assembler) { | 446 ASSEMBLER_TEST_GENERATE(LoadSigned32Bit, assembler) { |
510 __ SetupDartSP(); | 447 __ SetupDartSP(); |
511 __ LoadImmediate(R1, 0xffffffff); | 448 __ LoadImmediate(R1, 0xffffffff); |
512 __ str(R1, Address(SP, -4, Address::PreIndex, kWord), kWord); | 449 __ str(R1, Address(SP, -4, Address::PreIndex, kWord), kWord); |
513 __ ldr(R0, Address(SP), kWord); | 450 __ ldr(R0, Address(SP), kWord); |
514 __ ldr(R1, Address(SP, 4, Address::PostIndex, kWord), kWord); | 451 __ ldr(R1, Address(SP, 4, Address::PostIndex, kWord), kWord); |
515 __ RestoreCSP(); | 452 __ RestoreCSP(); |
516 __ ret(); | 453 __ ret(); |
517 } | 454 } |
518 | 455 |
519 | |
520 ASSEMBLER_TEST_RUN(LoadSigned32Bit, test) { | 456 ASSEMBLER_TEST_RUN(LoadSigned32Bit, test) { |
521 typedef int64_t (*Int64Return)() DART_UNUSED; | 457 typedef int64_t (*Int64Return)() DART_UNUSED; |
522 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 458 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
523 } | 459 } |
524 | 460 |
525 | |
526 ASSEMBLER_TEST_GENERATE(SimpleLoadStorePair, assembler) { | 461 ASSEMBLER_TEST_GENERATE(SimpleLoadStorePair, assembler) { |
527 __ SetupDartSP(); | 462 __ SetupDartSP(); |
528 __ LoadImmediate(R2, 43); | 463 __ LoadImmediate(R2, 43); |
529 __ LoadImmediate(R3, 42); | 464 __ LoadImmediate(R3, 42); |
530 __ stp(R2, R3, Address(SP, -2 * kWordSize, Address::PairPreIndex)); | 465 __ stp(R2, R3, Address(SP, -2 * kWordSize, Address::PairPreIndex)); |
531 __ ldp(R0, R1, Address(SP, 2 * kWordSize, Address::PairPostIndex)); | 466 __ ldp(R0, R1, Address(SP, 2 * kWordSize, Address::PairPostIndex)); |
532 __ sub(R0, R0, Operand(R1)); | 467 __ sub(R0, R0, Operand(R1)); |
533 __ RestoreCSP(); | 468 __ RestoreCSP(); |
534 __ ret(); | 469 __ ret(); |
535 } | 470 } |
536 | 471 |
537 | |
538 ASSEMBLER_TEST_RUN(SimpleLoadStorePair, test) { | 472 ASSEMBLER_TEST_RUN(SimpleLoadStorePair, test) { |
539 typedef int64_t (*Int64Return)() DART_UNUSED; | 473 typedef int64_t (*Int64Return)() DART_UNUSED; |
540 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 474 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
541 } | 475 } |
542 | 476 |
543 | |
544 ASSEMBLER_TEST_GENERATE(LoadStorePairOffset, assembler) { | 477 ASSEMBLER_TEST_GENERATE(LoadStorePairOffset, assembler) { |
545 __ SetupDartSP(); | 478 __ SetupDartSP(); |
546 __ LoadImmediate(R2, 43); | 479 __ LoadImmediate(R2, 43); |
547 __ LoadImmediate(R3, 42); | 480 __ LoadImmediate(R3, 42); |
548 __ sub(SP, SP, Operand(4 * kWordSize)); | 481 __ sub(SP, SP, Operand(4 * kWordSize)); |
549 __ stp(R2, R3, Address::Pair(SP, 2 * kWordSize)); | 482 __ stp(R2, R3, Address::Pair(SP, 2 * kWordSize)); |
550 __ ldp(R0, R1, Address::Pair(SP, 2 * kWordSize)); | 483 __ ldp(R0, R1, Address::Pair(SP, 2 * kWordSize)); |
551 __ add(SP, SP, Operand(4 * kWordSize)); | 484 __ add(SP, SP, Operand(4 * kWordSize)); |
552 __ sub(R0, R0, Operand(R1)); | 485 __ sub(R0, R0, Operand(R1)); |
553 __ RestoreCSP(); | 486 __ RestoreCSP(); |
554 __ ret(); | 487 __ ret(); |
555 } | 488 } |
556 | 489 |
557 | |
558 ASSEMBLER_TEST_RUN(LoadStorePairOffset, test) { | 490 ASSEMBLER_TEST_RUN(LoadStorePairOffset, test) { |
559 typedef int64_t (*Int64Return)() DART_UNUSED; | 491 typedef int64_t (*Int64Return)() DART_UNUSED; |
560 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 492 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
561 } | 493 } |
562 | 494 |
563 | |
564 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) { | 495 ASSEMBLER_TEST_GENERATE(Semaphore, assembler) { |
565 __ SetupDartSP(); | 496 __ SetupDartSP(); |
566 __ movz(R0, Immediate(40), 0); | 497 __ movz(R0, Immediate(40), 0); |
567 __ movz(R1, Immediate(42), 0); | 498 __ movz(R1, Immediate(42), 0); |
568 __ Push(R0); | 499 __ Push(R0); |
569 Label retry; | 500 Label retry; |
570 __ Bind(&retry); | 501 __ Bind(&retry); |
571 __ ldxr(R0, SP); | 502 __ ldxr(R0, SP); |
572 __ stxr(TMP, R1, SP); // IP == 0, success | 503 __ stxr(TMP, R1, SP); // IP == 0, success |
573 __ cmp(TMP, Operand(0)); | 504 __ cmp(TMP, Operand(0)); |
574 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. | 505 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. |
575 __ Pop(R0); // 42 | 506 __ Pop(R0); // 42 |
576 __ RestoreCSP(); | 507 __ RestoreCSP(); |
577 __ ret(); | 508 __ ret(); |
578 } | 509 } |
579 | 510 |
580 | |
581 ASSEMBLER_TEST_RUN(Semaphore, test) { | 511 ASSEMBLER_TEST_RUN(Semaphore, test) { |
582 EXPECT(test != NULL); | 512 EXPECT(test != NULL); |
583 typedef intptr_t (*Semaphore)() DART_UNUSED; | 513 typedef intptr_t (*Semaphore)() DART_UNUSED; |
584 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Semaphore, test->entry())); | 514 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Semaphore, test->entry())); |
585 } | 515 } |
586 | 516 |
587 | |
588 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) { | 517 ASSEMBLER_TEST_GENERATE(FailedSemaphore, assembler) { |
589 __ SetupDartSP(); | 518 __ SetupDartSP(); |
590 __ movz(R0, Immediate(40), 0); | 519 __ movz(R0, Immediate(40), 0); |
591 __ movz(R1, Immediate(42), 0); | 520 __ movz(R1, Immediate(42), 0); |
592 __ Push(R0); | 521 __ Push(R0); |
593 __ ldxr(R0, SP); | 522 __ ldxr(R0, SP); |
594 __ clrex(); // Simulate a context switch. | 523 __ clrex(); // Simulate a context switch. |
595 __ stxr(TMP, R1, SP); // IP == 1, failure | 524 __ stxr(TMP, R1, SP); // IP == 1, failure |
596 __ Pop(R0); // 40 | 525 __ Pop(R0); // 40 |
597 __ add(R0, R0, Operand(TMP)); | 526 __ add(R0, R0, Operand(TMP)); |
598 __ RestoreCSP(); | 527 __ RestoreCSP(); |
599 __ ret(); | 528 __ ret(); |
600 } | 529 } |
601 | 530 |
602 | |
603 ASSEMBLER_TEST_RUN(FailedSemaphore, test) { | 531 ASSEMBLER_TEST_RUN(FailedSemaphore, test) { |
604 EXPECT(test != NULL); | 532 EXPECT(test != NULL); |
605 typedef intptr_t (*FailedSemaphore)() DART_UNUSED; | 533 typedef intptr_t (*FailedSemaphore)() DART_UNUSED; |
606 EXPECT_EQ(41, EXECUTE_TEST_CODE_INT64(FailedSemaphore, test->entry())); | 534 EXPECT_EQ(41, EXECUTE_TEST_CODE_INT64(FailedSemaphore, test->entry())); |
607 } | 535 } |
608 | 536 |
609 | |
610 ASSEMBLER_TEST_GENERATE(Semaphore32, assembler) { | 537 ASSEMBLER_TEST_GENERATE(Semaphore32, assembler) { |
611 __ SetupDartSP(); | 538 __ SetupDartSP(); |
612 __ movz(R0, Immediate(40), 0); | 539 __ movz(R0, Immediate(40), 0); |
613 __ add(R0, R0, Operand(R0, LSL, 32)); | 540 __ add(R0, R0, Operand(R0, LSL, 32)); |
614 __ Push(R0); | 541 __ Push(R0); |
615 | 542 |
616 __ movz(R0, Immediate(40), 0); | 543 __ movz(R0, Immediate(40), 0); |
617 __ movz(R1, Immediate(42), 0); | 544 __ movz(R1, Immediate(42), 0); |
618 | 545 |
619 Label retry; | 546 Label retry; |
620 __ Bind(&retry); | 547 __ Bind(&retry); |
621 __ ldxr(R0, SP, kWord); | 548 __ ldxr(R0, SP, kWord); |
622 // 32 bit operation should ignore the high word of R0 that was pushed on the | 549 // 32 bit operation should ignore the high word of R0 that was pushed on the |
623 // stack. | 550 // stack. |
624 __ stxr(TMP, R1, SP, kWord); // IP == 0, success | 551 __ stxr(TMP, R1, SP, kWord); // IP == 0, success |
625 __ cmp(TMP, Operand(0)); | 552 __ cmp(TMP, Operand(0)); |
626 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. | 553 __ b(&retry, NE); // NE if context switch occurred between ldrex and strex. |
627 __ Pop(R0); // 42 + 42 * 2**32 | 554 __ Pop(R0); // 42 + 42 * 2**32 |
628 __ RestoreCSP(); | 555 __ RestoreCSP(); |
629 __ ret(); | 556 __ ret(); |
630 } | 557 } |
631 | 558 |
632 | |
633 ASSEMBLER_TEST_RUN(Semaphore32, test) { | 559 ASSEMBLER_TEST_RUN(Semaphore32, test) { |
634 EXPECT(test != NULL); | 560 EXPECT(test != NULL); |
635 typedef intptr_t (*Semaphore32)() DART_UNUSED; | 561 typedef intptr_t (*Semaphore32)() DART_UNUSED; |
636 // Lower word has been atomically switched from 40 to 42k, whereas upper word | 562 // Lower word has been atomically switched from 40 to 42k, whereas upper word |
637 // is unchanged at 40. | 563 // is unchanged at 40. |
638 EXPECT_EQ(42 + (40l << 32), | 564 EXPECT_EQ(42 + (40l << 32), |
639 EXECUTE_TEST_CODE_INT64(Semaphore32, test->entry())); | 565 EXECUTE_TEST_CODE_INT64(Semaphore32, test->entry())); |
640 } | 566 } |
641 | 567 |
642 | |
643 ASSEMBLER_TEST_GENERATE(FailedSemaphore32, assembler) { | 568 ASSEMBLER_TEST_GENERATE(FailedSemaphore32, assembler) { |
644 __ SetupDartSP(); | 569 __ SetupDartSP(); |
645 __ movz(R0, Immediate(40), 0); | 570 __ movz(R0, Immediate(40), 0); |
646 __ add(R0, R0, Operand(R0, LSL, 32)); | 571 __ add(R0, R0, Operand(R0, LSL, 32)); |
647 __ Push(R0); | 572 __ Push(R0); |
648 | 573 |
649 __ movz(R0, Immediate(40), 0); | 574 __ movz(R0, Immediate(40), 0); |
650 __ movz(R1, Immediate(42), 0); | 575 __ movz(R1, Immediate(42), 0); |
651 | 576 |
652 __ ldxr(R0, SP, kWord); | 577 __ ldxr(R0, SP, kWord); |
653 __ clrex(); // Simulate a context switch. | 578 __ clrex(); // Simulate a context switch. |
654 __ stxr(TMP, R1, SP, kWord); // IP == 1, failure | 579 __ stxr(TMP, R1, SP, kWord); // IP == 1, failure |
655 __ Pop(R0); // 40 | 580 __ Pop(R0); // 40 |
656 __ add(R0, R0, Operand(TMP)); | 581 __ add(R0, R0, Operand(TMP)); |
657 __ RestoreCSP(); | 582 __ RestoreCSP(); |
658 __ ret(); | 583 __ ret(); |
659 } | 584 } |
660 | 585 |
661 | |
662 ASSEMBLER_TEST_RUN(FailedSemaphore32, test) { | 586 ASSEMBLER_TEST_RUN(FailedSemaphore32, test) { |
663 EXPECT(test != NULL); | 587 EXPECT(test != NULL); |
664 typedef intptr_t (*FailedSemaphore32)() DART_UNUSED; | 588 typedef intptr_t (*FailedSemaphore32)() DART_UNUSED; |
665 // Lower word has had the failure code (1) added to it. Upper word is | 589 // Lower word has had the failure code (1) added to it. Upper word is |
666 // unchanged at 40. | 590 // unchanged at 40. |
667 EXPECT_EQ(41 + (40l << 32), | 591 EXPECT_EQ(41 + (40l << 32), |
668 EXECUTE_TEST_CODE_INT64(FailedSemaphore32, test->entry())); | 592 EXECUTE_TEST_CODE_INT64(FailedSemaphore32, test->entry())); |
669 } | 593 } |
670 | 594 |
671 | |
672 // Logical register operations. | 595 // Logical register operations. |
673 ASSEMBLER_TEST_GENERATE(AndRegs, assembler) { | 596 ASSEMBLER_TEST_GENERATE(AndRegs, assembler) { |
674 __ movz(R1, Immediate(43), 0); | 597 __ movz(R1, Immediate(43), 0); |
675 __ movz(R2, Immediate(42), 0); | 598 __ movz(R2, Immediate(42), 0); |
676 __ and_(R0, R1, Operand(R2)); | 599 __ and_(R0, R1, Operand(R2)); |
677 __ ret(); | 600 __ ret(); |
678 } | 601 } |
679 | 602 |
680 | |
681 ASSEMBLER_TEST_RUN(AndRegs, test) { | 603 ASSEMBLER_TEST_RUN(AndRegs, test) { |
682 typedef int64_t (*Int64Return)() DART_UNUSED; | 604 typedef int64_t (*Int64Return)() DART_UNUSED; |
683 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 605 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
684 } | 606 } |
685 | 607 |
686 | |
687 ASSEMBLER_TEST_GENERATE(AndShiftRegs, assembler) { | 608 ASSEMBLER_TEST_GENERATE(AndShiftRegs, assembler) { |
688 __ movz(R1, Immediate(42), 0); | 609 __ movz(R1, Immediate(42), 0); |
689 __ movz(R2, Immediate(21), 0); | 610 __ movz(R2, Immediate(21), 0); |
690 __ and_(R0, R1, Operand(R2, LSL, 1)); | 611 __ and_(R0, R1, Operand(R2, LSL, 1)); |
691 __ ret(); | 612 __ ret(); |
692 } | 613 } |
693 | 614 |
694 | |
695 ASSEMBLER_TEST_RUN(AndShiftRegs, test) { | 615 ASSEMBLER_TEST_RUN(AndShiftRegs, test) { |
696 typedef int64_t (*Int64Return)() DART_UNUSED; | 616 typedef int64_t (*Int64Return)() DART_UNUSED; |
697 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 617 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
698 } | 618 } |
699 | 619 |
700 | |
701 ASSEMBLER_TEST_GENERATE(BicRegs, assembler) { | 620 ASSEMBLER_TEST_GENERATE(BicRegs, assembler) { |
702 __ movz(R1, Immediate(42), 0); | 621 __ movz(R1, Immediate(42), 0); |
703 __ movz(R2, Immediate(5), 0); | 622 __ movz(R2, Immediate(5), 0); |
704 __ bic(R0, R1, Operand(R2)); | 623 __ bic(R0, R1, Operand(R2)); |
705 __ ret(); | 624 __ ret(); |
706 } | 625 } |
707 | 626 |
708 | |
709 ASSEMBLER_TEST_RUN(BicRegs, test) { | 627 ASSEMBLER_TEST_RUN(BicRegs, test) { |
710 typedef int64_t (*Int64Return)() DART_UNUSED; | 628 typedef int64_t (*Int64Return)() DART_UNUSED; |
711 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 629 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
712 } | 630 } |
713 | 631 |
714 | |
715 ASSEMBLER_TEST_GENERATE(OrrRegs, assembler) { | 632 ASSEMBLER_TEST_GENERATE(OrrRegs, assembler) { |
716 __ movz(R1, Immediate(32), 0); | 633 __ movz(R1, Immediate(32), 0); |
717 __ movz(R2, Immediate(10), 0); | 634 __ movz(R2, Immediate(10), 0); |
718 __ orr(R0, R1, Operand(R2)); | 635 __ orr(R0, R1, Operand(R2)); |
719 __ ret(); | 636 __ ret(); |
720 } | 637 } |
721 | 638 |
722 | |
723 ASSEMBLER_TEST_RUN(OrrRegs, test) { | 639 ASSEMBLER_TEST_RUN(OrrRegs, test) { |
724 typedef int64_t (*Int64Return)() DART_UNUSED; | 640 typedef int64_t (*Int64Return)() DART_UNUSED; |
725 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 641 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
726 } | 642 } |
727 | 643 |
728 | |
729 ASSEMBLER_TEST_GENERATE(OrnRegs, assembler) { | 644 ASSEMBLER_TEST_GENERATE(OrnRegs, assembler) { |
730 __ movz(R1, Immediate(32), 0); | 645 __ movz(R1, Immediate(32), 0); |
731 __ movn(R2, Immediate(0), 0); // R2 <- 0xffffffffffffffff. | 646 __ movn(R2, Immediate(0), 0); // R2 <- 0xffffffffffffffff. |
732 __ movk(R2, Immediate(0xffd5), 0); // R2 <- 0xffffffffffffffe5. | 647 __ movk(R2, Immediate(0xffd5), 0); // R2 <- 0xffffffffffffffe5. |
733 __ orn(R0, R1, Operand(R2)); | 648 __ orn(R0, R1, Operand(R2)); |
734 __ ret(); | 649 __ ret(); |
735 } | 650 } |
736 | 651 |
737 | |
738 ASSEMBLER_TEST_RUN(OrnRegs, test) { | 652 ASSEMBLER_TEST_RUN(OrnRegs, test) { |
739 typedef int64_t (*Int64Return)() DART_UNUSED; | 653 typedef int64_t (*Int64Return)() DART_UNUSED; |
740 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 654 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
741 } | 655 } |
742 | 656 |
743 | |
744 ASSEMBLER_TEST_GENERATE(EorRegs, assembler) { | 657 ASSEMBLER_TEST_GENERATE(EorRegs, assembler) { |
745 __ movz(R1, Immediate(0xffd5), 0); | 658 __ movz(R1, Immediate(0xffd5), 0); |
746 __ movz(R2, Immediate(0xffff), 0); | 659 __ movz(R2, Immediate(0xffff), 0); |
747 __ eor(R0, R1, Operand(R2)); | 660 __ eor(R0, R1, Operand(R2)); |
748 __ ret(); | 661 __ ret(); |
749 } | 662 } |
750 | 663 |
751 | |
752 ASSEMBLER_TEST_RUN(EorRegs, test) { | 664 ASSEMBLER_TEST_RUN(EorRegs, test) { |
753 typedef int64_t (*Int64Return)() DART_UNUSED; | 665 typedef int64_t (*Int64Return)() DART_UNUSED; |
754 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 666 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
755 } | 667 } |
756 | 668 |
757 | |
758 ASSEMBLER_TEST_GENERATE(EonRegs, assembler) { | 669 ASSEMBLER_TEST_GENERATE(EonRegs, assembler) { |
759 __ movz(R1, Immediate(0xffd5), 0); | 670 __ movz(R1, Immediate(0xffd5), 0); |
760 __ movn(R2, Immediate(0xffff), 0); | 671 __ movn(R2, Immediate(0xffff), 0); |
761 __ eon(R0, R1, Operand(R2)); | 672 __ eon(R0, R1, Operand(R2)); |
762 __ ret(); | 673 __ ret(); |
763 } | 674 } |
764 | 675 |
765 | |
766 ASSEMBLER_TEST_RUN(EonRegs, test) { | 676 ASSEMBLER_TEST_RUN(EonRegs, test) { |
767 typedef int64_t (*Int64Return)() DART_UNUSED; | 677 typedef int64_t (*Int64Return)() DART_UNUSED; |
768 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 678 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
769 } | 679 } |
770 | 680 |
771 | |
772 // Logical immediate operations. | 681 // Logical immediate operations. |
773 ASSEMBLER_TEST_GENERATE(AndImm, assembler) { | 682 ASSEMBLER_TEST_GENERATE(AndImm, assembler) { |
774 __ movz(R1, Immediate(42), 0); | 683 __ movz(R1, Immediate(42), 0); |
775 __ andi(R0, R1, Immediate(0xaaaaaaaaaaaaaaaaULL)); | 684 __ andi(R0, R1, Immediate(0xaaaaaaaaaaaaaaaaULL)); |
776 __ ret(); | 685 __ ret(); |
777 } | 686 } |
778 | 687 |
779 | |
780 ASSEMBLER_TEST_RUN(AndImm, test) { | 688 ASSEMBLER_TEST_RUN(AndImm, test) { |
781 typedef int64_t (*Int64Return)() DART_UNUSED; | 689 typedef int64_t (*Int64Return)() DART_UNUSED; |
782 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 690 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
783 } | 691 } |
784 | 692 |
785 | |
786 ASSEMBLER_TEST_GENERATE(AndImmCsp, assembler) { | 693 ASSEMBLER_TEST_GENERATE(AndImmCsp, assembler) { |
787 // Note we must maintain the ARM64 ABI invariants on CSP here. | 694 // Note we must maintain the ARM64 ABI invariants on CSP here. |
788 __ mov(TMP, CSP); | 695 __ mov(TMP, CSP); |
789 __ sub(TMP2, CSP, Operand(31)); | 696 __ sub(TMP2, CSP, Operand(31)); |
790 __ andi(CSP, TMP2, Immediate(~15)); | 697 __ andi(CSP, TMP2, Immediate(~15)); |
791 __ mov(R0, CSP); | 698 __ mov(R0, CSP); |
792 __ sub(R0, TMP, Operand(R0)); | 699 __ sub(R0, TMP, Operand(R0)); |
793 __ mov(CSP, TMP); | 700 __ mov(CSP, TMP); |
794 __ ret(); | 701 __ ret(); |
795 } | 702 } |
796 | 703 |
797 | |
798 ASSEMBLER_TEST_RUN(AndImmCsp, test) { | 704 ASSEMBLER_TEST_RUN(AndImmCsp, test) { |
799 typedef int64_t (*Int64Return)() DART_UNUSED; | 705 typedef int64_t (*Int64Return)() DART_UNUSED; |
800 EXPECT_EQ(32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 706 EXPECT_EQ(32, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
801 } | 707 } |
802 | 708 |
803 | |
804 ASSEMBLER_TEST_GENERATE(AndOneImm, assembler) { | 709 ASSEMBLER_TEST_GENERATE(AndOneImm, assembler) { |
805 __ movz(R1, Immediate(43), 0); | 710 __ movz(R1, Immediate(43), 0); |
806 __ andi(R0, R1, Immediate(1)); | 711 __ andi(R0, R1, Immediate(1)); |
807 __ ret(); | 712 __ ret(); |
808 } | 713 } |
809 | 714 |
810 | |
811 ASSEMBLER_TEST_RUN(AndOneImm, test) { | 715 ASSEMBLER_TEST_RUN(AndOneImm, test) { |
812 typedef int64_t (*Int64Return)() DART_UNUSED; | 716 typedef int64_t (*Int64Return)() DART_UNUSED; |
813 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 717 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
814 } | 718 } |
815 | 719 |
816 | |
817 ASSEMBLER_TEST_GENERATE(OrrImm, assembler) { | 720 ASSEMBLER_TEST_GENERATE(OrrImm, assembler) { |
818 __ movz(R1, Immediate(0), 0); | 721 __ movz(R1, Immediate(0), 0); |
819 __ movz(R2, Immediate(0x3f), 0); | 722 __ movz(R2, Immediate(0x3f), 0); |
820 __ movz(R3, Immediate(0xa), 0); | 723 __ movz(R3, Immediate(0xa), 0); |
821 __ orri(R1, R1, Immediate(0x0020002000200020ULL)); | 724 __ orri(R1, R1, Immediate(0x0020002000200020ULL)); |
822 __ orr(R1, R1, Operand(R3)); | 725 __ orr(R1, R1, Operand(R3)); |
823 __ and_(R0, R1, Operand(R2)); | 726 __ and_(R0, R1, Operand(R2)); |
824 __ ret(); | 727 __ ret(); |
825 } | 728 } |
826 | 729 |
827 | |
828 ASSEMBLER_TEST_RUN(OrrImm, test) { | 730 ASSEMBLER_TEST_RUN(OrrImm, test) { |
829 typedef int64_t (*Int64Return)() DART_UNUSED; | 731 typedef int64_t (*Int64Return)() DART_UNUSED; |
830 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 732 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
831 } | 733 } |
832 | 734 |
833 | |
834 ASSEMBLER_TEST_GENERATE(EorImm, assembler) { | 735 ASSEMBLER_TEST_GENERATE(EorImm, assembler) { |
835 __ movn(R0, Immediate(0), 0); | 736 __ movn(R0, Immediate(0), 0); |
836 __ movk(R0, Immediate(0xffd5), 0); // R0 < 0xffffffffffffffd5. | 737 __ movk(R0, Immediate(0xffd5), 0); // R0 < 0xffffffffffffffd5. |
837 __ movz(R1, Immediate(0x3f), 0); | 738 __ movz(R1, Immediate(0x3f), 0); |
838 __ eori(R0, R0, Immediate(0x3f3f3f3f3f3f3f3fULL)); | 739 __ eori(R0, R0, Immediate(0x3f3f3f3f3f3f3f3fULL)); |
839 __ and_(R0, R0, Operand(R1)); | 740 __ and_(R0, R0, Operand(R1)); |
840 __ ret(); | 741 __ ret(); |
841 } | 742 } |
842 | 743 |
843 | |
844 ASSEMBLER_TEST_RUN(EorImm, test) { | 744 ASSEMBLER_TEST_RUN(EorImm, test) { |
845 typedef int64_t (*Int64Return)() DART_UNUSED; | 745 typedef int64_t (*Int64Return)() DART_UNUSED; |
846 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 746 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
847 } | 747 } |
848 | 748 |
849 | |
850 ASSEMBLER_TEST_GENERATE(Clz, assembler) { | 749 ASSEMBLER_TEST_GENERATE(Clz, assembler) { |
851 Label error; | 750 Label error; |
852 | 751 |
853 __ clz(R1, ZR); | 752 __ clz(R1, ZR); |
854 __ cmp(R1, Operand(64)); | 753 __ cmp(R1, Operand(64)); |
855 __ b(&error, NE); | 754 __ b(&error, NE); |
856 __ LoadImmediate(R2, 42); | 755 __ LoadImmediate(R2, 42); |
857 __ clz(R2, R2); | 756 __ clz(R2, R2); |
858 __ cmp(R2, Operand(58)); | 757 __ cmp(R2, Operand(58)); |
859 __ b(&error, NE); | 758 __ b(&error, NE); |
860 __ LoadImmediate(R0, -1); | 759 __ LoadImmediate(R0, -1); |
861 __ clz(R1, R0); | 760 __ clz(R1, R0); |
862 __ cmp(R1, Operand(0)); | 761 __ cmp(R1, Operand(0)); |
863 __ b(&error, NE); | 762 __ b(&error, NE); |
864 __ add(R0, ZR, Operand(R0, LSR, 3)); | 763 __ add(R0, ZR, Operand(R0, LSR, 3)); |
865 __ clz(R1, R0); | 764 __ clz(R1, R0); |
866 __ cmp(R1, Operand(3)); | 765 __ cmp(R1, Operand(3)); |
867 __ b(&error, NE); | 766 __ b(&error, NE); |
868 __ mov(R0, ZR); | 767 __ mov(R0, ZR); |
869 __ ret(); | 768 __ ret(); |
870 __ Bind(&error); | 769 __ Bind(&error); |
871 __ LoadImmediate(R0, 1); | 770 __ LoadImmediate(R0, 1); |
872 __ ret(); | 771 __ ret(); |
873 } | 772 } |
874 | 773 |
875 | |
876 ASSEMBLER_TEST_RUN(Clz, test) { | 774 ASSEMBLER_TEST_RUN(Clz, test) { |
877 typedef int64_t (*Int64Return)() DART_UNUSED; | 775 typedef int64_t (*Int64Return)() DART_UNUSED; |
878 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 776 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
879 } | 777 } |
880 | 778 |
881 | |
882 // Comparisons, branching. | 779 // Comparisons, branching. |
883 ASSEMBLER_TEST_GENERATE(BranchALForward, assembler) { | 780 ASSEMBLER_TEST_GENERATE(BranchALForward, assembler) { |
884 Label l; | 781 Label l; |
885 __ movz(R0, Immediate(42), 0); | 782 __ movz(R0, Immediate(42), 0); |
886 __ b(&l, AL); | 783 __ b(&l, AL); |
887 __ movz(R0, Immediate(0), 0); | 784 __ movz(R0, Immediate(0), 0); |
888 __ Bind(&l); | 785 __ Bind(&l); |
889 __ ret(); | 786 __ ret(); |
890 } | 787 } |
891 | 788 |
892 | |
893 ASSEMBLER_TEST_RUN(BranchALForward, test) { | 789 ASSEMBLER_TEST_RUN(BranchALForward, test) { |
894 typedef int64_t (*Int64Return)() DART_UNUSED; | 790 typedef int64_t (*Int64Return)() DART_UNUSED; |
895 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 791 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
896 } | 792 } |
897 | 793 |
898 | |
899 ASSEMBLER_TEST_GENERATE(BranchALBackwards, assembler) { | 794 ASSEMBLER_TEST_GENERATE(BranchALBackwards, assembler) { |
900 Label l, leave; | 795 Label l, leave; |
901 __ movz(R0, Immediate(42), 0); | 796 __ movz(R0, Immediate(42), 0); |
902 __ b(&l, AL); | 797 __ b(&l, AL); |
903 | 798 |
904 __ movz(R0, Immediate(0), 0); | 799 __ movz(R0, Immediate(0), 0); |
905 __ Bind(&leave); | 800 __ Bind(&leave); |
906 __ ret(); | 801 __ ret(); |
907 __ movz(R0, Immediate(0), 0); | 802 __ movz(R0, Immediate(0), 0); |
908 | 803 |
909 __ Bind(&l); | 804 __ Bind(&l); |
910 __ b(&leave, AL); | 805 __ b(&leave, AL); |
911 __ movz(R0, Immediate(0), 0); | 806 __ movz(R0, Immediate(0), 0); |
912 __ ret(); | 807 __ ret(); |
913 } | 808 } |
914 | 809 |
915 | |
916 ASSEMBLER_TEST_RUN(BranchALBackwards, test) { | 810 ASSEMBLER_TEST_RUN(BranchALBackwards, test) { |
917 typedef int64_t (*Int64Return)() DART_UNUSED; | 811 typedef int64_t (*Int64Return)() DART_UNUSED; |
918 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 812 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
919 } | 813 } |
920 | 814 |
921 | |
922 ASSEMBLER_TEST_GENERATE(CmpEqBranch, assembler) { | 815 ASSEMBLER_TEST_GENERATE(CmpEqBranch, assembler) { |
923 Label l; | 816 Label l; |
924 | 817 |
925 __ movz(R0, Immediate(42), 0); | 818 __ movz(R0, Immediate(42), 0); |
926 __ movz(R1, Immediate(234), 0); | 819 __ movz(R1, Immediate(234), 0); |
927 __ movz(R2, Immediate(234), 0); | 820 __ movz(R2, Immediate(234), 0); |
928 | 821 |
929 __ cmp(R1, Operand(R2)); | 822 __ cmp(R1, Operand(R2)); |
930 __ b(&l, EQ); | 823 __ b(&l, EQ); |
931 __ movz(R0, Immediate(0), 0); | 824 __ movz(R0, Immediate(0), 0); |
932 __ Bind(&l); | 825 __ Bind(&l); |
933 __ ret(); | 826 __ ret(); |
934 } | 827 } |
935 | 828 |
936 | |
937 ASSEMBLER_TEST_RUN(CmpEqBranch, test) { | 829 ASSEMBLER_TEST_RUN(CmpEqBranch, test) { |
938 typedef int64_t (*Int64Return)() DART_UNUSED; | 830 typedef int64_t (*Int64Return)() DART_UNUSED; |
939 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 831 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
940 } | 832 } |
941 | 833 |
942 | |
943 ASSEMBLER_TEST_GENERATE(CmpEqBranchNotTaken, assembler) { | 834 ASSEMBLER_TEST_GENERATE(CmpEqBranchNotTaken, assembler) { |
944 Label l; | 835 Label l; |
945 | 836 |
946 __ movz(R0, Immediate(0), 0); | 837 __ movz(R0, Immediate(0), 0); |
947 __ movz(R1, Immediate(233), 0); | 838 __ movz(R1, Immediate(233), 0); |
948 __ movz(R2, Immediate(234), 0); | 839 __ movz(R2, Immediate(234), 0); |
949 | 840 |
950 __ cmp(R1, Operand(R2)); | 841 __ cmp(R1, Operand(R2)); |
951 __ b(&l, EQ); | 842 __ b(&l, EQ); |
952 __ movz(R0, Immediate(42), 0); | 843 __ movz(R0, Immediate(42), 0); |
953 __ Bind(&l); | 844 __ Bind(&l); |
954 __ ret(); | 845 __ ret(); |
955 } | 846 } |
956 | 847 |
957 | |
958 ASSEMBLER_TEST_RUN(CmpEqBranchNotTaken, test) { | 848 ASSEMBLER_TEST_RUN(CmpEqBranchNotTaken, test) { |
959 typedef int64_t (*Int64Return)() DART_UNUSED; | 849 typedef int64_t (*Int64Return)() DART_UNUSED; |
960 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 850 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
961 } | 851 } |
962 | 852 |
963 | |
964 ASSEMBLER_TEST_GENERATE(CmpEq1Branch, assembler) { | 853 ASSEMBLER_TEST_GENERATE(CmpEq1Branch, assembler) { |
965 Label l; | 854 Label l; |
966 | 855 |
967 __ movz(R0, Immediate(42), 0); | 856 __ movz(R0, Immediate(42), 0); |
968 __ movz(R1, Immediate(1), 0); | 857 __ movz(R1, Immediate(1), 0); |
969 | 858 |
970 __ cmp(R1, Operand(1)); | 859 __ cmp(R1, Operand(1)); |
971 __ b(&l, EQ); | 860 __ b(&l, EQ); |
972 __ movz(R0, Immediate(0), 0); | 861 __ movz(R0, Immediate(0), 0); |
973 __ Bind(&l); | 862 __ Bind(&l); |
974 __ ret(); | 863 __ ret(); |
975 } | 864 } |
976 | 865 |
977 | |
978 ASSEMBLER_TEST_RUN(CmpEq1Branch, test) { | 866 ASSEMBLER_TEST_RUN(CmpEq1Branch, test) { |
979 typedef int64_t (*Int64Return)() DART_UNUSED; | 867 typedef int64_t (*Int64Return)() DART_UNUSED; |
980 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 868 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
981 } | 869 } |
982 | 870 |
983 | |
984 ASSEMBLER_TEST_GENERATE(CmnEq1Branch, assembler) { | 871 ASSEMBLER_TEST_GENERATE(CmnEq1Branch, assembler) { |
985 Label l; | 872 Label l; |
986 | 873 |
987 __ movz(R0, Immediate(42), 0); | 874 __ movz(R0, Immediate(42), 0); |
988 __ movn(R1, Immediate(0), 0); // R1 <- -1 | 875 __ movn(R1, Immediate(0), 0); // R1 <- -1 |
989 | 876 |
990 __ cmn(R1, Operand(1)); | 877 __ cmn(R1, Operand(1)); |
991 __ b(&l, EQ); | 878 __ b(&l, EQ); |
992 __ movz(R0, Immediate(0), 0); | 879 __ movz(R0, Immediate(0), 0); |
993 __ Bind(&l); | 880 __ Bind(&l); |
994 __ ret(); | 881 __ ret(); |
995 } | 882 } |
996 | 883 |
997 | |
998 ASSEMBLER_TEST_RUN(CmnEq1Branch, test) { | 884 ASSEMBLER_TEST_RUN(CmnEq1Branch, test) { |
999 typedef int64_t (*Int64Return)() DART_UNUSED; | 885 typedef int64_t (*Int64Return)() DART_UNUSED; |
1000 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 886 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1001 } | 887 } |
1002 | 888 |
1003 | |
1004 ASSEMBLER_TEST_GENERATE(CmpLtBranch, assembler) { | 889 ASSEMBLER_TEST_GENERATE(CmpLtBranch, assembler) { |
1005 Label l; | 890 Label l; |
1006 | 891 |
1007 __ movz(R0, Immediate(42), 0); | 892 __ movz(R0, Immediate(42), 0); |
1008 __ movz(R1, Immediate(233), 0); | 893 __ movz(R1, Immediate(233), 0); |
1009 __ movz(R2, Immediate(234), 0); | 894 __ movz(R2, Immediate(234), 0); |
1010 | 895 |
1011 __ cmp(R1, Operand(R2)); | 896 __ cmp(R1, Operand(R2)); |
1012 __ b(&l, LT); | 897 __ b(&l, LT); |
1013 __ movz(R0, Immediate(0), 0); | 898 __ movz(R0, Immediate(0), 0); |
1014 __ Bind(&l); | 899 __ Bind(&l); |
1015 __ ret(); | 900 __ ret(); |
1016 } | 901 } |
1017 | 902 |
1018 | |
1019 ASSEMBLER_TEST_RUN(CmpLtBranch, test) { | 903 ASSEMBLER_TEST_RUN(CmpLtBranch, test) { |
1020 typedef int64_t (*Int64Return)() DART_UNUSED; | 904 typedef int64_t (*Int64Return)() DART_UNUSED; |
1021 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 905 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1022 } | 906 } |
1023 | 907 |
1024 | |
1025 ASSEMBLER_TEST_GENERATE(CmpLtBranchNotTaken, assembler) { | 908 ASSEMBLER_TEST_GENERATE(CmpLtBranchNotTaken, assembler) { |
1026 Label l; | 909 Label l; |
1027 | 910 |
1028 __ movz(R0, Immediate(0), 0); | 911 __ movz(R0, Immediate(0), 0); |
1029 __ movz(R1, Immediate(235), 0); | 912 __ movz(R1, Immediate(235), 0); |
1030 __ movz(R2, Immediate(234), 0); | 913 __ movz(R2, Immediate(234), 0); |
1031 | 914 |
1032 __ cmp(R1, Operand(R2)); | 915 __ cmp(R1, Operand(R2)); |
1033 __ b(&l, LT); | 916 __ b(&l, LT); |
1034 __ movz(R0, Immediate(42), 0); | 917 __ movz(R0, Immediate(42), 0); |
1035 __ Bind(&l); | 918 __ Bind(&l); |
1036 __ ret(); | 919 __ ret(); |
1037 } | 920 } |
1038 | 921 |
1039 | |
1040 ASSEMBLER_TEST_RUN(CmpLtBranchNotTaken, test) { | 922 ASSEMBLER_TEST_RUN(CmpLtBranchNotTaken, test) { |
1041 typedef int64_t (*Int64Return)() DART_UNUSED; | 923 typedef int64_t (*Int64Return)() DART_UNUSED; |
1042 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 924 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1043 } | 925 } |
1044 | 926 |
1045 | |
1046 ASSEMBLER_TEST_GENERATE(CmpBranchIfZero, assembler) { | 927 ASSEMBLER_TEST_GENERATE(CmpBranchIfZero, assembler) { |
1047 Label l; | 928 Label l; |
1048 | 929 |
1049 __ movz(R0, Immediate(42), 0); | 930 __ movz(R0, Immediate(42), 0); |
1050 __ movz(R1, Immediate(0), 0); | 931 __ movz(R1, Immediate(0), 0); |
1051 | 932 |
1052 __ cbz(&l, R1); | 933 __ cbz(&l, R1); |
1053 __ movz(R0, Immediate(0), 0); | 934 __ movz(R0, Immediate(0), 0); |
1054 __ Bind(&l); | 935 __ Bind(&l); |
1055 __ ret(); | 936 __ ret(); |
1056 } | 937 } |
1057 | 938 |
1058 | |
1059 ASSEMBLER_TEST_RUN(CmpBranchIfZero, test) { | 939 ASSEMBLER_TEST_RUN(CmpBranchIfZero, test) { |
1060 typedef int64_t (*Int64Return)() DART_UNUSED; | 940 typedef int64_t (*Int64Return)() DART_UNUSED; |
1061 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 941 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1062 } | 942 } |
1063 | 943 |
1064 | |
1065 ASSEMBLER_TEST_GENERATE(CmpBranchIfZeroNotTaken, assembler) { | 944 ASSEMBLER_TEST_GENERATE(CmpBranchIfZeroNotTaken, assembler) { |
1066 Label l; | 945 Label l; |
1067 | 946 |
1068 __ movz(R0, Immediate(0), 0); | 947 __ movz(R0, Immediate(0), 0); |
1069 __ movz(R1, Immediate(1), 0); | 948 __ movz(R1, Immediate(1), 0); |
1070 | 949 |
1071 __ cbz(&l, R1); | 950 __ cbz(&l, R1); |
1072 __ movz(R0, Immediate(42), 0); | 951 __ movz(R0, Immediate(42), 0); |
1073 __ Bind(&l); | 952 __ Bind(&l); |
1074 __ ret(); | 953 __ ret(); |
1075 } | 954 } |
1076 | 955 |
1077 | |
1078 ASSEMBLER_TEST_RUN(CmpBranchIfZeroNotTaken, test) { | 956 ASSEMBLER_TEST_RUN(CmpBranchIfZeroNotTaken, test) { |
1079 typedef int64_t (*Int64Return)() DART_UNUSED; | 957 typedef int64_t (*Int64Return)() DART_UNUSED; |
1080 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 958 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1081 } | 959 } |
1082 | 960 |
1083 | |
1084 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZero, assembler) { | 961 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZero, assembler) { |
1085 Label l; | 962 Label l; |
1086 | 963 |
1087 __ movz(R0, Immediate(42), 0); | 964 __ movz(R0, Immediate(42), 0); |
1088 __ movz(R1, Immediate(1), 0); | 965 __ movz(R1, Immediate(1), 0); |
1089 | 966 |
1090 __ cbnz(&l, R1); | 967 __ cbnz(&l, R1); |
1091 __ movz(R0, Immediate(0), 0); | 968 __ movz(R0, Immediate(0), 0); |
1092 __ Bind(&l); | 969 __ Bind(&l); |
1093 __ ret(); | 970 __ ret(); |
1094 } | 971 } |
1095 | 972 |
1096 | |
1097 ASSEMBLER_TEST_RUN(CmpBranchIfNotZero, test) { | 973 ASSEMBLER_TEST_RUN(CmpBranchIfNotZero, test) { |
1098 typedef int64_t (*Int64Return)() DART_UNUSED; | 974 typedef int64_t (*Int64Return)() DART_UNUSED; |
1099 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 975 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1100 } | 976 } |
1101 | 977 |
1102 | |
1103 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZeroNotTaken, assembler) { | 978 ASSEMBLER_TEST_GENERATE(CmpBranchIfNotZeroNotTaken, assembler) { |
1104 Label l; | 979 Label l; |
1105 | 980 |
1106 __ movz(R0, Immediate(0), 0); | 981 __ movz(R0, Immediate(0), 0); |
1107 __ movz(R1, Immediate(0), 0); | 982 __ movz(R1, Immediate(0), 0); |
1108 | 983 |
1109 __ cbnz(&l, R1); | 984 __ cbnz(&l, R1); |
1110 __ movz(R0, Immediate(42), 0); | 985 __ movz(R0, Immediate(42), 0); |
1111 __ Bind(&l); | 986 __ Bind(&l); |
1112 __ ret(); | 987 __ ret(); |
1113 } | 988 } |
1114 | 989 |
1115 | |
1116 ASSEMBLER_TEST_RUN(CmpBranchIfNotZeroNotTaken, test) { | 990 ASSEMBLER_TEST_RUN(CmpBranchIfNotZeroNotTaken, test) { |
1117 typedef int64_t (*Int64Return)() DART_UNUSED; | 991 typedef int64_t (*Int64Return)() DART_UNUSED; |
1118 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 992 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1119 } | 993 } |
1120 | 994 |
1121 | |
1122 ASSEMBLER_TEST_GENERATE(FcmpEqBranch, assembler) { | 995 ASSEMBLER_TEST_GENERATE(FcmpEqBranch, assembler) { |
1123 Label l; | 996 Label l; |
1124 | 997 |
1125 __ LoadDImmediate(V0, 42.0); | 998 __ LoadDImmediate(V0, 42.0); |
1126 __ LoadDImmediate(V1, 234.0); | 999 __ LoadDImmediate(V1, 234.0); |
1127 __ LoadDImmediate(V2, 234.0); | 1000 __ LoadDImmediate(V2, 234.0); |
1128 | 1001 |
1129 __ fcmpd(V1, V2); | 1002 __ fcmpd(V1, V2); |
1130 __ b(&l, EQ); | 1003 __ b(&l, EQ); |
1131 __ LoadDImmediate(V0, 0.0); | 1004 __ LoadDImmediate(V0, 0.0); |
1132 __ Bind(&l); | 1005 __ Bind(&l); |
1133 __ ret(); | 1006 __ ret(); |
1134 } | 1007 } |
1135 | 1008 |
1136 | |
1137 ASSEMBLER_TEST_RUN(FcmpEqBranch, test) { | 1009 ASSEMBLER_TEST_RUN(FcmpEqBranch, test) { |
1138 typedef double (*DoubleReturn)() DART_UNUSED; | 1010 typedef double (*DoubleReturn)() DART_UNUSED; |
1139 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1011 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
1140 } | 1012 } |
1141 | 1013 |
1142 | |
1143 ASSEMBLER_TEST_GENERATE(FcmpEqBranchNotTaken, assembler) { | 1014 ASSEMBLER_TEST_GENERATE(FcmpEqBranchNotTaken, assembler) { |
1144 Label l; | 1015 Label l; |
1145 | 1016 |
1146 __ LoadDImmediate(V0, 0.0); | 1017 __ LoadDImmediate(V0, 0.0); |
1147 __ LoadDImmediate(V1, 233.0); | 1018 __ LoadDImmediate(V1, 233.0); |
1148 __ LoadDImmediate(V2, 234.0); | 1019 __ LoadDImmediate(V2, 234.0); |
1149 | 1020 |
1150 __ fcmpd(V1, V2); | 1021 __ fcmpd(V1, V2); |
1151 __ b(&l, EQ); | 1022 __ b(&l, EQ); |
1152 __ LoadDImmediate(V0, 42.0); | 1023 __ LoadDImmediate(V0, 42.0); |
1153 __ Bind(&l); | 1024 __ Bind(&l); |
1154 __ ret(); | 1025 __ ret(); |
1155 } | 1026 } |
1156 | 1027 |
1157 | |
1158 ASSEMBLER_TEST_RUN(FcmpEqBranchNotTaken, test) { | 1028 ASSEMBLER_TEST_RUN(FcmpEqBranchNotTaken, test) { |
1159 typedef double (*DoubleReturn)() DART_UNUSED; | 1029 typedef double (*DoubleReturn)() DART_UNUSED; |
1160 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1030 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
1161 } | 1031 } |
1162 | 1032 |
1163 | |
1164 ASSEMBLER_TEST_GENERATE(FcmpLtBranch, assembler) { | 1033 ASSEMBLER_TEST_GENERATE(FcmpLtBranch, assembler) { |
1165 Label l; | 1034 Label l; |
1166 | 1035 |
1167 __ LoadDImmediate(V0, 42.0); | 1036 __ LoadDImmediate(V0, 42.0); |
1168 __ LoadDImmediate(V1, 233.0); | 1037 __ LoadDImmediate(V1, 233.0); |
1169 __ LoadDImmediate(V2, 234.0); | 1038 __ LoadDImmediate(V2, 234.0); |
1170 | 1039 |
1171 __ fcmpd(V1, V2); | 1040 __ fcmpd(V1, V2); |
1172 __ b(&l, LT); | 1041 __ b(&l, LT); |
1173 __ LoadDImmediate(V0, 0.0); | 1042 __ LoadDImmediate(V0, 0.0); |
1174 __ Bind(&l); | 1043 __ Bind(&l); |
1175 __ ret(); | 1044 __ ret(); |
1176 } | 1045 } |
1177 | 1046 |
1178 | |
1179 ASSEMBLER_TEST_RUN(FcmpLtBranch, test) { | 1047 ASSEMBLER_TEST_RUN(FcmpLtBranch, test) { |
1180 typedef double (*DoubleReturn)() DART_UNUSED; | 1048 typedef double (*DoubleReturn)() DART_UNUSED; |
1181 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1049 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
1182 } | 1050 } |
1183 | 1051 |
1184 | |
1185 ASSEMBLER_TEST_GENERATE(FcmpLtBranchNotTaken, assembler) { | 1052 ASSEMBLER_TEST_GENERATE(FcmpLtBranchNotTaken, assembler) { |
1186 Label l; | 1053 Label l; |
1187 | 1054 |
1188 __ LoadDImmediate(V0, 0.0); | 1055 __ LoadDImmediate(V0, 0.0); |
1189 __ LoadDImmediate(V1, 235.0); | 1056 __ LoadDImmediate(V1, 235.0); |
1190 __ LoadDImmediate(V2, 234.0); | 1057 __ LoadDImmediate(V2, 234.0); |
1191 | 1058 |
1192 __ fcmpd(V1, V2); | 1059 __ fcmpd(V1, V2); |
1193 __ b(&l, LT); | 1060 __ b(&l, LT); |
1194 __ LoadDImmediate(V0, 42.0); | 1061 __ LoadDImmediate(V0, 42.0); |
1195 __ Bind(&l); | 1062 __ Bind(&l); |
1196 __ ret(); | 1063 __ ret(); |
1197 } | 1064 } |
1198 | 1065 |
1199 | |
1200 ASSEMBLER_TEST_RUN(FcmpLtBranchNotTaken, test) { | 1066 ASSEMBLER_TEST_RUN(FcmpLtBranchNotTaken, test) { |
1201 typedef double (*DoubleReturn)() DART_UNUSED; | 1067 typedef double (*DoubleReturn)() DART_UNUSED; |
1202 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1068 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
1203 } | 1069 } |
1204 | 1070 |
1205 | |
1206 ASSEMBLER_TEST_GENERATE(FcmpzGtBranch, assembler) { | 1071 ASSEMBLER_TEST_GENERATE(FcmpzGtBranch, assembler) { |
1207 Label l; | 1072 Label l; |
1208 | 1073 |
1209 __ LoadDImmediate(V0, 235.0); | 1074 __ LoadDImmediate(V0, 235.0); |
1210 __ LoadDImmediate(V1, 233.0); | 1075 __ LoadDImmediate(V1, 233.0); |
1211 | 1076 |
1212 __ fcmpdz(V1); | 1077 __ fcmpdz(V1); |
1213 __ b(&l, GT); | 1078 __ b(&l, GT); |
1214 __ LoadDImmediate(V0, 0.0); | 1079 __ LoadDImmediate(V0, 0.0); |
1215 __ ret(); | 1080 __ ret(); |
1216 __ Bind(&l); | 1081 __ Bind(&l); |
1217 __ LoadDImmediate(V0, 42.0); | 1082 __ LoadDImmediate(V0, 42.0); |
1218 __ ret(); | 1083 __ ret(); |
1219 } | 1084 } |
1220 | 1085 |
1221 | |
1222 ASSEMBLER_TEST_RUN(FcmpzGtBranch, test) { | 1086 ASSEMBLER_TEST_RUN(FcmpzGtBranch, test) { |
1223 typedef double (*DoubleReturn)() DART_UNUSED; | 1087 typedef double (*DoubleReturn)() DART_UNUSED; |
1224 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1088 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
1225 } | 1089 } |
1226 | 1090 |
1227 | |
1228 ASSEMBLER_TEST_GENERATE(AndsBranch, assembler) { | 1091 ASSEMBLER_TEST_GENERATE(AndsBranch, assembler) { |
1229 Label l; | 1092 Label l; |
1230 | 1093 |
1231 __ movz(R0, Immediate(42), 0); | 1094 __ movz(R0, Immediate(42), 0); |
1232 __ movz(R1, Immediate(2), 0); | 1095 __ movz(R1, Immediate(2), 0); |
1233 __ movz(R2, Immediate(1), 0); | 1096 __ movz(R2, Immediate(1), 0); |
1234 | 1097 |
1235 __ ands(R3, R1, Operand(R2)); | 1098 __ ands(R3, R1, Operand(R2)); |
1236 __ b(&l, EQ); | 1099 __ b(&l, EQ); |
1237 __ movz(R0, Immediate(0), 0); | 1100 __ movz(R0, Immediate(0), 0); |
1238 __ Bind(&l); | 1101 __ Bind(&l); |
1239 __ ret(); | 1102 __ ret(); |
1240 } | 1103 } |
1241 | 1104 |
1242 | |
1243 ASSEMBLER_TEST_RUN(AndsBranch, test) { | 1105 ASSEMBLER_TEST_RUN(AndsBranch, test) { |
1244 typedef int64_t (*Int64Return)() DART_UNUSED; | 1106 typedef int64_t (*Int64Return)() DART_UNUSED; |
1245 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1107 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1246 } | 1108 } |
1247 | 1109 |
1248 | |
1249 ASSEMBLER_TEST_GENERATE(AndsBranchNotTaken, assembler) { | 1110 ASSEMBLER_TEST_GENERATE(AndsBranchNotTaken, assembler) { |
1250 Label l; | 1111 Label l; |
1251 | 1112 |
1252 __ movz(R0, Immediate(0), 0); | 1113 __ movz(R0, Immediate(0), 0); |
1253 __ movz(R1, Immediate(2), 0); | 1114 __ movz(R1, Immediate(2), 0); |
1254 __ movz(R2, Immediate(2), 0); | 1115 __ movz(R2, Immediate(2), 0); |
1255 | 1116 |
1256 __ ands(R3, R1, Operand(R2)); | 1117 __ ands(R3, R1, Operand(R2)); |
1257 __ b(&l, EQ); | 1118 __ b(&l, EQ); |
1258 __ movz(R0, Immediate(42), 0); | 1119 __ movz(R0, Immediate(42), 0); |
1259 __ Bind(&l); | 1120 __ Bind(&l); |
1260 __ ret(); | 1121 __ ret(); |
1261 } | 1122 } |
1262 | 1123 |
1263 | |
1264 ASSEMBLER_TEST_RUN(AndsBranchNotTaken, test) { | 1124 ASSEMBLER_TEST_RUN(AndsBranchNotTaken, test) { |
1265 typedef int64_t (*Int64Return)() DART_UNUSED; | 1125 typedef int64_t (*Int64Return)() DART_UNUSED; |
1266 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1126 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1267 } | 1127 } |
1268 | 1128 |
1269 | |
1270 ASSEMBLER_TEST_GENERATE(BicsBranch, assembler) { | 1129 ASSEMBLER_TEST_GENERATE(BicsBranch, assembler) { |
1271 Label l; | 1130 Label l; |
1272 | 1131 |
1273 __ movz(R0, Immediate(42), 0); | 1132 __ movz(R0, Immediate(42), 0); |
1274 __ movz(R1, Immediate(2), 0); | 1133 __ movz(R1, Immediate(2), 0); |
1275 __ movz(R2, Immediate(2), 0); | 1134 __ movz(R2, Immediate(2), 0); |
1276 | 1135 |
1277 __ bics(R3, R1, Operand(R2)); | 1136 __ bics(R3, R1, Operand(R2)); |
1278 __ b(&l, EQ); | 1137 __ b(&l, EQ); |
1279 __ movz(R0, Immediate(0), 0); | 1138 __ movz(R0, Immediate(0), 0); |
1280 __ Bind(&l); | 1139 __ Bind(&l); |
1281 __ ret(); | 1140 __ ret(); |
1282 } | 1141 } |
1283 | 1142 |
1284 | |
1285 ASSEMBLER_TEST_RUN(BicsBranch, test) { | 1143 ASSEMBLER_TEST_RUN(BicsBranch, test) { |
1286 typedef int64_t (*Int64Return)() DART_UNUSED; | 1144 typedef int64_t (*Int64Return)() DART_UNUSED; |
1287 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1145 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1288 } | 1146 } |
1289 | 1147 |
1290 | |
1291 ASSEMBLER_TEST_GENERATE(BicsBranchNotTaken, assembler) { | 1148 ASSEMBLER_TEST_GENERATE(BicsBranchNotTaken, assembler) { |
1292 Label l; | 1149 Label l; |
1293 | 1150 |
1294 __ movz(R0, Immediate(0), 0); | 1151 __ movz(R0, Immediate(0), 0); |
1295 __ movz(R1, Immediate(2), 0); | 1152 __ movz(R1, Immediate(2), 0); |
1296 __ movz(R2, Immediate(1), 0); | 1153 __ movz(R2, Immediate(1), 0); |
1297 | 1154 |
1298 __ bics(R3, R1, Operand(R2)); | 1155 __ bics(R3, R1, Operand(R2)); |
1299 __ b(&l, EQ); | 1156 __ b(&l, EQ); |
1300 __ movz(R0, Immediate(42), 0); | 1157 __ movz(R0, Immediate(42), 0); |
1301 __ Bind(&l); | 1158 __ Bind(&l); |
1302 __ ret(); | 1159 __ ret(); |
1303 } | 1160 } |
1304 | 1161 |
1305 | |
1306 ASSEMBLER_TEST_RUN(BicsBranchNotTaken, test) { | 1162 ASSEMBLER_TEST_RUN(BicsBranchNotTaken, test) { |
1307 typedef int64_t (*Int64Return)() DART_UNUSED; | 1163 typedef int64_t (*Int64Return)() DART_UNUSED; |
1308 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1164 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1309 } | 1165 } |
1310 | 1166 |
1311 | |
1312 ASSEMBLER_TEST_GENERATE(AndisBranch, assembler) { | 1167 ASSEMBLER_TEST_GENERATE(AndisBranch, assembler) { |
1313 Label l; | 1168 Label l; |
1314 | 1169 |
1315 __ movz(R0, Immediate(42), 0); | 1170 __ movz(R0, Immediate(42), 0); |
1316 __ movz(R1, Immediate(2), 0); | 1171 __ movz(R1, Immediate(2), 0); |
1317 | 1172 |
1318 __ andis(R3, R1, Immediate(1)); | 1173 __ andis(R3, R1, Immediate(1)); |
1319 __ b(&l, EQ); | 1174 __ b(&l, EQ); |
1320 __ movz(R0, Immediate(0), 0); | 1175 __ movz(R0, Immediate(0), 0); |
1321 __ Bind(&l); | 1176 __ Bind(&l); |
1322 __ ret(); | 1177 __ ret(); |
1323 } | 1178 } |
1324 | 1179 |
1325 | |
1326 ASSEMBLER_TEST_RUN(AndisBranch, test) { | 1180 ASSEMBLER_TEST_RUN(AndisBranch, test) { |
1327 typedef int64_t (*Int64Return)() DART_UNUSED; | 1181 typedef int64_t (*Int64Return)() DART_UNUSED; |
1328 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1182 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1329 } | 1183 } |
1330 | 1184 |
1331 | |
1332 ASSEMBLER_TEST_GENERATE(AndisBranchNotTaken, assembler) { | 1185 ASSEMBLER_TEST_GENERATE(AndisBranchNotTaken, assembler) { |
1333 Label l; | 1186 Label l; |
1334 | 1187 |
1335 __ movz(R0, Immediate(0), 0); | 1188 __ movz(R0, Immediate(0), 0); |
1336 __ movz(R1, Immediate(2), 0); | 1189 __ movz(R1, Immediate(2), 0); |
1337 | 1190 |
1338 __ andis(R3, R1, Immediate(2)); | 1191 __ andis(R3, R1, Immediate(2)); |
1339 __ b(&l, EQ); | 1192 __ b(&l, EQ); |
1340 __ movz(R0, Immediate(42), 0); | 1193 __ movz(R0, Immediate(42), 0); |
1341 __ Bind(&l); | 1194 __ Bind(&l); |
1342 __ ret(); | 1195 __ ret(); |
1343 } | 1196 } |
1344 | 1197 |
1345 | |
1346 ASSEMBLER_TEST_RUN(AndisBranchNotTaken, test) { | 1198 ASSEMBLER_TEST_RUN(AndisBranchNotTaken, test) { |
1347 typedef int64_t (*Int64Return)() DART_UNUSED; | 1199 typedef int64_t (*Int64Return)() DART_UNUSED; |
1348 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1200 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1349 } | 1201 } |
1350 | 1202 |
1351 | |
1352 // Address of PC-rel offset, br, blr. | 1203 // Address of PC-rel offset, br, blr. |
1353 ASSEMBLER_TEST_GENERATE(AdrBr, assembler) { | 1204 ASSEMBLER_TEST_GENERATE(AdrBr, assembler) { |
1354 __ movz(R0, Immediate(123), 0); | 1205 __ movz(R0, Immediate(123), 0); |
1355 // R1 <- PC + 3*Instr::kInstrSize | 1206 // R1 <- PC + 3*Instr::kInstrSize |
1356 __ adr(R1, Immediate(3 * Instr::kInstrSize)); | 1207 __ adr(R1, Immediate(3 * Instr::kInstrSize)); |
1357 __ br(R1); | 1208 __ br(R1); |
1358 __ ret(); | 1209 __ ret(); |
1359 | 1210 |
1360 // br goes here. | 1211 // br goes here. |
1361 __ movz(R0, Immediate(42), 0); | 1212 __ movz(R0, Immediate(42), 0); |
1362 __ ret(); | 1213 __ ret(); |
1363 } | 1214 } |
1364 | 1215 |
1365 | |
1366 ASSEMBLER_TEST_RUN(AdrBr, test) { | 1216 ASSEMBLER_TEST_RUN(AdrBr, test) { |
1367 typedef int64_t (*Int64Return)() DART_UNUSED; | 1217 typedef int64_t (*Int64Return)() DART_UNUSED; |
1368 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1218 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1369 } | 1219 } |
1370 | 1220 |
1371 | |
1372 ASSEMBLER_TEST_GENERATE(AdrBlr, assembler) { | 1221 ASSEMBLER_TEST_GENERATE(AdrBlr, assembler) { |
1373 __ movz(R0, Immediate(123), 0); | 1222 __ movz(R0, Immediate(123), 0); |
1374 __ add(R3, ZR, Operand(LR)); // Save LR. | 1223 __ add(R3, ZR, Operand(LR)); // Save LR. |
1375 // R1 <- PC + 4*Instr::kInstrSize | 1224 // R1 <- PC + 4*Instr::kInstrSize |
1376 __ adr(R1, Immediate(4 * Instr::kInstrSize)); | 1225 __ adr(R1, Immediate(4 * Instr::kInstrSize)); |
1377 __ blr(R1); | 1226 __ blr(R1); |
1378 __ add(LR, ZR, Operand(R3)); | 1227 __ add(LR, ZR, Operand(R3)); |
1379 __ ret(); | 1228 __ ret(); |
1380 | 1229 |
1381 // blr goes here. | 1230 // blr goes here. |
1382 __ movz(R0, Immediate(42), 0); | 1231 __ movz(R0, Immediate(42), 0); |
1383 __ ret(); | 1232 __ ret(); |
1384 } | 1233 } |
1385 | 1234 |
1386 | |
1387 ASSEMBLER_TEST_RUN(AdrBlr, test) { | 1235 ASSEMBLER_TEST_RUN(AdrBlr, test) { |
1388 typedef int64_t (*Int64Return)() DART_UNUSED; | 1236 typedef int64_t (*Int64Return)() DART_UNUSED; |
1389 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1237 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1390 } | 1238 } |
1391 | 1239 |
1392 | |
1393 // Misc. arithmetic. | 1240 // Misc. arithmetic. |
1394 ASSEMBLER_TEST_GENERATE(Udiv, assembler) { | 1241 ASSEMBLER_TEST_GENERATE(Udiv, assembler) { |
1395 __ movz(R0, Immediate(27), 0); | 1242 __ movz(R0, Immediate(27), 0); |
1396 __ movz(R1, Immediate(9), 0); | 1243 __ movz(R1, Immediate(9), 0); |
1397 __ udiv(R2, R0, R1); | 1244 __ udiv(R2, R0, R1); |
1398 __ mov(R0, R2); | 1245 __ mov(R0, R2); |
1399 __ ret(); | 1246 __ ret(); |
1400 } | 1247 } |
1401 | 1248 |
1402 | |
1403 ASSEMBLER_TEST_RUN(Udiv, test) { | 1249 ASSEMBLER_TEST_RUN(Udiv, test) { |
1404 EXPECT(test != NULL); | 1250 EXPECT(test != NULL); |
1405 typedef int64_t (*Int64Return)() DART_UNUSED; | 1251 typedef int64_t (*Int64Return)() DART_UNUSED; |
1406 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1252 EXPECT_EQ(3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1407 } | 1253 } |
1408 | 1254 |
1409 | |
1410 ASSEMBLER_TEST_GENERATE(Sdiv, assembler) { | 1255 ASSEMBLER_TEST_GENERATE(Sdiv, assembler) { |
1411 __ movz(R0, Immediate(27), 0); | 1256 __ movz(R0, Immediate(27), 0); |
1412 __ movz(R1, Immediate(9), 0); | 1257 __ movz(R1, Immediate(9), 0); |
1413 __ neg(R1, R1); | 1258 __ neg(R1, R1); |
1414 __ sdiv(R2, R0, R1); | 1259 __ sdiv(R2, R0, R1); |
1415 __ mov(R0, R2); | 1260 __ mov(R0, R2); |
1416 __ ret(); | 1261 __ ret(); |
1417 } | 1262 } |
1418 | 1263 |
1419 | |
1420 ASSEMBLER_TEST_RUN(Sdiv, test) { | 1264 ASSEMBLER_TEST_RUN(Sdiv, test) { |
1421 EXPECT(test != NULL); | 1265 EXPECT(test != NULL); |
1422 typedef int64_t (*Int64Return)() DART_UNUSED; | 1266 typedef int64_t (*Int64Return)() DART_UNUSED; |
1423 EXPECT_EQ(-3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1267 EXPECT_EQ(-3, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1424 } | 1268 } |
1425 | 1269 |
1426 | |
1427 ASSEMBLER_TEST_GENERATE(Udiv_zero, assembler) { | 1270 ASSEMBLER_TEST_GENERATE(Udiv_zero, assembler) { |
1428 __ movz(R0, Immediate(27), 0); | 1271 __ movz(R0, Immediate(27), 0); |
1429 __ movz(R1, Immediate(0), 0); | 1272 __ movz(R1, Immediate(0), 0); |
1430 __ udiv(R2, R0, R1); | 1273 __ udiv(R2, R0, R1); |
1431 __ mov(R0, R2); | 1274 __ mov(R0, R2); |
1432 __ ret(); | 1275 __ ret(); |
1433 } | 1276 } |
1434 | 1277 |
1435 | |
1436 ASSEMBLER_TEST_RUN(Udiv_zero, test) { | 1278 ASSEMBLER_TEST_RUN(Udiv_zero, test) { |
1437 EXPECT(test != NULL); | 1279 EXPECT(test != NULL); |
1438 typedef int64_t (*Int64Return)() DART_UNUSED; | 1280 typedef int64_t (*Int64Return)() DART_UNUSED; |
1439 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1281 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1440 } | 1282 } |
1441 | 1283 |
1442 | |
1443 ASSEMBLER_TEST_GENERATE(Sdiv_zero, assembler) { | 1284 ASSEMBLER_TEST_GENERATE(Sdiv_zero, assembler) { |
1444 __ movz(R0, Immediate(27), 0); | 1285 __ movz(R0, Immediate(27), 0); |
1445 __ movz(R1, Immediate(0), 0); | 1286 __ movz(R1, Immediate(0), 0); |
1446 __ sdiv(R2, R0, R1); | 1287 __ sdiv(R2, R0, R1); |
1447 __ mov(R0, R2); | 1288 __ mov(R0, R2); |
1448 __ ret(); | 1289 __ ret(); |
1449 } | 1290 } |
1450 | 1291 |
1451 | |
1452 ASSEMBLER_TEST_RUN(Sdiv_zero, test) { | 1292 ASSEMBLER_TEST_RUN(Sdiv_zero, test) { |
1453 EXPECT(test != NULL); | 1293 EXPECT(test != NULL); |
1454 typedef int64_t (*Int64Return)() DART_UNUSED; | 1294 typedef int64_t (*Int64Return)() DART_UNUSED; |
1455 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1295 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1456 } | 1296 } |
1457 | 1297 |
1458 | |
1459 ASSEMBLER_TEST_GENERATE(Udiv_corner, assembler) { | 1298 ASSEMBLER_TEST_GENERATE(Udiv_corner, assembler) { |
1460 __ movz(R0, Immediate(0x8000), 3); // R0 <- 0x8000000000000000 | 1299 __ movz(R0, Immediate(0x8000), 3); // R0 <- 0x8000000000000000 |
1461 __ movn(R1, Immediate(0), 0); // R1 <- 0xffffffffffffffff | 1300 __ movn(R1, Immediate(0), 0); // R1 <- 0xffffffffffffffff |
1462 __ udiv(R2, R0, R1); | 1301 __ udiv(R2, R0, R1); |
1463 __ mov(R0, R2); | 1302 __ mov(R0, R2); |
1464 __ ret(); | 1303 __ ret(); |
1465 } | 1304 } |
1466 | 1305 |
1467 | |
1468 ASSEMBLER_TEST_RUN(Udiv_corner, test) { | 1306 ASSEMBLER_TEST_RUN(Udiv_corner, test) { |
1469 EXPECT(test != NULL); | 1307 EXPECT(test != NULL); |
1470 typedef int64_t (*Int64Return)() DART_UNUSED; | 1308 typedef int64_t (*Int64Return)() DART_UNUSED; |
1471 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1309 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1472 } | 1310 } |
1473 | 1311 |
1474 | |
1475 ASSEMBLER_TEST_GENERATE(Sdiv_corner, assembler) { | 1312 ASSEMBLER_TEST_GENERATE(Sdiv_corner, assembler) { |
1476 __ movz(R3, Immediate(0x8000), 3); // R0 <- 0x8000000000000000 | 1313 __ movz(R3, Immediate(0x8000), 3); // R0 <- 0x8000000000000000 |
1477 __ movn(R1, Immediate(0), 0); // R1 <- 0xffffffffffffffff | 1314 __ movn(R1, Immediate(0), 0); // R1 <- 0xffffffffffffffff |
1478 __ sdiv(R2, R3, R1); | 1315 __ sdiv(R2, R3, R1); |
1479 __ mov(R0, R2); | 1316 __ mov(R0, R2); |
1480 __ ret(); | 1317 __ ret(); |
1481 } | 1318 } |
1482 | 1319 |
1483 | |
1484 ASSEMBLER_TEST_RUN(Sdiv_corner, test) { | 1320 ASSEMBLER_TEST_RUN(Sdiv_corner, test) { |
1485 EXPECT(test != NULL); | 1321 EXPECT(test != NULL); |
1486 typedef int64_t (*Int64Return)() DART_UNUSED; | 1322 typedef int64_t (*Int64Return)() DART_UNUSED; |
1487 EXPECT_EQ(static_cast<int64_t>(0x8000000000000000), | 1323 EXPECT_EQ(static_cast<int64_t>(0x8000000000000000), |
1488 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1324 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1489 } | 1325 } |
1490 | 1326 |
1491 | |
1492 ASSEMBLER_TEST_GENERATE(Lslv, assembler) { | 1327 ASSEMBLER_TEST_GENERATE(Lslv, assembler) { |
1493 __ movz(R1, Immediate(21), 0); | 1328 __ movz(R1, Immediate(21), 0); |
1494 __ movz(R2, Immediate(1), 0); | 1329 __ movz(R2, Immediate(1), 0); |
1495 __ lslv(R0, R1, R2); | 1330 __ lslv(R0, R1, R2); |
1496 __ ret(); | 1331 __ ret(); |
1497 } | 1332 } |
1498 | 1333 |
1499 | |
1500 ASSEMBLER_TEST_RUN(Lslv, test) { | 1334 ASSEMBLER_TEST_RUN(Lslv, test) { |
1501 typedef int64_t (*Int64Return)() DART_UNUSED; | 1335 typedef int64_t (*Int64Return)() DART_UNUSED; |
1502 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1336 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1503 } | 1337 } |
1504 | 1338 |
1505 | |
1506 ASSEMBLER_TEST_GENERATE(Lsrv, assembler) { | 1339 ASSEMBLER_TEST_GENERATE(Lsrv, assembler) { |
1507 __ movz(R1, Immediate(84), 0); | 1340 __ movz(R1, Immediate(84), 0); |
1508 __ movz(R2, Immediate(1), 0); | 1341 __ movz(R2, Immediate(1), 0); |
1509 __ lsrv(R0, R1, R2); | 1342 __ lsrv(R0, R1, R2); |
1510 __ ret(); | 1343 __ ret(); |
1511 } | 1344 } |
1512 | 1345 |
1513 | |
1514 ASSEMBLER_TEST_RUN(Lsrv, test) { | 1346 ASSEMBLER_TEST_RUN(Lsrv, test) { |
1515 typedef int64_t (*Int64Return)() DART_UNUSED; | 1347 typedef int64_t (*Int64Return)() DART_UNUSED; |
1516 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1348 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1517 } | 1349 } |
1518 | 1350 |
1519 | |
1520 ASSEMBLER_TEST_GENERATE(LShiftingV, assembler) { | 1351 ASSEMBLER_TEST_GENERATE(LShiftingV, assembler) { |
1521 __ movz(R1, Immediate(1), 0); | 1352 __ movz(R1, Immediate(1), 0); |
1522 __ movz(R2, Immediate(63), 0); | 1353 __ movz(R2, Immediate(63), 0); |
1523 __ lslv(R1, R1, R2); | 1354 __ lslv(R1, R1, R2); |
1524 __ lsrv(R0, R1, R2); | 1355 __ lsrv(R0, R1, R2); |
1525 __ ret(); | 1356 __ ret(); |
1526 } | 1357 } |
1527 | 1358 |
1528 | |
1529 ASSEMBLER_TEST_RUN(LShiftingV, test) { | 1359 ASSEMBLER_TEST_RUN(LShiftingV, test) { |
1530 typedef int64_t (*Int64Return)() DART_UNUSED; | 1360 typedef int64_t (*Int64Return)() DART_UNUSED; |
1531 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1361 EXPECT_EQ(1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1532 } | 1362 } |
1533 | 1363 |
1534 | |
1535 ASSEMBLER_TEST_GENERATE(RShiftingV, assembler) { | 1364 ASSEMBLER_TEST_GENERATE(RShiftingV, assembler) { |
1536 __ movz(R1, Immediate(1), 0); | 1365 __ movz(R1, Immediate(1), 0); |
1537 __ movz(R2, Immediate(63), 0); | 1366 __ movz(R2, Immediate(63), 0); |
1538 __ lslv(R1, R1, R2); | 1367 __ lslv(R1, R1, R2); |
1539 __ asrv(R0, R1, R2); | 1368 __ asrv(R0, R1, R2); |
1540 __ ret(); | 1369 __ ret(); |
1541 } | 1370 } |
1542 | 1371 |
1543 | |
1544 ASSEMBLER_TEST_RUN(RShiftingV, test) { | 1372 ASSEMBLER_TEST_RUN(RShiftingV, test) { |
1545 typedef int64_t (*Int64Return)() DART_UNUSED; | 1373 typedef int64_t (*Int64Return)() DART_UNUSED; |
1546 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1374 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1547 } | 1375 } |
1548 | 1376 |
1549 | |
1550 ASSEMBLER_TEST_GENERATE(Mult_pos, assembler) { | 1377 ASSEMBLER_TEST_GENERATE(Mult_pos, assembler) { |
1551 __ movz(R1, Immediate(6), 0); | 1378 __ movz(R1, Immediate(6), 0); |
1552 __ movz(R2, Immediate(7), 0); | 1379 __ movz(R2, Immediate(7), 0); |
1553 __ mul(R0, R1, R2); | 1380 __ mul(R0, R1, R2); |
1554 __ ret(); | 1381 __ ret(); |
1555 } | 1382 } |
1556 | 1383 |
1557 | |
1558 ASSEMBLER_TEST_RUN(Mult_pos, test) { | 1384 ASSEMBLER_TEST_RUN(Mult_pos, test) { |
1559 typedef int64_t (*Int64Return)() DART_UNUSED; | 1385 typedef int64_t (*Int64Return)() DART_UNUSED; |
1560 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1386 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1561 } | 1387 } |
1562 | 1388 |
1563 | |
1564 ASSEMBLER_TEST_GENERATE(Mult_neg, assembler) { | 1389 ASSEMBLER_TEST_GENERATE(Mult_neg, assembler) { |
1565 __ movz(R1, Immediate(6), 0); | 1390 __ movz(R1, Immediate(6), 0); |
1566 __ movz(R2, Immediate(7), 0); | 1391 __ movz(R2, Immediate(7), 0); |
1567 __ neg(R2, R2); | 1392 __ neg(R2, R2); |
1568 __ mul(R0, R1, R2); | 1393 __ mul(R0, R1, R2); |
1569 __ ret(); | 1394 __ ret(); |
1570 } | 1395 } |
1571 | 1396 |
1572 | |
1573 ASSEMBLER_TEST_RUN(Mult_neg, test) { | 1397 ASSEMBLER_TEST_RUN(Mult_neg, test) { |
1574 typedef int64_t (*Int64Return)() DART_UNUSED; | 1398 typedef int64_t (*Int64Return)() DART_UNUSED; |
1575 EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1399 EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1576 } | 1400 } |
1577 | 1401 |
1578 | |
1579 ASSEMBLER_TEST_GENERATE(Smulh_pos, assembler) { | 1402 ASSEMBLER_TEST_GENERATE(Smulh_pos, assembler) { |
1580 __ movz(R1, Immediate(6), 0); | 1403 __ movz(R1, Immediate(6), 0); |
1581 __ movz(R2, Immediate(7), 0); | 1404 __ movz(R2, Immediate(7), 0); |
1582 __ smulh(R0, R1, R2); | 1405 __ smulh(R0, R1, R2); |
1583 __ ret(); | 1406 __ ret(); |
1584 } | 1407 } |
1585 | 1408 |
1586 | |
1587 ASSEMBLER_TEST_RUN(Smulh_pos, test) { | 1409 ASSEMBLER_TEST_RUN(Smulh_pos, test) { |
1588 typedef int64_t (*Int64Return)() DART_UNUSED; | 1410 typedef int64_t (*Int64Return)() DART_UNUSED; |
1589 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1411 EXPECT_EQ(0, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1590 } | 1412 } |
1591 | 1413 |
1592 | |
1593 ASSEMBLER_TEST_GENERATE(Smulh_neg, assembler) { | 1414 ASSEMBLER_TEST_GENERATE(Smulh_neg, assembler) { |
1594 __ movz(R1, Immediate(6), 0); | 1415 __ movz(R1, Immediate(6), 0); |
1595 __ movz(R2, Immediate(7), 0); | 1416 __ movz(R2, Immediate(7), 0); |
1596 __ neg(R2, R2); | 1417 __ neg(R2, R2); |
1597 __ smulh(R0, R1, R2); | 1418 __ smulh(R0, R1, R2); |
1598 __ ret(); | 1419 __ ret(); |
1599 } | 1420 } |
1600 | 1421 |
1601 | |
1602 ASSEMBLER_TEST_RUN(Smulh_neg, test) { | 1422 ASSEMBLER_TEST_RUN(Smulh_neg, test) { |
1603 typedef int64_t (*Int64Return)() DART_UNUSED; | 1423 typedef int64_t (*Int64Return)() DART_UNUSED; |
1604 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1424 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1605 } | 1425 } |
1606 | 1426 |
1607 | |
1608 ASSEMBLER_TEST_GENERATE(Umulh, assembler) { | 1427 ASSEMBLER_TEST_GENERATE(Umulh, assembler) { |
1609 __ movz(R1, Immediate(-1), 3); // 0xffff000000000000 | 1428 __ movz(R1, Immediate(-1), 3); // 0xffff000000000000 |
1610 __ movz(R2, Immediate(7), 3); // 0x0007000000000000 | 1429 __ movz(R2, Immediate(7), 3); // 0x0007000000000000 |
1611 __ umulh(R0, R1, R2); // 0x0006fff900000000 | 1430 __ umulh(R0, R1, R2); // 0x0006fff900000000 |
1612 __ ret(); | 1431 __ ret(); |
1613 } | 1432 } |
1614 | 1433 |
1615 | |
1616 ASSEMBLER_TEST_RUN(Umulh, test) { | 1434 ASSEMBLER_TEST_RUN(Umulh, test) { |
1617 typedef int64_t (*Int64Return)() DART_UNUSED; | 1435 typedef int64_t (*Int64Return)() DART_UNUSED; |
1618 EXPECT_EQ(static_cast<int64_t>(0x6fff900000000), | 1436 EXPECT_EQ(static_cast<int64_t>(0x6fff900000000), |
1619 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1437 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1620 } | 1438 } |
1621 | 1439 |
1622 | |
1623 ASSEMBLER_TEST_GENERATE(Umaddl, assembler) { | 1440 ASSEMBLER_TEST_GENERATE(Umaddl, assembler) { |
1624 __ movn(R1, Immediate(0), 0); // W1 = 0xffffffff. | 1441 __ movn(R1, Immediate(0), 0); // W1 = 0xffffffff. |
1625 __ movz(R2, Immediate(7), 0); // W2 = 7. | 1442 __ movz(R2, Immediate(7), 0); // W2 = 7. |
1626 __ movz(R3, Immediate(8), 0); // X3 = 8. | 1443 __ movz(R3, Immediate(8), 0); // X3 = 8. |
1627 __ umaddl(R0, R1, R2, R3); // X0 = W1*W2 + X3 = 0x700000001. | 1444 __ umaddl(R0, R1, R2, R3); // X0 = W1*W2 + X3 = 0x700000001. |
1628 __ ret(); | 1445 __ ret(); |
1629 } | 1446 } |
1630 | 1447 |
1631 | |
1632 ASSEMBLER_TEST_RUN(Umaddl, test) { | 1448 ASSEMBLER_TEST_RUN(Umaddl, test) { |
1633 typedef int64_t (*Int64Return)() DART_UNUSED; | 1449 typedef int64_t (*Int64Return)() DART_UNUSED; |
1634 EXPECT_EQ(0x700000001, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1450 EXPECT_EQ(0x700000001, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1635 } | 1451 } |
1636 | 1452 |
1637 | |
1638 // Loading immediate values without the object pool. | 1453 // Loading immediate values without the object pool. |
1639 ASSEMBLER_TEST_GENERATE(LoadImmediateSmall, assembler) { | 1454 ASSEMBLER_TEST_GENERATE(LoadImmediateSmall, assembler) { |
1640 __ LoadImmediate(R0, 42); | 1455 __ LoadImmediate(R0, 42); |
1641 __ ret(); | 1456 __ ret(); |
1642 } | 1457 } |
1643 | 1458 |
1644 | |
1645 ASSEMBLER_TEST_RUN(LoadImmediateSmall, test) { | 1459 ASSEMBLER_TEST_RUN(LoadImmediateSmall, test) { |
1646 typedef int64_t (*Int64Return)() DART_UNUSED; | 1460 typedef int64_t (*Int64Return)() DART_UNUSED; |
1647 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1461 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1648 } | 1462 } |
1649 | 1463 |
1650 | |
1651 ASSEMBLER_TEST_GENERATE(LoadImmediateMed, assembler) { | 1464 ASSEMBLER_TEST_GENERATE(LoadImmediateMed, assembler) { |
1652 __ LoadImmediate(R0, 0xf1234123); | 1465 __ LoadImmediate(R0, 0xf1234123); |
1653 __ ret(); | 1466 __ ret(); |
1654 } | 1467 } |
1655 | 1468 |
1656 | |
1657 ASSEMBLER_TEST_RUN(LoadImmediateMed, test) { | 1469 ASSEMBLER_TEST_RUN(LoadImmediateMed, test) { |
1658 typedef int64_t (*Int64Return)() DART_UNUSED; | 1470 typedef int64_t (*Int64Return)() DART_UNUSED; |
1659 EXPECT_EQ(0xf1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1471 EXPECT_EQ(0xf1234123, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1660 } | 1472 } |
1661 | 1473 |
1662 | |
1663 ASSEMBLER_TEST_GENERATE(LoadImmediateMed2, assembler) { | 1474 ASSEMBLER_TEST_GENERATE(LoadImmediateMed2, assembler) { |
1664 __ LoadImmediate(R0, 0x4321f1234123); | 1475 __ LoadImmediate(R0, 0x4321f1234123); |
1665 __ ret(); | 1476 __ ret(); |
1666 } | 1477 } |
1667 | 1478 |
1668 | |
1669 ASSEMBLER_TEST_RUN(LoadImmediateMed2, test) { | 1479 ASSEMBLER_TEST_RUN(LoadImmediateMed2, test) { |
1670 typedef int64_t (*Int64Return)() DART_UNUSED; | 1480 typedef int64_t (*Int64Return)() DART_UNUSED; |
1671 EXPECT_EQ(0x4321f1234123, | 1481 EXPECT_EQ(0x4321f1234123, |
1672 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1482 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1673 } | 1483 } |
1674 | 1484 |
1675 | |
1676 ASSEMBLER_TEST_GENERATE(LoadImmediateLarge, assembler) { | 1485 ASSEMBLER_TEST_GENERATE(LoadImmediateLarge, assembler) { |
1677 __ LoadImmediate(R0, 0x9287436598237465); | 1486 __ LoadImmediate(R0, 0x9287436598237465); |
1678 __ ret(); | 1487 __ ret(); |
1679 } | 1488 } |
1680 | 1489 |
1681 | |
1682 ASSEMBLER_TEST_RUN(LoadImmediateLarge, test) { | 1490 ASSEMBLER_TEST_RUN(LoadImmediateLarge, test) { |
1683 typedef int64_t (*Int64Return)() DART_UNUSED; | 1491 typedef int64_t (*Int64Return)() DART_UNUSED; |
1684 EXPECT_EQ(static_cast<int64_t>(0x9287436598237465), | 1492 EXPECT_EQ(static_cast<int64_t>(0x9287436598237465), |
1685 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1493 EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1686 } | 1494 } |
1687 | 1495 |
1688 | |
1689 ASSEMBLER_TEST_GENERATE(LoadImmediateSmallNeg, assembler) { | 1496 ASSEMBLER_TEST_GENERATE(LoadImmediateSmallNeg, assembler) { |
1690 __ LoadImmediate(R0, -42); | 1497 __ LoadImmediate(R0, -42); |
1691 __ ret(); | 1498 __ ret(); |
1692 } | 1499 } |
1693 | 1500 |
1694 | |
1695 ASSEMBLER_TEST_RUN(LoadImmediateSmallNeg, test) { | 1501 ASSEMBLER_TEST_RUN(LoadImmediateSmallNeg, test) { |
1696 typedef int64_t (*Int64Return)() DART_UNUSED; | 1502 typedef int64_t (*Int64Return)() DART_UNUSED; |
1697 EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1503 EXPECT_EQ(-42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1698 } | 1504 } |
1699 | 1505 |
1700 | |
1701 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg, assembler) { | 1506 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg, assembler) { |
1702 __ LoadImmediate(R0, -0x1212341234); | 1507 __ LoadImmediate(R0, -0x1212341234); |
1703 __ ret(); | 1508 __ ret(); |
1704 } | 1509 } |
1705 | 1510 |
1706 | |
1707 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg, test) { | 1511 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg, test) { |
1708 typedef int64_t (*Int64Return)() DART_UNUSED; | 1512 typedef int64_t (*Int64Return)() DART_UNUSED; |
1709 EXPECT_EQ(-0x1212341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1513 EXPECT_EQ(-0x1212341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1710 } | 1514 } |
1711 | 1515 |
1712 | |
1713 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg2, assembler) { | 1516 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg2, assembler) { |
1714 __ LoadImmediate(R0, -0x1212340000); | 1517 __ LoadImmediate(R0, -0x1212340000); |
1715 __ ret(); | 1518 __ ret(); |
1716 } | 1519 } |
1717 | 1520 |
1718 | |
1719 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg2, test) { | 1521 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg2, test) { |
1720 typedef int64_t (*Int64Return)() DART_UNUSED; | 1522 typedef int64_t (*Int64Return)() DART_UNUSED; |
1721 EXPECT_EQ(-0x1212340000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1523 EXPECT_EQ(-0x1212340000, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1722 } | 1524 } |
1723 | 1525 |
1724 | |
1725 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg3, assembler) { | 1526 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg3, assembler) { |
1726 __ LoadImmediate(R0, -0x1200001234); | 1527 __ LoadImmediate(R0, -0x1200001234); |
1727 __ ret(); | 1528 __ ret(); |
1728 } | 1529 } |
1729 | 1530 |
1730 | |
1731 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg3, test) { | 1531 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg3, test) { |
1732 typedef int64_t (*Int64Return)() DART_UNUSED; | 1532 typedef int64_t (*Int64Return)() DART_UNUSED; |
1733 EXPECT_EQ(-0x1200001234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1533 EXPECT_EQ(-0x1200001234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1734 } | 1534 } |
1735 | 1535 |
1736 | |
1737 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg4, assembler) { | 1536 ASSEMBLER_TEST_GENERATE(LoadImmediateMedNeg4, assembler) { |
1738 __ LoadImmediate(R0, -0x12341234); | 1537 __ LoadImmediate(R0, -0x12341234); |
1739 __ ret(); | 1538 __ ret(); |
1740 } | 1539 } |
1741 | 1540 |
1742 | |
1743 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg4, test) { | 1541 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg4, test) { |
1744 typedef int64_t (*Int64Return)() DART_UNUSED; | 1542 typedef int64_t (*Int64Return)() DART_UNUSED; |
1745 EXPECT_EQ(-0x12341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1543 EXPECT_EQ(-0x12341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
1746 } | 1544 } |
1747 | 1545 |
1748 | |
1749 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) { | 1546 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) { |
1750 __ LoadUnaligned(R1, R0, TMP, kHalfword); | 1547 __ LoadUnaligned(R1, R0, TMP, kHalfword); |
1751 __ mov(R0, R1); | 1548 __ mov(R0, R1); |
1752 __ ret(); | 1549 __ ret(); |
1753 } | 1550 } |
1754 | 1551 |
1755 | |
1756 ASSEMBLER_TEST_RUN(LoadHalfWordUnaligned, test) { | 1552 ASSEMBLER_TEST_RUN(LoadHalfWordUnaligned, test) { |
1757 EXPECT(test != NULL); | 1553 EXPECT(test != NULL); |
1758 typedef intptr_t (*LoadHalfWordUnaligned)(intptr_t) DART_UNUSED; | 1554 typedef intptr_t (*LoadHalfWordUnaligned)(intptr_t) DART_UNUSED; |
1759 uint8_t buffer[4] = { | 1555 uint8_t buffer[4] = { |
1760 0x89, 0xAB, 0xCD, 0xEF, | 1556 0x89, 0xAB, 0xCD, 0xEF, |
1761 }; | 1557 }; |
1762 | 1558 |
1763 EXPECT_EQ( | 1559 EXPECT_EQ( |
1764 static_cast<int16_t>(static_cast<uint16_t>(0xAB89)), | 1560 static_cast<int16_t>(static_cast<uint16_t>(0xAB89)), |
1765 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), | 1561 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), |
1766 reinterpret_cast<intptr_t>(&buffer[0]))); | 1562 reinterpret_cast<intptr_t>(&buffer[0]))); |
1767 EXPECT_EQ( | 1563 EXPECT_EQ( |
1768 static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)), | 1564 static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)), |
1769 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), | 1565 EXECUTE_TEST_CODE_INTPTR_INTPTR(LoadHalfWordUnaligned, test->entry(), |
1770 reinterpret_cast<intptr_t>(&buffer[1]))); | 1566 reinterpret_cast<intptr_t>(&buffer[1]))); |
1771 } | 1567 } |
1772 | 1568 |
1773 | |
1774 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) { | 1569 ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) { |
1775 __ LoadUnaligned(R1, R0, TMP, kUnsignedHalfword); | 1570 __ LoadUnaligned(R1, R0, TMP, kUnsignedHalfword); |
1776 __ mov(R0, R1); | 1571 __ mov(R0, R1); |
1777 __ ret(); | 1572 __ ret(); |
1778 } | 1573 } |
1779 | 1574 |
1780 | |
1781 ASSEMBLER_TEST_RUN(LoadHalfWordUnsignedUnaligned, test) { | 1575 ASSEMBLER_TEST_RUN(LoadHalfWordUnsignedUnaligned, test) { |
1782 EXPECT(test != NULL); | 1576 EXPECT(test != NULL); |
1783 typedef intptr_t (*LoadHalfWordUnsignedUnaligned)(intptr_t) DART_UNUSED; | 1577 typedef intptr_t (*LoadHalfWordUnsignedUnaligned)(intptr_t) DART_UNUSED; |
1784 uint8_t buffer[4] = { | 1578 uint8_t buffer[4] = { |
1785 0x89, 0xAB, 0xCD, 0xEF, | 1579 0x89, 0xAB, 0xCD, 0xEF, |
1786 }; | 1580 }; |
1787 | 1581 |
1788 EXPECT_EQ(0xAB89, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1582 EXPECT_EQ(0xAB89, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1789 LoadHalfWordUnsignedUnaligned, test->entry(), | 1583 LoadHalfWordUnsignedUnaligned, test->entry(), |
1790 reinterpret_cast<intptr_t>(&buffer[0]))); | 1584 reinterpret_cast<intptr_t>(&buffer[0]))); |
1791 EXPECT_EQ(0xCDAB, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1585 EXPECT_EQ(0xCDAB, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1792 LoadHalfWordUnsignedUnaligned, test->entry(), | 1586 LoadHalfWordUnsignedUnaligned, test->entry(), |
1793 reinterpret_cast<intptr_t>(&buffer[1]))); | 1587 reinterpret_cast<intptr_t>(&buffer[1]))); |
1794 } | 1588 } |
1795 | 1589 |
1796 | |
1797 ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) { | 1590 ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) { |
1798 __ LoadImmediate(R1, 0xABCD); | 1591 __ LoadImmediate(R1, 0xABCD); |
1799 __ StoreUnaligned(R1, R0, TMP, kHalfword); | 1592 __ StoreUnaligned(R1, R0, TMP, kHalfword); |
1800 __ mov(R0, R1); | 1593 __ mov(R0, R1); |
1801 __ ret(); | 1594 __ ret(); |
1802 } | 1595 } |
1803 | 1596 |
1804 | |
1805 ASSEMBLER_TEST_RUN(StoreHalfWordUnaligned, test) { | 1597 ASSEMBLER_TEST_RUN(StoreHalfWordUnaligned, test) { |
1806 EXPECT(test != NULL); | 1598 EXPECT(test != NULL); |
1807 typedef intptr_t (*StoreHalfWordUnaligned)(intptr_t) DART_UNUSED; | 1599 typedef intptr_t (*StoreHalfWordUnaligned)(intptr_t) DART_UNUSED; |
1808 uint8_t buffer[4] = { | 1600 uint8_t buffer[4] = { |
1809 0, 0, 0, 0, | 1601 0, 0, 0, 0, |
1810 }; | 1602 }; |
1811 | 1603 |
1812 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1604 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1813 StoreHalfWordUnaligned, test->entry(), | 1605 StoreHalfWordUnaligned, test->entry(), |
1814 reinterpret_cast<intptr_t>(&buffer[0]))); | 1606 reinterpret_cast<intptr_t>(&buffer[0]))); |
1815 EXPECT_EQ(0xCD, buffer[0]); | 1607 EXPECT_EQ(0xCD, buffer[0]); |
1816 EXPECT_EQ(0xAB, buffer[1]); | 1608 EXPECT_EQ(0xAB, buffer[1]); |
1817 EXPECT_EQ(0, buffer[2]); | 1609 EXPECT_EQ(0, buffer[2]); |
1818 | 1610 |
1819 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1611 EXPECT_EQ(0xABCD, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1820 StoreHalfWordUnaligned, test->entry(), | 1612 StoreHalfWordUnaligned, test->entry(), |
1821 reinterpret_cast<intptr_t>(&buffer[1]))); | 1613 reinterpret_cast<intptr_t>(&buffer[1]))); |
1822 EXPECT_EQ(0xCD, buffer[1]); | 1614 EXPECT_EQ(0xCD, buffer[1]); |
1823 EXPECT_EQ(0xAB, buffer[2]); | 1615 EXPECT_EQ(0xAB, buffer[2]); |
1824 EXPECT_EQ(0, buffer[3]); | 1616 EXPECT_EQ(0, buffer[3]); |
1825 } | 1617 } |
1826 | 1618 |
1827 | |
1828 ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) { | 1619 ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) { |
1829 __ LoadUnaligned(R1, R0, TMP, kUnsignedWord); | 1620 __ LoadUnaligned(R1, R0, TMP, kUnsignedWord); |
1830 __ mov(R0, R1); | 1621 __ mov(R0, R1); |
1831 __ ret(); | 1622 __ ret(); |
1832 } | 1623 } |
1833 | 1624 |
1834 | |
1835 ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) { | 1625 ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) { |
1836 EXPECT(test != NULL); | 1626 EXPECT(test != NULL); |
1837 typedef int32_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED; | 1627 typedef int32_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED; |
1838 uint8_t buffer[8] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; | 1628 uint8_t buffer[8] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0}; |
1839 | 1629 |
1840 EXPECT_EQ( | 1630 EXPECT_EQ( |
1841 static_cast<int32_t>(0x78563412), | 1631 static_cast<int32_t>(0x78563412), |
1842 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), | 1632 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), |
1843 reinterpret_cast<intptr_t>(&buffer[0]))); | 1633 reinterpret_cast<intptr_t>(&buffer[0]))); |
1844 EXPECT_EQ( | 1634 EXPECT_EQ( |
1845 static_cast<int32_t>(0x9A785634), | 1635 static_cast<int32_t>(0x9A785634), |
1846 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), | 1636 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), |
1847 reinterpret_cast<intptr_t>(&buffer[1]))); | 1637 reinterpret_cast<intptr_t>(&buffer[1]))); |
1848 EXPECT_EQ( | 1638 EXPECT_EQ( |
1849 static_cast<int32_t>(0xBC9A7856), | 1639 static_cast<int32_t>(0xBC9A7856), |
1850 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), | 1640 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), |
1851 reinterpret_cast<intptr_t>(&buffer[2]))); | 1641 reinterpret_cast<intptr_t>(&buffer[2]))); |
1852 EXPECT_EQ( | 1642 EXPECT_EQ( |
1853 static_cast<int32_t>(0xDEBC9A78), | 1643 static_cast<int32_t>(0xDEBC9A78), |
1854 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), | 1644 EXECUTE_TEST_CODE_INT32_INTPTR(LoadWordUnaligned, test->entry(), |
1855 reinterpret_cast<intptr_t>(&buffer[3]))); | 1645 reinterpret_cast<intptr_t>(&buffer[3]))); |
1856 } | 1646 } |
1857 | 1647 |
1858 | |
1859 ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) { | 1648 ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) { |
1860 __ LoadImmediate(R1, 0x12345678); | 1649 __ LoadImmediate(R1, 0x12345678); |
1861 __ StoreUnaligned(R1, R0, TMP, kUnsignedWord); | 1650 __ StoreUnaligned(R1, R0, TMP, kUnsignedWord); |
1862 __ mov(R0, R1); | 1651 __ mov(R0, R1); |
1863 __ ret(); | 1652 __ ret(); |
1864 } | 1653 } |
1865 | 1654 |
1866 | |
1867 ASSEMBLER_TEST_RUN(StoreWordUnaligned, test) { | 1655 ASSEMBLER_TEST_RUN(StoreWordUnaligned, test) { |
1868 EXPECT(test != NULL); | 1656 EXPECT(test != NULL); |
1869 typedef intptr_t (*StoreWordUnaligned)(intptr_t) DART_UNUSED; | 1657 typedef intptr_t (*StoreWordUnaligned)(intptr_t) DART_UNUSED; |
1870 uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0}; | 1658 uint8_t buffer[8] = {0, 0, 0, 0, 0, 0, 0, 0}; |
1871 | 1659 |
1872 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1660 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1873 StoreWordUnaligned, test->entry(), | 1661 StoreWordUnaligned, test->entry(), |
1874 reinterpret_cast<intptr_t>(&buffer[0]))); | 1662 reinterpret_cast<intptr_t>(&buffer[0]))); |
1875 EXPECT_EQ(0x78, buffer[0]); | 1663 EXPECT_EQ(0x78, buffer[0]); |
1876 EXPECT_EQ(0x56, buffer[1]); | 1664 EXPECT_EQ(0x56, buffer[1]); |
(...skipping 18 matching lines...) Expand all Loading... |
1895 | 1683 |
1896 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( | 1684 EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INTPTR_INTPTR( |
1897 StoreWordUnaligned, test->entry(), | 1685 StoreWordUnaligned, test->entry(), |
1898 reinterpret_cast<intptr_t>(&buffer[3]))); | 1686 reinterpret_cast<intptr_t>(&buffer[3]))); |
1899 EXPECT_EQ(0x78, buffer[3]); | 1687 EXPECT_EQ(0x78, buffer[3]); |
1900 EXPECT_EQ(0x56, buffer[4]); | 1688 EXPECT_EQ(0x56, buffer[4]); |
1901 EXPECT_EQ(0x34, buffer[5]); | 1689 EXPECT_EQ(0x34, buffer[5]); |
1902 EXPECT_EQ(0x12, buffer[6]); | 1690 EXPECT_EQ(0x12, buffer[6]); |
1903 } | 1691 } |
1904 | 1692 |
1905 | |
1906 static void EnterTestFrame(Assembler* assembler) { | 1693 static void EnterTestFrame(Assembler* assembler) { |
1907 __ EnterFrame(0); | 1694 __ EnterFrame(0); |
1908 __ Push(CODE_REG); | 1695 __ Push(CODE_REG); |
1909 __ Push(THR); | 1696 __ Push(THR); |
1910 __ TagAndPushPP(); | 1697 __ TagAndPushPP(); |
1911 __ ldr(CODE_REG, Address(R0, VMHandles::kOffsetOfRawPtrInHandle)); | 1698 __ ldr(CODE_REG, Address(R0, VMHandles::kOffsetOfRawPtrInHandle)); |
1912 __ mov(THR, R1); | 1699 __ mov(THR, R1); |
1913 __ LoadPoolPointer(PP); | 1700 __ LoadPoolPointer(PP); |
1914 } | 1701 } |
1915 | 1702 |
1916 | |
1917 static void LeaveTestFrame(Assembler* assembler) { | 1703 static void LeaveTestFrame(Assembler* assembler) { |
1918 __ PopAndUntagPP(); | 1704 __ PopAndUntagPP(); |
1919 __ Pop(THR); | 1705 __ Pop(THR); |
1920 __ Pop(CODE_REG); | 1706 __ Pop(CODE_REG); |
1921 __ LeaveFrame(); | 1707 __ LeaveFrame(); |
1922 } | 1708 } |
1923 | 1709 |
1924 | |
1925 // Loading immediate values with the object pool. | 1710 // Loading immediate values with the object pool. |
1926 ASSEMBLER_TEST_GENERATE(LoadImmediatePPSmall, assembler) { | 1711 ASSEMBLER_TEST_GENERATE(LoadImmediatePPSmall, assembler) { |
1927 __ SetupDartSP(); | 1712 __ SetupDartSP(); |
1928 EnterTestFrame(assembler); | 1713 EnterTestFrame(assembler); |
1929 __ LoadImmediate(R0, 42); | 1714 __ LoadImmediate(R0, 42); |
1930 LeaveTestFrame(assembler); | 1715 LeaveTestFrame(assembler); |
1931 __ RestoreCSP(); | 1716 __ RestoreCSP(); |
1932 __ ret(); | 1717 __ ret(); |
1933 } | 1718 } |
1934 | 1719 |
1935 | |
1936 ASSEMBLER_TEST_RUN(LoadImmediatePPSmall, test) { | 1720 ASSEMBLER_TEST_RUN(LoadImmediatePPSmall, test) { |
1937 EXPECT_EQ(42, test->InvokeWithCodeAndThread<int64_t>()); | 1721 EXPECT_EQ(42, test->InvokeWithCodeAndThread<int64_t>()); |
1938 } | 1722 } |
1939 | 1723 |
1940 | |
1941 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed, assembler) { | 1724 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed, assembler) { |
1942 __ SetupDartSP(); | 1725 __ SetupDartSP(); |
1943 EnterTestFrame(assembler); | 1726 EnterTestFrame(assembler); |
1944 __ LoadImmediate(R0, 0xf1234123); | 1727 __ LoadImmediate(R0, 0xf1234123); |
1945 LeaveTestFrame(assembler); | 1728 LeaveTestFrame(assembler); |
1946 __ RestoreCSP(); | 1729 __ RestoreCSP(); |
1947 __ ret(); | 1730 __ ret(); |
1948 } | 1731 } |
1949 | 1732 |
1950 | |
1951 ASSEMBLER_TEST_RUN(LoadImmediatePPMed, test) { | 1733 ASSEMBLER_TEST_RUN(LoadImmediatePPMed, test) { |
1952 EXPECT_EQ(0xf1234123, test->InvokeWithCodeAndThread<int64_t>()); | 1734 EXPECT_EQ(0xf1234123, test->InvokeWithCodeAndThread<int64_t>()); |
1953 } | 1735 } |
1954 | 1736 |
1955 | |
1956 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed2, assembler) { | 1737 ASSEMBLER_TEST_GENERATE(LoadImmediatePPMed2, assembler) { |
1957 __ SetupDartSP(); | 1738 __ SetupDartSP(); |
1958 EnterTestFrame(assembler); | 1739 EnterTestFrame(assembler); |
1959 __ LoadImmediate(R0, 0x4321f1234124); | 1740 __ LoadImmediate(R0, 0x4321f1234124); |
1960 LeaveTestFrame(assembler); | 1741 LeaveTestFrame(assembler); |
1961 __ RestoreCSP(); | 1742 __ RestoreCSP(); |
1962 __ ret(); | 1743 __ ret(); |
1963 } | 1744 } |
1964 | 1745 |
1965 | |
1966 ASSEMBLER_TEST_RUN(LoadImmediatePPMed2, test) { | 1746 ASSEMBLER_TEST_RUN(LoadImmediatePPMed2, test) { |
1967 EXPECT_EQ(0x4321f1234124, test->InvokeWithCodeAndThread<int64_t>()); | 1747 EXPECT_EQ(0x4321f1234124, test->InvokeWithCodeAndThread<int64_t>()); |
1968 } | 1748 } |
1969 | 1749 |
1970 | |
1971 ASSEMBLER_TEST_GENERATE(LoadImmediatePPLarge, assembler) { | 1750 ASSEMBLER_TEST_GENERATE(LoadImmediatePPLarge, assembler) { |
1972 __ SetupDartSP(); | 1751 __ SetupDartSP(); |
1973 EnterTestFrame(assembler); | 1752 EnterTestFrame(assembler); |
1974 __ LoadImmediate(R0, 0x9287436598237465); | 1753 __ LoadImmediate(R0, 0x9287436598237465); |
1975 LeaveTestFrame(assembler); | 1754 LeaveTestFrame(assembler); |
1976 __ RestoreCSP(); | 1755 __ RestoreCSP(); |
1977 __ ret(); | 1756 __ ret(); |
1978 } | 1757 } |
1979 | 1758 |
1980 | |
1981 ASSEMBLER_TEST_RUN(LoadImmediatePPLarge, test) { | 1759 ASSEMBLER_TEST_RUN(LoadImmediatePPLarge, test) { |
1982 EXPECT_EQ(static_cast<int64_t>(0x9287436598237465), | 1760 EXPECT_EQ(static_cast<int64_t>(0x9287436598237465), |
1983 test->InvokeWithCodeAndThread<int64_t>()); | 1761 test->InvokeWithCodeAndThread<int64_t>()); |
1984 } | 1762 } |
1985 | 1763 |
1986 | |
1987 // LoadObject null. | 1764 // LoadObject null. |
1988 ASSEMBLER_TEST_GENERATE(LoadObjectNull, assembler) { | 1765 ASSEMBLER_TEST_GENERATE(LoadObjectNull, assembler) { |
1989 __ SetupDartSP(); | 1766 __ SetupDartSP(); |
1990 EnterTestFrame(assembler); | 1767 EnterTestFrame(assembler); |
1991 __ LoadObject(R0, Object::null_object()); | 1768 __ LoadObject(R0, Object::null_object()); |
1992 LeaveTestFrame(assembler); | 1769 LeaveTestFrame(assembler); |
1993 __ RestoreCSP(); | 1770 __ RestoreCSP(); |
1994 __ ret(); | 1771 __ ret(); |
1995 } | 1772 } |
1996 | 1773 |
1997 | |
1998 ASSEMBLER_TEST_RUN(LoadObjectNull, test) { | 1774 ASSEMBLER_TEST_RUN(LoadObjectNull, test) { |
1999 EXPECT_EQ(Object::null(), test->InvokeWithCodeAndThread<RawObject*>()); | 1775 EXPECT_EQ(Object::null(), test->InvokeWithCodeAndThread<RawObject*>()); |
2000 } | 1776 } |
2001 | 1777 |
2002 | |
2003 ASSEMBLER_TEST_GENERATE(LoadObjectTrue, assembler) { | 1778 ASSEMBLER_TEST_GENERATE(LoadObjectTrue, assembler) { |
2004 __ SetupDartSP(); | 1779 __ SetupDartSP(); |
2005 EnterTestFrame(assembler); | 1780 EnterTestFrame(assembler); |
2006 __ LoadObject(R0, Bool::True()); | 1781 __ LoadObject(R0, Bool::True()); |
2007 LeaveTestFrame(assembler); | 1782 LeaveTestFrame(assembler); |
2008 __ RestoreCSP(); | 1783 __ RestoreCSP(); |
2009 __ ret(); | 1784 __ ret(); |
2010 } | 1785 } |
2011 | 1786 |
2012 | |
2013 ASSEMBLER_TEST_RUN(LoadObjectTrue, test) { | 1787 ASSEMBLER_TEST_RUN(LoadObjectTrue, test) { |
2014 EXPECT_EQ(Bool::True().raw(), test->InvokeWithCodeAndThread<RawObject*>()); | 1788 EXPECT_EQ(Bool::True().raw(), test->InvokeWithCodeAndThread<RawObject*>()); |
2015 } | 1789 } |
2016 | 1790 |
2017 | |
2018 ASSEMBLER_TEST_GENERATE(LoadObjectFalse, assembler) { | 1791 ASSEMBLER_TEST_GENERATE(LoadObjectFalse, assembler) { |
2019 __ SetupDartSP(); | 1792 __ SetupDartSP(); |
2020 EnterTestFrame(assembler); | 1793 EnterTestFrame(assembler); |
2021 __ LoadObject(R0, Bool::False()); | 1794 __ LoadObject(R0, Bool::False()); |
2022 LeaveTestFrame(assembler); | 1795 LeaveTestFrame(assembler); |
2023 __ RestoreCSP(); | 1796 __ RestoreCSP(); |
2024 __ ret(); | 1797 __ ret(); |
2025 } | 1798 } |
2026 | 1799 |
2027 | |
2028 ASSEMBLER_TEST_RUN(LoadObjectFalse, test) { | 1800 ASSEMBLER_TEST_RUN(LoadObjectFalse, test) { |
2029 EXPECT_EQ(Bool::False().raw(), test->InvokeWithCodeAndThread<RawObject*>()); | 1801 EXPECT_EQ(Bool::False().raw(), test->InvokeWithCodeAndThread<RawObject*>()); |
2030 } | 1802 } |
2031 | 1803 |
2032 | |
2033 ASSEMBLER_TEST_GENERATE(CSelTrue, assembler) { | 1804 ASSEMBLER_TEST_GENERATE(CSelTrue, assembler) { |
2034 __ LoadImmediate(R1, 42); | 1805 __ LoadImmediate(R1, 42); |
2035 __ LoadImmediate(R2, 1234); | 1806 __ LoadImmediate(R2, 1234); |
2036 __ CompareRegisters(R1, R2); | 1807 __ CompareRegisters(R1, R2); |
2037 __ csel(R0, R1, R2, LT); | 1808 __ csel(R0, R1, R2, LT); |
2038 __ ret(); | 1809 __ ret(); |
2039 } | 1810 } |
2040 | 1811 |
2041 | |
2042 ASSEMBLER_TEST_RUN(CSelTrue, test) { | 1812 ASSEMBLER_TEST_RUN(CSelTrue, test) { |
2043 typedef int64_t (*Int64Return)() DART_UNUSED; | 1813 typedef int64_t (*Int64Return)() DART_UNUSED; |
2044 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1814 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2045 } | 1815 } |
2046 | 1816 |
2047 | |
2048 ASSEMBLER_TEST_GENERATE(CSelFalse, assembler) { | 1817 ASSEMBLER_TEST_GENERATE(CSelFalse, assembler) { |
2049 __ LoadImmediate(R1, 42); | 1818 __ LoadImmediate(R1, 42); |
2050 __ LoadImmediate(R2, 1234); | 1819 __ LoadImmediate(R2, 1234); |
2051 __ CompareRegisters(R1, R2); | 1820 __ CompareRegisters(R1, R2); |
2052 __ csel(R0, R1, R2, GE); | 1821 __ csel(R0, R1, R2, GE); |
2053 __ ret(); | 1822 __ ret(); |
2054 } | 1823 } |
2055 | 1824 |
2056 | |
2057 ASSEMBLER_TEST_RUN(CSelFalse, test) { | 1825 ASSEMBLER_TEST_RUN(CSelFalse, test) { |
2058 typedef int64_t (*Int64Return)() DART_UNUSED; | 1826 typedef int64_t (*Int64Return)() DART_UNUSED; |
2059 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1827 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2060 } | 1828 } |
2061 | 1829 |
2062 | |
2063 ASSEMBLER_TEST_GENERATE(CsincFalse, assembler) { | 1830 ASSEMBLER_TEST_GENERATE(CsincFalse, assembler) { |
2064 __ LoadImmediate(R1, 42); | 1831 __ LoadImmediate(R1, 42); |
2065 __ LoadImmediate(R2, 1234); | 1832 __ LoadImmediate(R2, 1234); |
2066 __ CompareRegisters(R1, R2); | 1833 __ CompareRegisters(R1, R2); |
2067 __ csinc(R0, R2, R1, GE); | 1834 __ csinc(R0, R2, R1, GE); |
2068 __ ret(); | 1835 __ ret(); |
2069 } | 1836 } |
2070 | 1837 |
2071 | |
2072 ASSEMBLER_TEST_RUN(CsincFalse, test) { | 1838 ASSEMBLER_TEST_RUN(CsincFalse, test) { |
2073 typedef int64_t (*Int64Return)() DART_UNUSED; | 1839 typedef int64_t (*Int64Return)() DART_UNUSED; |
2074 EXPECT_EQ(43, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1840 EXPECT_EQ(43, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2075 } | 1841 } |
2076 | 1842 |
2077 | |
2078 ASSEMBLER_TEST_GENERATE(CsincTrue, assembler) { | 1843 ASSEMBLER_TEST_GENERATE(CsincTrue, assembler) { |
2079 __ LoadImmediate(R1, 42); | 1844 __ LoadImmediate(R1, 42); |
2080 __ LoadImmediate(R2, 1234); | 1845 __ LoadImmediate(R2, 1234); |
2081 __ CompareRegisters(R1, R2); | 1846 __ CompareRegisters(R1, R2); |
2082 __ csinc(R0, R2, R1, LT); | 1847 __ csinc(R0, R2, R1, LT); |
2083 __ ret(); | 1848 __ ret(); |
2084 } | 1849 } |
2085 | 1850 |
2086 | |
2087 ASSEMBLER_TEST_RUN(CsincTrue, test) { | 1851 ASSEMBLER_TEST_RUN(CsincTrue, test) { |
2088 typedef int64_t (*Int64Return)() DART_UNUSED; | 1852 typedef int64_t (*Int64Return)() DART_UNUSED; |
2089 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1853 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2090 } | 1854 } |
2091 | 1855 |
2092 | |
2093 ASSEMBLER_TEST_GENERATE(CsinvFalse, assembler) { | 1856 ASSEMBLER_TEST_GENERATE(CsinvFalse, assembler) { |
2094 __ LoadImmediate(R1, 42); | 1857 __ LoadImmediate(R1, 42); |
2095 __ LoadImmediate(R2, 1234); | 1858 __ LoadImmediate(R2, 1234); |
2096 __ CompareRegisters(R1, R2); | 1859 __ CompareRegisters(R1, R2); |
2097 __ csinv(R0, R2, R1, GE); | 1860 __ csinv(R0, R2, R1, GE); |
2098 __ ret(); | 1861 __ ret(); |
2099 } | 1862 } |
2100 | 1863 |
2101 | |
2102 ASSEMBLER_TEST_RUN(CsinvFalse, test) { | 1864 ASSEMBLER_TEST_RUN(CsinvFalse, test) { |
2103 typedef int64_t (*Int64Return)() DART_UNUSED; | 1865 typedef int64_t (*Int64Return)() DART_UNUSED; |
2104 EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1866 EXPECT_EQ(~42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2105 } | 1867 } |
2106 | 1868 |
2107 | |
2108 ASSEMBLER_TEST_GENERATE(CsinvTrue, assembler) { | 1869 ASSEMBLER_TEST_GENERATE(CsinvTrue, assembler) { |
2109 __ LoadImmediate(R1, 42); | 1870 __ LoadImmediate(R1, 42); |
2110 __ LoadImmediate(R2, 1234); | 1871 __ LoadImmediate(R2, 1234); |
2111 __ CompareRegisters(R1, R2); | 1872 __ CompareRegisters(R1, R2); |
2112 __ csinv(R0, R2, R1, LT); | 1873 __ csinv(R0, R2, R1, LT); |
2113 __ ret(); | 1874 __ ret(); |
2114 } | 1875 } |
2115 | 1876 |
2116 | |
2117 ASSEMBLER_TEST_RUN(CsinvTrue, test) { | 1877 ASSEMBLER_TEST_RUN(CsinvTrue, test) { |
2118 typedef int64_t (*Int64Return)() DART_UNUSED; | 1878 typedef int64_t (*Int64Return)() DART_UNUSED; |
2119 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1879 EXPECT_EQ(1234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2120 } | 1880 } |
2121 | 1881 |
2122 | |
2123 // Floating point move immediate, to/from integer register. | 1882 // Floating point move immediate, to/from integer register. |
2124 ASSEMBLER_TEST_GENERATE(Fmovdi, assembler) { | 1883 ASSEMBLER_TEST_GENERATE(Fmovdi, assembler) { |
2125 __ LoadDImmediate(V0, 1.0); | 1884 __ LoadDImmediate(V0, 1.0); |
2126 __ ret(); | 1885 __ ret(); |
2127 } | 1886 } |
2128 | 1887 |
2129 | |
2130 ASSEMBLER_TEST_RUN(Fmovdi, test) { | 1888 ASSEMBLER_TEST_RUN(Fmovdi, test) { |
2131 typedef double (*DoubleReturn)() DART_UNUSED; | 1889 typedef double (*DoubleReturn)() DART_UNUSED; |
2132 EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1890 EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2133 } | 1891 } |
2134 | 1892 |
2135 | |
2136 ASSEMBLER_TEST_GENERATE(Fmovdi2, assembler) { | 1893 ASSEMBLER_TEST_GENERATE(Fmovdi2, assembler) { |
2137 __ LoadDImmediate(V0, 123412983.1324524315); | 1894 __ LoadDImmediate(V0, 123412983.1324524315); |
2138 __ ret(); | 1895 __ ret(); |
2139 } | 1896 } |
2140 | 1897 |
2141 | |
2142 ASSEMBLER_TEST_RUN(Fmovdi2, test) { | 1898 ASSEMBLER_TEST_RUN(Fmovdi2, test) { |
2143 typedef double (*DoubleReturn)() DART_UNUSED; | 1899 typedef double (*DoubleReturn)() DART_UNUSED; |
2144 EXPECT_FLOAT_EQ(123412983.1324524315, | 1900 EXPECT_FLOAT_EQ(123412983.1324524315, |
2145 EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()), | 1901 EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()), |
2146 0.0001f); | 1902 0.0001f); |
2147 } | 1903 } |
2148 | 1904 |
2149 | |
2150 ASSEMBLER_TEST_GENERATE(Fmovrd, assembler) { | 1905 ASSEMBLER_TEST_GENERATE(Fmovrd, assembler) { |
2151 __ LoadDImmediate(V1, 1.0); | 1906 __ LoadDImmediate(V1, 1.0); |
2152 __ fmovrd(R0, V1); | 1907 __ fmovrd(R0, V1); |
2153 __ ret(); | 1908 __ ret(); |
2154 } | 1909 } |
2155 | 1910 |
2156 | |
2157 ASSEMBLER_TEST_RUN(Fmovrd, test) { | 1911 ASSEMBLER_TEST_RUN(Fmovrd, test) { |
2158 typedef int64_t (*Int64Return)() DART_UNUSED; | 1912 typedef int64_t (*Int64Return)() DART_UNUSED; |
2159 const int64_t one = bit_cast<int64_t, double>(1.0); | 1913 const int64_t one = bit_cast<int64_t, double>(1.0); |
2160 EXPECT_EQ(one, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 1914 EXPECT_EQ(one, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2161 } | 1915 } |
2162 | 1916 |
2163 | |
2164 ASSEMBLER_TEST_GENERATE(Fmovdr, assembler) { | 1917 ASSEMBLER_TEST_GENERATE(Fmovdr, assembler) { |
2165 __ LoadDImmediate(V1, 1.0); | 1918 __ LoadDImmediate(V1, 1.0); |
2166 __ fmovrd(R1, V1); | 1919 __ fmovrd(R1, V1); |
2167 __ fmovdr(V0, R1); | 1920 __ fmovdr(V0, R1); |
2168 __ ret(); | 1921 __ ret(); |
2169 } | 1922 } |
2170 | 1923 |
2171 | |
2172 ASSEMBLER_TEST_RUN(Fmovdr, test) { | 1924 ASSEMBLER_TEST_RUN(Fmovdr, test) { |
2173 typedef double (*DoubleReturn)() DART_UNUSED; | 1925 typedef double (*DoubleReturn)() DART_UNUSED; |
2174 EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1926 EXPECT_EQ(1.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2175 } | 1927 } |
2176 | 1928 |
2177 | |
2178 ASSEMBLER_TEST_GENERATE(Fmovrs, assembler) { | 1929 ASSEMBLER_TEST_GENERATE(Fmovrs, assembler) { |
2179 __ LoadDImmediate(V2, 1.0); | 1930 __ LoadDImmediate(V2, 1.0); |
2180 __ fcvtsd(V1, V2); | 1931 __ fcvtsd(V1, V2); |
2181 __ fmovrs(R0, V1); | 1932 __ fmovrs(R0, V1); |
2182 __ ret(); | 1933 __ ret(); |
2183 } | 1934 } |
2184 | 1935 |
2185 | |
2186 ASSEMBLER_TEST_RUN(Fmovrs, test) { | 1936 ASSEMBLER_TEST_RUN(Fmovrs, test) { |
2187 typedef int64_t (*Int64Return)() DART_UNUSED; | 1937 typedef int64_t (*Int64Return)() DART_UNUSED; |
2188 int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()); | 1938 int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()); |
2189 const uint32_t one = bit_cast<uint32_t, float>(1.0f); | 1939 const uint32_t one = bit_cast<uint32_t, float>(1.0f); |
2190 EXPECT_EQ(one, static_cast<uint32_t>(result)); | 1940 EXPECT_EQ(one, static_cast<uint32_t>(result)); |
2191 } | 1941 } |
2192 | 1942 |
2193 | |
2194 ASSEMBLER_TEST_GENERATE(Fmovsr, assembler) { | 1943 ASSEMBLER_TEST_GENERATE(Fmovsr, assembler) { |
2195 __ LoadImmediate(R2, bit_cast<uint32_t, float>(1.0f)); | 1944 __ LoadImmediate(R2, bit_cast<uint32_t, float>(1.0f)); |
2196 __ fmovsr(V1, R2); | 1945 __ fmovsr(V1, R2); |
2197 __ fmovrs(R0, V1); | 1946 __ fmovrs(R0, V1); |
2198 __ ret(); | 1947 __ ret(); |
2199 } | 1948 } |
2200 | 1949 |
2201 | |
2202 ASSEMBLER_TEST_RUN(Fmovsr, test) { | 1950 ASSEMBLER_TEST_RUN(Fmovsr, test) { |
2203 typedef int64_t (*Int64Return)() DART_UNUSED; | 1951 typedef int64_t (*Int64Return)() DART_UNUSED; |
2204 int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()); | 1952 int64_t result = EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()); |
2205 const uint32_t one = bit_cast<uint32_t, float>(1.0f); | 1953 const uint32_t one = bit_cast<uint32_t, float>(1.0f); |
2206 EXPECT_EQ(one, static_cast<uint32_t>(result)); | 1954 EXPECT_EQ(one, static_cast<uint32_t>(result)); |
2207 } | 1955 } |
2208 | 1956 |
2209 | |
2210 ASSEMBLER_TEST_GENERATE(FldrdFstrdPrePostIndex, assembler) { | 1957 ASSEMBLER_TEST_GENERATE(FldrdFstrdPrePostIndex, assembler) { |
2211 __ SetupDartSP(); | 1958 __ SetupDartSP(); |
2212 __ LoadDImmediate(V1, 42.0); | 1959 __ LoadDImmediate(V1, 42.0); |
2213 __ fstrd(V1, Address(SP, -1 * kWordSize, Address::PreIndex)); | 1960 __ fstrd(V1, Address(SP, -1 * kWordSize, Address::PreIndex)); |
2214 __ fldrd(V0, Address(SP, 1 * kWordSize, Address::PostIndex)); | 1961 __ fldrd(V0, Address(SP, 1 * kWordSize, Address::PostIndex)); |
2215 __ RestoreCSP(); | 1962 __ RestoreCSP(); |
2216 __ ret(); | 1963 __ ret(); |
2217 } | 1964 } |
2218 | 1965 |
2219 | |
2220 ASSEMBLER_TEST_RUN(FldrdFstrdPrePostIndex, test) { | 1966 ASSEMBLER_TEST_RUN(FldrdFstrdPrePostIndex, test) { |
2221 typedef double (*DoubleReturn)() DART_UNUSED; | 1967 typedef double (*DoubleReturn)() DART_UNUSED; |
2222 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1968 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2223 } | 1969 } |
2224 | 1970 |
2225 | |
2226 ASSEMBLER_TEST_GENERATE(FldrsFstrsPrePostIndex, assembler) { | 1971 ASSEMBLER_TEST_GENERATE(FldrsFstrsPrePostIndex, assembler) { |
2227 __ SetupDartSP(); | 1972 __ SetupDartSP(); |
2228 __ LoadDImmediate(V1, 42.0); | 1973 __ LoadDImmediate(V1, 42.0); |
2229 __ fcvtsd(V2, V1); | 1974 __ fcvtsd(V2, V1); |
2230 __ fstrs(V2, Address(SP, -1 * kWordSize, Address::PreIndex)); | 1975 __ fstrs(V2, Address(SP, -1 * kWordSize, Address::PreIndex)); |
2231 __ fldrs(V3, Address(SP, 1 * kWordSize, Address::PostIndex)); | 1976 __ fldrs(V3, Address(SP, 1 * kWordSize, Address::PostIndex)); |
2232 __ fcvtds(V0, V3); | 1977 __ fcvtds(V0, V3); |
2233 __ RestoreCSP(); | 1978 __ RestoreCSP(); |
2234 __ ret(); | 1979 __ ret(); |
2235 } | 1980 } |
2236 | 1981 |
2237 | |
2238 ASSEMBLER_TEST_RUN(FldrsFstrsPrePostIndex, test) { | 1982 ASSEMBLER_TEST_RUN(FldrsFstrsPrePostIndex, test) { |
2239 typedef double (*DoubleReturn)() DART_UNUSED; | 1983 typedef double (*DoubleReturn)() DART_UNUSED; |
2240 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 1984 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2241 } | 1985 } |
2242 | 1986 |
2243 | |
2244 ASSEMBLER_TEST_GENERATE(FldrqFstrqPrePostIndex, assembler) { | 1987 ASSEMBLER_TEST_GENERATE(FldrqFstrqPrePostIndex, assembler) { |
2245 __ SetupDartSP(); | 1988 __ SetupDartSP(); |
2246 __ LoadDImmediate(V1, 21.0); | 1989 __ LoadDImmediate(V1, 21.0); |
2247 __ LoadDImmediate(V2, 21.0); | 1990 __ LoadDImmediate(V2, 21.0); |
2248 __ LoadImmediate(R1, 42); | 1991 __ LoadImmediate(R1, 42); |
2249 __ Push(R1); | 1992 __ Push(R1); |
2250 __ PushDouble(V1); | 1993 __ PushDouble(V1); |
2251 __ PushDouble(V2); | 1994 __ PushDouble(V2); |
2252 __ fldrq(V3, Address(SP, 2 * kWordSize, Address::PostIndex)); | 1995 __ fldrq(V3, Address(SP, 2 * kWordSize, Address::PostIndex)); |
2253 __ Pop(R0); | 1996 __ Pop(R0); |
2254 __ fstrq(V3, Address(SP, -2 * kWordSize, Address::PreIndex)); | 1997 __ fstrq(V3, Address(SP, -2 * kWordSize, Address::PreIndex)); |
2255 __ PopDouble(V0); | 1998 __ PopDouble(V0); |
2256 __ PopDouble(V1); | 1999 __ PopDouble(V1); |
2257 __ faddd(V0, V0, V1); | 2000 __ faddd(V0, V0, V1); |
2258 __ RestoreCSP(); | 2001 __ RestoreCSP(); |
2259 __ ret(); | 2002 __ ret(); |
2260 } | 2003 } |
2261 | 2004 |
2262 | |
2263 ASSEMBLER_TEST_RUN(FldrqFstrqPrePostIndex, test) { | 2005 ASSEMBLER_TEST_RUN(FldrqFstrqPrePostIndex, test) { |
2264 typedef double (*DoubleReturn)() DART_UNUSED; | 2006 typedef double (*DoubleReturn)() DART_UNUSED; |
2265 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2007 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2266 } | 2008 } |
2267 | 2009 |
2268 | |
2269 ASSEMBLER_TEST_GENERATE(Fcvtzds, assembler) { | 2010 ASSEMBLER_TEST_GENERATE(Fcvtzds, assembler) { |
2270 __ LoadDImmediate(V0, 42.0); | 2011 __ LoadDImmediate(V0, 42.0); |
2271 __ fcvtzds(R0, V0); | 2012 __ fcvtzds(R0, V0); |
2272 __ ret(); | 2013 __ ret(); |
2273 } | 2014 } |
2274 | 2015 |
2275 | |
2276 ASSEMBLER_TEST_RUN(Fcvtzds, test) { | 2016 ASSEMBLER_TEST_RUN(Fcvtzds, test) { |
2277 typedef int64_t (*Int64Return)() DART_UNUSED; | 2017 typedef int64_t (*Int64Return)() DART_UNUSED; |
2278 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2018 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2279 } | 2019 } |
2280 | 2020 |
2281 | |
2282 ASSEMBLER_TEST_GENERATE(Scvtfdx, assembler) { | 2021 ASSEMBLER_TEST_GENERATE(Scvtfdx, assembler) { |
2283 __ LoadImmediate(R0, 42); | 2022 __ LoadImmediate(R0, 42); |
2284 __ scvtfdx(V0, R0); | 2023 __ scvtfdx(V0, R0); |
2285 __ ret(); | 2024 __ ret(); |
2286 } | 2025 } |
2287 | 2026 |
2288 | |
2289 ASSEMBLER_TEST_RUN(Scvtfdx, test) { | 2027 ASSEMBLER_TEST_RUN(Scvtfdx, test) { |
2290 typedef double (*DoubleReturn)() DART_UNUSED; | 2028 typedef double (*DoubleReturn)() DART_UNUSED; |
2291 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2029 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2292 } | 2030 } |
2293 | 2031 |
2294 | |
2295 ASSEMBLER_TEST_GENERATE(Scvtfdw, assembler) { | 2032 ASSEMBLER_TEST_GENERATE(Scvtfdw, assembler) { |
2296 // Fill upper 32-bits with garbage. | 2033 // Fill upper 32-bits with garbage. |
2297 __ LoadImmediate(R0, 0x111111110000002A); | 2034 __ LoadImmediate(R0, 0x111111110000002A); |
2298 __ scvtfdw(V0, R0); | 2035 __ scvtfdw(V0, R0); |
2299 __ ret(); | 2036 __ ret(); |
2300 } | 2037 } |
2301 | 2038 |
2302 | |
2303 ASSEMBLER_TEST_RUN(Scvtfdw, test) { | 2039 ASSEMBLER_TEST_RUN(Scvtfdw, test) { |
2304 typedef double (*DoubleReturn)() DART_UNUSED; | 2040 typedef double (*DoubleReturn)() DART_UNUSED; |
2305 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2041 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2306 } | 2042 } |
2307 | 2043 |
2308 | |
2309 ASSEMBLER_TEST_GENERATE(FabsdPos, assembler) { | 2044 ASSEMBLER_TEST_GENERATE(FabsdPos, assembler) { |
2310 __ LoadDImmediate(V1, 42.0); | 2045 __ LoadDImmediate(V1, 42.0); |
2311 __ fabsd(V0, V1); | 2046 __ fabsd(V0, V1); |
2312 __ ret(); | 2047 __ ret(); |
2313 } | 2048 } |
2314 | 2049 |
2315 | |
2316 ASSEMBLER_TEST_RUN(FabsdPos, test) { | 2050 ASSEMBLER_TEST_RUN(FabsdPos, test) { |
2317 typedef double (*DoubleReturn)() DART_UNUSED; | 2051 typedef double (*DoubleReturn)() DART_UNUSED; |
2318 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2052 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2319 } | 2053 } |
2320 | 2054 |
2321 | |
2322 ASSEMBLER_TEST_GENERATE(FabsdNeg, assembler) { | 2055 ASSEMBLER_TEST_GENERATE(FabsdNeg, assembler) { |
2323 __ LoadDImmediate(V1, -42.0); | 2056 __ LoadDImmediate(V1, -42.0); |
2324 __ fabsd(V0, V1); | 2057 __ fabsd(V0, V1); |
2325 __ ret(); | 2058 __ ret(); |
2326 } | 2059 } |
2327 | 2060 |
2328 | |
2329 ASSEMBLER_TEST_RUN(FabsdNeg, test) { | 2061 ASSEMBLER_TEST_RUN(FabsdNeg, test) { |
2330 typedef double (*DoubleReturn)() DART_UNUSED; | 2062 typedef double (*DoubleReturn)() DART_UNUSED; |
2331 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2063 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2332 } | 2064 } |
2333 | 2065 |
2334 | |
2335 ASSEMBLER_TEST_GENERATE(FnegdPos, assembler) { | 2066 ASSEMBLER_TEST_GENERATE(FnegdPos, assembler) { |
2336 __ LoadDImmediate(V1, 42.0); | 2067 __ LoadDImmediate(V1, 42.0); |
2337 __ fnegd(V0, V1); | 2068 __ fnegd(V0, V1); |
2338 __ ret(); | 2069 __ ret(); |
2339 } | 2070 } |
2340 | 2071 |
2341 | |
2342 ASSEMBLER_TEST_RUN(FnegdPos, test) { | 2072 ASSEMBLER_TEST_RUN(FnegdPos, test) { |
2343 typedef double (*DoubleReturn)() DART_UNUSED; | 2073 typedef double (*DoubleReturn)() DART_UNUSED; |
2344 EXPECT_EQ(-42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2074 EXPECT_EQ(-42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2345 } | 2075 } |
2346 | 2076 |
2347 | |
2348 ASSEMBLER_TEST_GENERATE(FnegdNeg, assembler) { | 2077 ASSEMBLER_TEST_GENERATE(FnegdNeg, assembler) { |
2349 __ LoadDImmediate(V1, -42.0); | 2078 __ LoadDImmediate(V1, -42.0); |
2350 __ fnegd(V0, V1); | 2079 __ fnegd(V0, V1); |
2351 __ ret(); | 2080 __ ret(); |
2352 } | 2081 } |
2353 | 2082 |
2354 | |
2355 ASSEMBLER_TEST_RUN(FnegdNeg, test) { | 2083 ASSEMBLER_TEST_RUN(FnegdNeg, test) { |
2356 typedef double (*DoubleReturn)() DART_UNUSED; | 2084 typedef double (*DoubleReturn)() DART_UNUSED; |
2357 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2085 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2358 } | 2086 } |
2359 | 2087 |
2360 | |
2361 ASSEMBLER_TEST_GENERATE(Fsqrtd, assembler) { | 2088 ASSEMBLER_TEST_GENERATE(Fsqrtd, assembler) { |
2362 __ LoadDImmediate(V1, 64.0); | 2089 __ LoadDImmediate(V1, 64.0); |
2363 __ fsqrtd(V0, V1); | 2090 __ fsqrtd(V0, V1); |
2364 __ ret(); | 2091 __ ret(); |
2365 } | 2092 } |
2366 | 2093 |
2367 | |
2368 ASSEMBLER_TEST_RUN(Fsqrtd, test) { | 2094 ASSEMBLER_TEST_RUN(Fsqrtd, test) { |
2369 typedef double (*DoubleReturn)() DART_UNUSED; | 2095 typedef double (*DoubleReturn)() DART_UNUSED; |
2370 EXPECT_EQ(8.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2096 EXPECT_EQ(8.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2371 } | 2097 } |
2372 | 2098 |
2373 | |
2374 ASSEMBLER_TEST_GENERATE(Fmuld, assembler) { | 2099 ASSEMBLER_TEST_GENERATE(Fmuld, assembler) { |
2375 __ LoadDImmediate(V1, 84.0); | 2100 __ LoadDImmediate(V1, 84.0); |
2376 __ LoadDImmediate(V2, 0.5); | 2101 __ LoadDImmediate(V2, 0.5); |
2377 __ fmuld(V0, V1, V2); | 2102 __ fmuld(V0, V1, V2); |
2378 __ ret(); | 2103 __ ret(); |
2379 } | 2104 } |
2380 | 2105 |
2381 | |
2382 ASSEMBLER_TEST_RUN(Fmuld, test) { | 2106 ASSEMBLER_TEST_RUN(Fmuld, test) { |
2383 typedef double (*DoubleReturn)() DART_UNUSED; | 2107 typedef double (*DoubleReturn)() DART_UNUSED; |
2384 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2108 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2385 } | 2109 } |
2386 | 2110 |
2387 | |
2388 ASSEMBLER_TEST_GENERATE(Fdivd, assembler) { | 2111 ASSEMBLER_TEST_GENERATE(Fdivd, assembler) { |
2389 __ LoadDImmediate(V1, 84.0); | 2112 __ LoadDImmediate(V1, 84.0); |
2390 __ LoadDImmediate(V2, 2.0); | 2113 __ LoadDImmediate(V2, 2.0); |
2391 __ fdivd(V0, V1, V2); | 2114 __ fdivd(V0, V1, V2); |
2392 __ ret(); | 2115 __ ret(); |
2393 } | 2116 } |
2394 | 2117 |
2395 | |
2396 ASSEMBLER_TEST_RUN(Fdivd, test) { | 2118 ASSEMBLER_TEST_RUN(Fdivd, test) { |
2397 typedef double (*DoubleReturn)() DART_UNUSED; | 2119 typedef double (*DoubleReturn)() DART_UNUSED; |
2398 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2120 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2399 } | 2121 } |
2400 | 2122 |
2401 | |
2402 ASSEMBLER_TEST_GENERATE(Faddd, assembler) { | 2123 ASSEMBLER_TEST_GENERATE(Faddd, assembler) { |
2403 __ LoadDImmediate(V1, 41.5); | 2124 __ LoadDImmediate(V1, 41.5); |
2404 __ LoadDImmediate(V2, 0.5); | 2125 __ LoadDImmediate(V2, 0.5); |
2405 __ faddd(V0, V1, V2); | 2126 __ faddd(V0, V1, V2); |
2406 __ ret(); | 2127 __ ret(); |
2407 } | 2128 } |
2408 | 2129 |
2409 | |
2410 ASSEMBLER_TEST_RUN(Faddd, test) { | 2130 ASSEMBLER_TEST_RUN(Faddd, test) { |
2411 typedef double (*DoubleReturn)() DART_UNUSED; | 2131 typedef double (*DoubleReturn)() DART_UNUSED; |
2412 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2132 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2413 } | 2133 } |
2414 | 2134 |
2415 | |
2416 ASSEMBLER_TEST_GENERATE(Fsubd, assembler) { | 2135 ASSEMBLER_TEST_GENERATE(Fsubd, assembler) { |
2417 __ LoadDImmediate(V1, 42.5); | 2136 __ LoadDImmediate(V1, 42.5); |
2418 __ LoadDImmediate(V2, 0.5); | 2137 __ LoadDImmediate(V2, 0.5); |
2419 __ fsubd(V0, V1, V2); | 2138 __ fsubd(V0, V1, V2); |
2420 __ ret(); | 2139 __ ret(); |
2421 } | 2140 } |
2422 | 2141 |
2423 | |
2424 ASSEMBLER_TEST_RUN(Fsubd, test) { | 2142 ASSEMBLER_TEST_RUN(Fsubd, test) { |
2425 typedef double (*DoubleReturn)() DART_UNUSED; | 2143 typedef double (*DoubleReturn)() DART_UNUSED; |
2426 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2144 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2427 } | 2145 } |
2428 | 2146 |
2429 | |
2430 ASSEMBLER_TEST_GENERATE(FldrdFstrdHeapTag, assembler) { | 2147 ASSEMBLER_TEST_GENERATE(FldrdFstrdHeapTag, assembler) { |
2431 __ SetupDartSP(); | 2148 __ SetupDartSP(); |
2432 __ LoadDImmediate(V0, 43.0); | 2149 __ LoadDImmediate(V0, 43.0); |
2433 __ LoadDImmediate(V1, 42.0); | 2150 __ LoadDImmediate(V1, 42.0); |
2434 __ AddImmediate(SP, SP, -1 * kWordSize); | 2151 __ AddImmediate(SP, SP, -1 * kWordSize); |
2435 __ add(R2, SP, Operand(1)); | 2152 __ add(R2, SP, Operand(1)); |
2436 __ fstrd(V1, Address(R2, -1)); | 2153 __ fstrd(V1, Address(R2, -1)); |
2437 __ fldrd(V0, Address(R2, -1)); | 2154 __ fldrd(V0, Address(R2, -1)); |
2438 __ AddImmediate(SP, 1 * kWordSize); | 2155 __ AddImmediate(SP, 1 * kWordSize); |
2439 __ RestoreCSP(); | 2156 __ RestoreCSP(); |
2440 __ ret(); | 2157 __ ret(); |
2441 } | 2158 } |
2442 | 2159 |
2443 | |
2444 ASSEMBLER_TEST_RUN(FldrdFstrdHeapTag, test) { | 2160 ASSEMBLER_TEST_RUN(FldrdFstrdHeapTag, test) { |
2445 typedef double (*DoubleReturn)() DART_UNUSED; | 2161 typedef double (*DoubleReturn)() DART_UNUSED; |
2446 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2162 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2447 } | 2163 } |
2448 | 2164 |
2449 | |
2450 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeIndex, assembler) { | 2165 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeIndex, assembler) { |
2451 __ SetupDartSP(); | 2166 __ SetupDartSP(); |
2452 __ LoadDImmediate(V0, 43.0); | 2167 __ LoadDImmediate(V0, 43.0); |
2453 __ LoadDImmediate(V1, 42.0); | 2168 __ LoadDImmediate(V1, 42.0); |
2454 // Largest negative offset that can fit in the signed 9-bit immediate field. | 2169 // Largest negative offset that can fit in the signed 9-bit immediate field. |
2455 __ fstrd(V1, Address(SP, -32 * kWordSize, Address::PreIndex)); | 2170 __ fstrd(V1, Address(SP, -32 * kWordSize, Address::PreIndex)); |
2456 // Largest positive kWordSize aligned offset that we can fit. | 2171 // Largest positive kWordSize aligned offset that we can fit. |
2457 __ fldrd(V0, Address(SP, 31 * kWordSize, Address::PostIndex)); | 2172 __ fldrd(V0, Address(SP, 31 * kWordSize, Address::PostIndex)); |
2458 // Correction. | 2173 // Correction. |
2459 __ add(SP, SP, Operand(kWordSize)); // Restore SP. | 2174 __ add(SP, SP, Operand(kWordSize)); // Restore SP. |
2460 __ RestoreCSP(); | 2175 __ RestoreCSP(); |
2461 __ ret(); | 2176 __ ret(); |
2462 } | 2177 } |
2463 | 2178 |
2464 | |
2465 ASSEMBLER_TEST_RUN(FldrdFstrdLargeIndex, test) { | 2179 ASSEMBLER_TEST_RUN(FldrdFstrdLargeIndex, test) { |
2466 typedef double (*DoubleReturn)() DART_UNUSED; | 2180 typedef double (*DoubleReturn)() DART_UNUSED; |
2467 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2181 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2468 } | 2182 } |
2469 | 2183 |
2470 | |
2471 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeOffset, assembler) { | 2184 ASSEMBLER_TEST_GENERATE(FldrdFstrdLargeOffset, assembler) { |
2472 __ SetupDartSP(); | 2185 __ SetupDartSP(); |
2473 __ LoadDImmediate(V0, 43.0); | 2186 __ LoadDImmediate(V0, 43.0); |
2474 __ LoadDImmediate(V1, 42.0); | 2187 __ LoadDImmediate(V1, 42.0); |
2475 __ sub(SP, SP, Operand(512 * kWordSize)); | 2188 __ sub(SP, SP, Operand(512 * kWordSize)); |
2476 __ fstrd(V1, Address(SP, 512 * kWordSize, Address::Offset)); | 2189 __ fstrd(V1, Address(SP, 512 * kWordSize, Address::Offset)); |
2477 __ add(SP, SP, Operand(512 * kWordSize)); | 2190 __ add(SP, SP, Operand(512 * kWordSize)); |
2478 __ fldrd(V0, Address(SP)); | 2191 __ fldrd(V0, Address(SP)); |
2479 __ RestoreCSP(); | 2192 __ RestoreCSP(); |
2480 __ ret(); | 2193 __ ret(); |
2481 } | 2194 } |
2482 | 2195 |
2483 | |
2484 ASSEMBLER_TEST_RUN(FldrdFstrdLargeOffset, test) { | 2196 ASSEMBLER_TEST_RUN(FldrdFstrdLargeOffset, test) { |
2485 typedef double (*DoubleReturn)() DART_UNUSED; | 2197 typedef double (*DoubleReturn)() DART_UNUSED; |
2486 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2198 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2487 } | 2199 } |
2488 | 2200 |
2489 | |
2490 ASSEMBLER_TEST_GENERATE(FldrdFstrdExtReg, assembler) { | 2201 ASSEMBLER_TEST_GENERATE(FldrdFstrdExtReg, assembler) { |
2491 __ SetupDartSP(); | 2202 __ SetupDartSP(); |
2492 __ LoadDImmediate(V0, 43.0); | 2203 __ LoadDImmediate(V0, 43.0); |
2493 __ LoadDImmediate(V1, 42.0); | 2204 __ LoadDImmediate(V1, 42.0); |
2494 __ movz(R2, Immediate(0xfff8), 0); | 2205 __ movz(R2, Immediate(0xfff8), 0); |
2495 __ movk(R2, Immediate(0xffff), 1); // R2 <- -8 (int32_t). | 2206 __ movk(R2, Immediate(0xffff), 1); // R2 <- -8 (int32_t). |
2496 // This should sign extend R2, and add to SP to get address, | 2207 // This should sign extend R2, and add to SP to get address, |
2497 // i.e. SP - kWordSize. | 2208 // i.e. SP - kWordSize. |
2498 __ fstrd(V1, Address(SP, R2, SXTW)); | 2209 __ fstrd(V1, Address(SP, R2, SXTW)); |
2499 __ sub(SP, SP, Operand(kWordSize)); | 2210 __ sub(SP, SP, Operand(kWordSize)); |
2500 __ fldrd(V0, Address(SP)); | 2211 __ fldrd(V0, Address(SP)); |
2501 __ add(SP, SP, Operand(kWordSize)); | 2212 __ add(SP, SP, Operand(kWordSize)); |
2502 __ RestoreCSP(); | 2213 __ RestoreCSP(); |
2503 __ ret(); | 2214 __ ret(); |
2504 } | 2215 } |
2505 | 2216 |
2506 | |
2507 ASSEMBLER_TEST_RUN(FldrdFstrdExtReg, test) { | 2217 ASSEMBLER_TEST_RUN(FldrdFstrdExtReg, test) { |
2508 typedef double (*DoubleReturn)() DART_UNUSED; | 2218 typedef double (*DoubleReturn)() DART_UNUSED; |
2509 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2219 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2510 } | 2220 } |
2511 | 2221 |
2512 | |
2513 ASSEMBLER_TEST_GENERATE(FldrdFstrdScaledReg, assembler) { | 2222 ASSEMBLER_TEST_GENERATE(FldrdFstrdScaledReg, assembler) { |
2514 __ SetupDartSP(); | 2223 __ SetupDartSP(); |
2515 __ LoadDImmediate(V0, 43.0); | 2224 __ LoadDImmediate(V0, 43.0); |
2516 __ LoadDImmediate(V1, 42.0); | 2225 __ LoadDImmediate(V1, 42.0); |
2517 __ movz(R2, Immediate(10), 0); | 2226 __ movz(R2, Immediate(10), 0); |
2518 __ sub(SP, SP, Operand(10 * kWordSize)); | 2227 __ sub(SP, SP, Operand(10 * kWordSize)); |
2519 // Store V1 into SP + R2 * kWordSize. | 2228 // Store V1 into SP + R2 * kWordSize. |
2520 __ fstrd(V1, Address(SP, R2, UXTX, Address::Scaled)); | 2229 __ fstrd(V1, Address(SP, R2, UXTX, Address::Scaled)); |
2521 __ fldrd(V0, Address(SP, R2, UXTX, Address::Scaled)); | 2230 __ fldrd(V0, Address(SP, R2, UXTX, Address::Scaled)); |
2522 __ add(SP, SP, Operand(10 * kWordSize)); | 2231 __ add(SP, SP, Operand(10 * kWordSize)); |
2523 __ RestoreCSP(); | 2232 __ RestoreCSP(); |
2524 __ ret(); | 2233 __ ret(); |
2525 } | 2234 } |
2526 | 2235 |
2527 | |
2528 ASSEMBLER_TEST_RUN(FldrdFstrdScaledReg, test) { | 2236 ASSEMBLER_TEST_RUN(FldrdFstrdScaledReg, test) { |
2529 typedef double (*DoubleReturn)() DART_UNUSED; | 2237 typedef double (*DoubleReturn)() DART_UNUSED; |
2530 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2238 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2531 } | 2239 } |
2532 | 2240 |
2533 | |
2534 ASSEMBLER_TEST_GENERATE(VinswVmovrs, assembler) { | 2241 ASSEMBLER_TEST_GENERATE(VinswVmovrs, assembler) { |
2535 __ LoadImmediate(R0, 42); | 2242 __ LoadImmediate(R0, 42); |
2536 __ LoadImmediate(R1, 43); | 2243 __ LoadImmediate(R1, 43); |
2537 __ LoadImmediate(R2, 44); | 2244 __ LoadImmediate(R2, 44); |
2538 __ LoadImmediate(R3, 45); | 2245 __ LoadImmediate(R3, 45); |
2539 | 2246 |
2540 __ vinsw(V0, 0, R0); | 2247 __ vinsw(V0, 0, R0); |
2541 __ vinsw(V0, 1, R1); | 2248 __ vinsw(V0, 1, R1); |
2542 __ vinsw(V0, 2, R2); | 2249 __ vinsw(V0, 2, R2); |
2543 __ vinsw(V0, 3, R3); | 2250 __ vinsw(V0, 3, R3); |
2544 | 2251 |
2545 __ vmovrs(R4, V0, 0); | 2252 __ vmovrs(R4, V0, 0); |
2546 __ vmovrs(R5, V0, 1); | 2253 __ vmovrs(R5, V0, 1); |
2547 __ vmovrs(R6, V0, 2); | 2254 __ vmovrs(R6, V0, 2); |
2548 __ vmovrs(R7, V0, 3); | 2255 __ vmovrs(R7, V0, 3); |
2549 | 2256 |
2550 __ add(R0, R4, Operand(R5)); | 2257 __ add(R0, R4, Operand(R5)); |
2551 __ add(R0, R0, Operand(R6)); | 2258 __ add(R0, R0, Operand(R6)); |
2552 __ add(R0, R0, Operand(R7)); | 2259 __ add(R0, R0, Operand(R7)); |
2553 __ ret(); | 2260 __ ret(); |
2554 } | 2261 } |
2555 | 2262 |
2556 | |
2557 ASSEMBLER_TEST_RUN(VinswVmovrs, test) { | 2263 ASSEMBLER_TEST_RUN(VinswVmovrs, test) { |
2558 EXPECT(test != NULL); | 2264 EXPECT(test != NULL); |
2559 typedef int64_t (*Int64Return)() DART_UNUSED; | 2265 typedef int64_t (*Int64Return)() DART_UNUSED; |
2560 EXPECT_EQ(174, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2266 EXPECT_EQ(174, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2561 } | 2267 } |
2562 | 2268 |
2563 | |
2564 ASSEMBLER_TEST_GENERATE(VinsxVmovrd, assembler) { | 2269 ASSEMBLER_TEST_GENERATE(VinsxVmovrd, assembler) { |
2565 __ LoadImmediate(R0, 42); | 2270 __ LoadImmediate(R0, 42); |
2566 __ LoadImmediate(R1, 43); | 2271 __ LoadImmediate(R1, 43); |
2567 | 2272 |
2568 __ vinsx(V0, 0, R0); | 2273 __ vinsx(V0, 0, R0); |
2569 __ vinsx(V0, 1, R1); | 2274 __ vinsx(V0, 1, R1); |
2570 | 2275 |
2571 __ vmovrd(R2, V0, 0); | 2276 __ vmovrd(R2, V0, 0); |
2572 __ vmovrd(R3, V0, 1); | 2277 __ vmovrd(R3, V0, 1); |
2573 | 2278 |
2574 __ add(R0, R2, Operand(R3)); | 2279 __ add(R0, R2, Operand(R3)); |
2575 __ ret(); | 2280 __ ret(); |
2576 } | 2281 } |
2577 | 2282 |
2578 | |
2579 ASSEMBLER_TEST_RUN(VinsxVmovrd, test) { | 2283 ASSEMBLER_TEST_RUN(VinsxVmovrd, test) { |
2580 EXPECT(test != NULL); | 2284 EXPECT(test != NULL); |
2581 typedef int64_t (*Int64Return)() DART_UNUSED; | 2285 typedef int64_t (*Int64Return)() DART_UNUSED; |
2582 EXPECT_EQ(85, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2286 EXPECT_EQ(85, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2583 } | 2287 } |
2584 | 2288 |
2585 | |
2586 ASSEMBLER_TEST_GENERATE(Vnot, assembler) { | 2289 ASSEMBLER_TEST_GENERATE(Vnot, assembler) { |
2587 __ LoadImmediate(R0, 0xfffffffe); | 2290 __ LoadImmediate(R0, 0xfffffffe); |
2588 __ LoadImmediate(R1, 0xffffffff); | 2291 __ LoadImmediate(R1, 0xffffffff); |
2589 __ vinsw(V1, 0, R1); | 2292 __ vinsw(V1, 0, R1); |
2590 __ vinsw(V1, 1, R0); | 2293 __ vinsw(V1, 1, R0); |
2591 __ vinsw(V1, 2, R1); | 2294 __ vinsw(V1, 2, R1); |
2592 __ vinsw(V1, 3, R0); | 2295 __ vinsw(V1, 3, R0); |
2593 | 2296 |
2594 __ vnot(V0, V1); | 2297 __ vnot(V0, V1); |
2595 | 2298 |
2596 __ vmovrs(R2, V0, 0); | 2299 __ vmovrs(R2, V0, 0); |
2597 __ vmovrs(R3, V0, 1); | 2300 __ vmovrs(R3, V0, 1); |
2598 __ vmovrs(R4, V0, 2); | 2301 __ vmovrs(R4, V0, 2); |
2599 __ vmovrs(R5, V0, 3); | 2302 __ vmovrs(R5, V0, 3); |
2600 __ add(R0, R2, Operand(R3)); | 2303 __ add(R0, R2, Operand(R3)); |
2601 __ add(R0, R0, Operand(R4)); | 2304 __ add(R0, R0, Operand(R4)); |
2602 __ add(R0, R0, Operand(R5)); | 2305 __ add(R0, R0, Operand(R5)); |
2603 __ ret(); | 2306 __ ret(); |
2604 } | 2307 } |
2605 | 2308 |
2606 | |
2607 ASSEMBLER_TEST_RUN(Vnot, test) { | 2309 ASSEMBLER_TEST_RUN(Vnot, test) { |
2608 EXPECT(test != NULL); | 2310 EXPECT(test != NULL); |
2609 typedef int64_t (*Int64Return)() DART_UNUSED; | 2311 typedef int64_t (*Int64Return)() DART_UNUSED; |
2610 EXPECT_EQ(2, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2312 EXPECT_EQ(2, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
2611 } | 2313 } |
2612 | 2314 |
2613 | |
2614 ASSEMBLER_TEST_GENERATE(Vabss, assembler) { | 2315 ASSEMBLER_TEST_GENERATE(Vabss, assembler) { |
2615 __ LoadDImmediate(V1, 21.0); | 2316 __ LoadDImmediate(V1, 21.0); |
2616 __ LoadDImmediate(V2, -21.0); | 2317 __ LoadDImmediate(V2, -21.0); |
2617 | 2318 |
2618 __ fcvtsd(V1, V1); | 2319 __ fcvtsd(V1, V1); |
2619 __ fcvtsd(V2, V2); | 2320 __ fcvtsd(V2, V2); |
2620 | 2321 |
2621 __ veor(V3, V3, V3); | 2322 __ veor(V3, V3, V3); |
2622 __ vinss(V3, 1, V1, 0); | 2323 __ vinss(V3, 1, V1, 0); |
2623 __ vinss(V3, 3, V2, 0); | 2324 __ vinss(V3, 3, V2, 0); |
2624 | 2325 |
2625 __ vabss(V4, V3); | 2326 __ vabss(V4, V3); |
2626 | 2327 |
2627 __ vinss(V5, 0, V4, 1); | 2328 __ vinss(V5, 0, V4, 1); |
2628 __ vinss(V6, 0, V4, 3); | 2329 __ vinss(V6, 0, V4, 3); |
2629 | 2330 |
2630 __ fcvtds(V5, V5); | 2331 __ fcvtds(V5, V5); |
2631 __ fcvtds(V6, V6); | 2332 __ fcvtds(V6, V6); |
2632 | 2333 |
2633 __ faddd(V0, V5, V6); | 2334 __ faddd(V0, V5, V6); |
2634 __ ret(); | 2335 __ ret(); |
2635 } | 2336 } |
2636 | 2337 |
2637 | |
2638 ASSEMBLER_TEST_RUN(Vabss, test) { | 2338 ASSEMBLER_TEST_RUN(Vabss, test) { |
2639 typedef double (*DoubleReturn)() DART_UNUSED; | 2339 typedef double (*DoubleReturn)() DART_UNUSED; |
2640 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2340 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2641 } | 2341 } |
2642 | 2342 |
2643 | |
2644 ASSEMBLER_TEST_GENERATE(Vabsd, assembler) { | 2343 ASSEMBLER_TEST_GENERATE(Vabsd, assembler) { |
2645 __ LoadDImmediate(V1, 21.0); | 2344 __ LoadDImmediate(V1, 21.0); |
2646 __ LoadDImmediate(V2, -21.0); | 2345 __ LoadDImmediate(V2, -21.0); |
2647 | 2346 |
2648 __ vinsd(V3, 0, V1, 0); | 2347 __ vinsd(V3, 0, V1, 0); |
2649 __ vinsd(V3, 1, V2, 0); | 2348 __ vinsd(V3, 1, V2, 0); |
2650 | 2349 |
2651 __ vabsd(V4, V3); | 2350 __ vabsd(V4, V3); |
2652 | 2351 |
2653 __ vinsd(V5, 0, V4, 0); | 2352 __ vinsd(V5, 0, V4, 0); |
2654 __ vinsd(V6, 0, V4, 1); | 2353 __ vinsd(V6, 0, V4, 1); |
2655 | 2354 |
2656 __ faddd(V0, V5, V6); | 2355 __ faddd(V0, V5, V6); |
2657 __ ret(); | 2356 __ ret(); |
2658 } | 2357 } |
2659 | 2358 |
2660 | |
2661 ASSEMBLER_TEST_RUN(Vabsd, test) { | 2359 ASSEMBLER_TEST_RUN(Vabsd, test) { |
2662 typedef double (*DoubleReturn)() DART_UNUSED; | 2360 typedef double (*DoubleReturn)() DART_UNUSED; |
2663 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2361 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2664 } | 2362 } |
2665 | 2363 |
2666 | |
2667 ASSEMBLER_TEST_GENERATE(Vnegs, assembler) { | 2364 ASSEMBLER_TEST_GENERATE(Vnegs, assembler) { |
2668 __ LoadDImmediate(V1, 42.0); | 2365 __ LoadDImmediate(V1, 42.0); |
2669 __ LoadDImmediate(V2, -84.0); | 2366 __ LoadDImmediate(V2, -84.0); |
2670 | 2367 |
2671 __ fcvtsd(V1, V1); | 2368 __ fcvtsd(V1, V1); |
2672 __ fcvtsd(V2, V2); | 2369 __ fcvtsd(V2, V2); |
2673 | 2370 |
2674 __ veor(V3, V3, V3); | 2371 __ veor(V3, V3, V3); |
2675 __ vinss(V3, 1, V1, 0); | 2372 __ vinss(V3, 1, V1, 0); |
2676 __ vinss(V3, 3, V2, 0); | 2373 __ vinss(V3, 3, V2, 0); |
2677 | 2374 |
2678 __ vnegs(V4, V3); | 2375 __ vnegs(V4, V3); |
2679 | 2376 |
2680 __ vinss(V5, 0, V4, 1); | 2377 __ vinss(V5, 0, V4, 1); |
2681 __ vinss(V6, 0, V4, 3); | 2378 __ vinss(V6, 0, V4, 3); |
2682 | 2379 |
2683 __ fcvtds(V5, V5); | 2380 __ fcvtds(V5, V5); |
2684 __ fcvtds(V6, V6); | 2381 __ fcvtds(V6, V6); |
2685 __ faddd(V0, V5, V6); | 2382 __ faddd(V0, V5, V6); |
2686 __ ret(); | 2383 __ ret(); |
2687 } | 2384 } |
2688 | 2385 |
2689 | |
2690 ASSEMBLER_TEST_RUN(Vnegs, test) { | 2386 ASSEMBLER_TEST_RUN(Vnegs, test) { |
2691 typedef double (*DoubleReturn)() DART_UNUSED; | 2387 typedef double (*DoubleReturn)() DART_UNUSED; |
2692 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2388 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2693 } | 2389 } |
2694 | 2390 |
2695 | |
2696 ASSEMBLER_TEST_GENERATE(Vnegd, assembler) { | 2391 ASSEMBLER_TEST_GENERATE(Vnegd, assembler) { |
2697 __ LoadDImmediate(V1, 42.0); | 2392 __ LoadDImmediate(V1, 42.0); |
2698 __ LoadDImmediate(V2, -84.0); | 2393 __ LoadDImmediate(V2, -84.0); |
2699 | 2394 |
2700 __ vinsd(V3, 0, V1, 0); | 2395 __ vinsd(V3, 0, V1, 0); |
2701 __ vinsd(V3, 1, V2, 0); | 2396 __ vinsd(V3, 1, V2, 0); |
2702 | 2397 |
2703 __ vnegd(V4, V3); | 2398 __ vnegd(V4, V3); |
2704 | 2399 |
2705 __ vinsd(V5, 0, V4, 0); | 2400 __ vinsd(V5, 0, V4, 0); |
2706 __ vinsd(V6, 0, V4, 1); | 2401 __ vinsd(V6, 0, V4, 1); |
2707 | 2402 |
2708 __ faddd(V0, V5, V6); | 2403 __ faddd(V0, V5, V6); |
2709 __ ret(); | 2404 __ ret(); |
2710 } | 2405 } |
2711 | 2406 |
2712 | |
2713 ASSEMBLER_TEST_RUN(Vnegd, test) { | 2407 ASSEMBLER_TEST_RUN(Vnegd, test) { |
2714 typedef double (*DoubleReturn)() DART_UNUSED; | 2408 typedef double (*DoubleReturn)() DART_UNUSED; |
2715 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2409 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2716 } | 2410 } |
2717 | 2411 |
2718 | |
2719 ASSEMBLER_TEST_GENERATE(Vadds, assembler) { | 2412 ASSEMBLER_TEST_GENERATE(Vadds, assembler) { |
2720 __ LoadDImmediate(V0, 0.0); | 2413 __ LoadDImmediate(V0, 0.0); |
2721 __ LoadDImmediate(V1, 1.0); | 2414 __ LoadDImmediate(V1, 1.0); |
2722 __ LoadDImmediate(V2, 2.0); | 2415 __ LoadDImmediate(V2, 2.0); |
2723 __ LoadDImmediate(V3, 3.0); | 2416 __ LoadDImmediate(V3, 3.0); |
2724 | 2417 |
2725 __ fcvtsd(V0, V0); | 2418 __ fcvtsd(V0, V0); |
2726 __ fcvtsd(V1, V1); | 2419 __ fcvtsd(V1, V1); |
2727 __ fcvtsd(V2, V2); | 2420 __ fcvtsd(V2, V2); |
2728 __ fcvtsd(V3, V3); | 2421 __ fcvtsd(V3, V3); |
(...skipping 14 matching lines...) Expand all Loading... |
2743 __ fcvtds(V1, V1); | 2436 __ fcvtds(V1, V1); |
2744 __ fcvtds(V2, V2); | 2437 __ fcvtds(V2, V2); |
2745 __ fcvtds(V3, V3); | 2438 __ fcvtds(V3, V3); |
2746 | 2439 |
2747 __ faddd(V0, V0, V1); | 2440 __ faddd(V0, V0, V1); |
2748 __ faddd(V0, V0, V2); | 2441 __ faddd(V0, V0, V2); |
2749 __ faddd(V0, V0, V3); | 2442 __ faddd(V0, V0, V3); |
2750 __ ret(); | 2443 __ ret(); |
2751 } | 2444 } |
2752 | 2445 |
2753 | |
2754 ASSEMBLER_TEST_RUN(Vadds, test) { | 2446 ASSEMBLER_TEST_RUN(Vadds, test) { |
2755 typedef double (*DoubleReturn)() DART_UNUSED; | 2447 typedef double (*DoubleReturn)() DART_UNUSED; |
2756 EXPECT_EQ(12.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2448 EXPECT_EQ(12.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2757 } | 2449 } |
2758 | 2450 |
2759 | |
2760 ASSEMBLER_TEST_GENERATE(Vsubs, assembler) { | 2451 ASSEMBLER_TEST_GENERATE(Vsubs, assembler) { |
2761 __ LoadDImmediate(V0, 0.0); | 2452 __ LoadDImmediate(V0, 0.0); |
2762 __ LoadDImmediate(V1, 1.0); | 2453 __ LoadDImmediate(V1, 1.0); |
2763 __ LoadDImmediate(V2, 2.0); | 2454 __ LoadDImmediate(V2, 2.0); |
2764 __ LoadDImmediate(V3, 3.0); | 2455 __ LoadDImmediate(V3, 3.0); |
2765 __ LoadDImmediate(V5, 0.0); | 2456 __ LoadDImmediate(V5, 0.0); |
2766 | 2457 |
2767 __ fcvtsd(V0, V0); | 2458 __ fcvtsd(V0, V0); |
2768 __ fcvtsd(V1, V1); | 2459 __ fcvtsd(V1, V1); |
2769 __ fcvtsd(V2, V2); | 2460 __ fcvtsd(V2, V2); |
(...skipping 15 matching lines...) Expand all Loading... |
2785 __ fcvtds(V1, V1); | 2476 __ fcvtds(V1, V1); |
2786 __ fcvtds(V2, V2); | 2477 __ fcvtds(V2, V2); |
2787 __ fcvtds(V3, V3); | 2478 __ fcvtds(V3, V3); |
2788 | 2479 |
2789 __ faddd(V0, V0, V1); | 2480 __ faddd(V0, V0, V1); |
2790 __ faddd(V0, V0, V2); | 2481 __ faddd(V0, V0, V2); |
2791 __ faddd(V0, V0, V3); | 2482 __ faddd(V0, V0, V3); |
2792 __ ret(); | 2483 __ ret(); |
2793 } | 2484 } |
2794 | 2485 |
2795 | |
2796 ASSEMBLER_TEST_RUN(Vsubs, test) { | 2486 ASSEMBLER_TEST_RUN(Vsubs, test) { |
2797 typedef double (*DoubleReturn)() DART_UNUSED; | 2487 typedef double (*DoubleReturn)() DART_UNUSED; |
2798 EXPECT_EQ(-6.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2488 EXPECT_EQ(-6.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2799 } | 2489 } |
2800 | 2490 |
2801 | |
2802 ASSEMBLER_TEST_GENERATE(Vmuls, assembler) { | 2491 ASSEMBLER_TEST_GENERATE(Vmuls, assembler) { |
2803 __ LoadDImmediate(V0, 0.0); | 2492 __ LoadDImmediate(V0, 0.0); |
2804 __ LoadDImmediate(V1, 1.0); | 2493 __ LoadDImmediate(V1, 1.0); |
2805 __ LoadDImmediate(V2, 2.0); | 2494 __ LoadDImmediate(V2, 2.0); |
2806 __ LoadDImmediate(V3, 3.0); | 2495 __ LoadDImmediate(V3, 3.0); |
2807 | 2496 |
2808 __ fcvtsd(V0, V0); | 2497 __ fcvtsd(V0, V0); |
2809 __ fcvtsd(V1, V1); | 2498 __ fcvtsd(V1, V1); |
2810 __ fcvtsd(V2, V2); | 2499 __ fcvtsd(V2, V2); |
2811 __ fcvtsd(V3, V3); | 2500 __ fcvtsd(V3, V3); |
(...skipping 14 matching lines...) Expand all Loading... |
2826 __ fcvtds(V1, V1); | 2515 __ fcvtds(V1, V1); |
2827 __ fcvtds(V2, V2); | 2516 __ fcvtds(V2, V2); |
2828 __ fcvtds(V3, V3); | 2517 __ fcvtds(V3, V3); |
2829 | 2518 |
2830 __ faddd(V0, V0, V1); | 2519 __ faddd(V0, V0, V1); |
2831 __ faddd(V0, V0, V2); | 2520 __ faddd(V0, V0, V2); |
2832 __ faddd(V0, V0, V3); | 2521 __ faddd(V0, V0, V3); |
2833 __ ret(); | 2522 __ ret(); |
2834 } | 2523 } |
2835 | 2524 |
2836 | |
2837 ASSEMBLER_TEST_RUN(Vmuls, test) { | 2525 ASSEMBLER_TEST_RUN(Vmuls, test) { |
2838 typedef double (*DoubleReturn)() DART_UNUSED; | 2526 typedef double (*DoubleReturn)() DART_UNUSED; |
2839 EXPECT_EQ(14.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2527 EXPECT_EQ(14.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2840 } | 2528 } |
2841 | 2529 |
2842 | |
2843 ASSEMBLER_TEST_GENERATE(Vdivs, assembler) { | 2530 ASSEMBLER_TEST_GENERATE(Vdivs, assembler) { |
2844 __ LoadDImmediate(V0, 0.0); | 2531 __ LoadDImmediate(V0, 0.0); |
2845 __ LoadDImmediate(V1, 1.0); | 2532 __ LoadDImmediate(V1, 1.0); |
2846 __ LoadDImmediate(V2, 2.0); | 2533 __ LoadDImmediate(V2, 2.0); |
2847 __ LoadDImmediate(V3, 3.0); | 2534 __ LoadDImmediate(V3, 3.0); |
2848 | 2535 |
2849 __ fcvtsd(V0, V0); | 2536 __ fcvtsd(V0, V0); |
2850 __ fcvtsd(V1, V1); | 2537 __ fcvtsd(V1, V1); |
2851 __ fcvtsd(V2, V2); | 2538 __ fcvtsd(V2, V2); |
2852 __ fcvtsd(V3, V3); | 2539 __ fcvtsd(V3, V3); |
(...skipping 14 matching lines...) Expand all Loading... |
2867 __ fcvtds(V1, V1); | 2554 __ fcvtds(V1, V1); |
2868 __ fcvtds(V2, V2); | 2555 __ fcvtds(V2, V2); |
2869 __ fcvtds(V3, V3); | 2556 __ fcvtds(V3, V3); |
2870 | 2557 |
2871 __ faddd(V0, V1, V1); | 2558 __ faddd(V0, V1, V1); |
2872 __ faddd(V0, V0, V2); | 2559 __ faddd(V0, V0, V2); |
2873 __ faddd(V0, V0, V3); | 2560 __ faddd(V0, V0, V3); |
2874 __ ret(); | 2561 __ ret(); |
2875 } | 2562 } |
2876 | 2563 |
2877 | |
2878 ASSEMBLER_TEST_RUN(Vdivs, test) { | 2564 ASSEMBLER_TEST_RUN(Vdivs, test) { |
2879 typedef double (*DoubleReturn)() DART_UNUSED; | 2565 typedef double (*DoubleReturn)() DART_UNUSED; |
2880 EXPECT_EQ(4.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2566 EXPECT_EQ(4.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2881 } | 2567 } |
2882 | 2568 |
2883 | |
2884 ASSEMBLER_TEST_GENERATE(Vaddd, assembler) { | 2569 ASSEMBLER_TEST_GENERATE(Vaddd, assembler) { |
2885 __ LoadDImmediate(V0, 2.0); | 2570 __ LoadDImmediate(V0, 2.0); |
2886 __ LoadDImmediate(V1, 3.0); | 2571 __ LoadDImmediate(V1, 3.0); |
2887 | 2572 |
2888 __ vinsd(V4, 0, V0, 0); | 2573 __ vinsd(V4, 0, V0, 0); |
2889 __ vinsd(V4, 1, V1, 0); | 2574 __ vinsd(V4, 1, V1, 0); |
2890 | 2575 |
2891 __ vaddd(V5, V4, V4); | 2576 __ vaddd(V5, V4, V4); |
2892 | 2577 |
2893 __ vinsd(V0, 0, V5, 0); | 2578 __ vinsd(V0, 0, V5, 0); |
2894 __ vinsd(V1, 0, V5, 1); | 2579 __ vinsd(V1, 0, V5, 1); |
2895 | 2580 |
2896 __ faddd(V0, V0, V1); | 2581 __ faddd(V0, V0, V1); |
2897 __ ret(); | 2582 __ ret(); |
2898 } | 2583 } |
2899 | 2584 |
2900 | |
2901 ASSEMBLER_TEST_RUN(Vaddd, test) { | 2585 ASSEMBLER_TEST_RUN(Vaddd, test) { |
2902 typedef double (*DoubleReturn)() DART_UNUSED; | 2586 typedef double (*DoubleReturn)() DART_UNUSED; |
2903 EXPECT_EQ(10.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2587 EXPECT_EQ(10.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2904 } | 2588 } |
2905 | 2589 |
2906 | |
2907 ASSEMBLER_TEST_GENERATE(Vsubd, assembler) { | 2590 ASSEMBLER_TEST_GENERATE(Vsubd, assembler) { |
2908 __ LoadDImmediate(V0, 2.0); | 2591 __ LoadDImmediate(V0, 2.0); |
2909 __ LoadDImmediate(V1, 3.0); | 2592 __ LoadDImmediate(V1, 3.0); |
2910 __ LoadDImmediate(V5, 0.0); | 2593 __ LoadDImmediate(V5, 0.0); |
2911 | 2594 |
2912 __ vinsd(V4, 0, V0, 0); | 2595 __ vinsd(V4, 0, V0, 0); |
2913 __ vinsd(V4, 1, V1, 0); | 2596 __ vinsd(V4, 1, V1, 0); |
2914 | 2597 |
2915 __ vsubd(V5, V5, V4); | 2598 __ vsubd(V5, V5, V4); |
2916 | 2599 |
2917 __ vinsd(V0, 0, V5, 0); | 2600 __ vinsd(V0, 0, V5, 0); |
2918 __ vinsd(V1, 0, V5, 1); | 2601 __ vinsd(V1, 0, V5, 1); |
2919 | 2602 |
2920 __ faddd(V0, V0, V1); | 2603 __ faddd(V0, V0, V1); |
2921 __ ret(); | 2604 __ ret(); |
2922 } | 2605 } |
2923 | 2606 |
2924 | |
2925 ASSEMBLER_TEST_RUN(Vsubd, test) { | 2607 ASSEMBLER_TEST_RUN(Vsubd, test) { |
2926 typedef double (*DoubleReturn)() DART_UNUSED; | 2608 typedef double (*DoubleReturn)() DART_UNUSED; |
2927 EXPECT_EQ(-5.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2609 EXPECT_EQ(-5.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2928 } | 2610 } |
2929 | 2611 |
2930 | |
2931 ASSEMBLER_TEST_GENERATE(Vmuld, assembler) { | 2612 ASSEMBLER_TEST_GENERATE(Vmuld, assembler) { |
2932 __ LoadDImmediate(V0, 2.0); | 2613 __ LoadDImmediate(V0, 2.0); |
2933 __ LoadDImmediate(V1, 3.0); | 2614 __ LoadDImmediate(V1, 3.0); |
2934 | 2615 |
2935 __ vinsd(V4, 0, V0, 0); | 2616 __ vinsd(V4, 0, V0, 0); |
2936 __ vinsd(V4, 1, V1, 0); | 2617 __ vinsd(V4, 1, V1, 0); |
2937 | 2618 |
2938 __ vmuld(V5, V4, V4); | 2619 __ vmuld(V5, V4, V4); |
2939 | 2620 |
2940 __ vinsd(V0, 0, V5, 0); | 2621 __ vinsd(V0, 0, V5, 0); |
2941 __ vinsd(V1, 0, V5, 1); | 2622 __ vinsd(V1, 0, V5, 1); |
2942 | 2623 |
2943 __ faddd(V0, V0, V1); | 2624 __ faddd(V0, V0, V1); |
2944 __ ret(); | 2625 __ ret(); |
2945 } | 2626 } |
2946 | 2627 |
2947 | |
2948 ASSEMBLER_TEST_RUN(Vmuld, test) { | 2628 ASSEMBLER_TEST_RUN(Vmuld, test) { |
2949 typedef double (*DoubleReturn)() DART_UNUSED; | 2629 typedef double (*DoubleReturn)() DART_UNUSED; |
2950 EXPECT_EQ(13.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2630 EXPECT_EQ(13.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2951 } | 2631 } |
2952 | 2632 |
2953 | |
2954 ASSEMBLER_TEST_GENERATE(Vdivd, assembler) { | 2633 ASSEMBLER_TEST_GENERATE(Vdivd, assembler) { |
2955 __ LoadDImmediate(V0, 2.0); | 2634 __ LoadDImmediate(V0, 2.0); |
2956 __ LoadDImmediate(V1, 3.0); | 2635 __ LoadDImmediate(V1, 3.0); |
2957 | 2636 |
2958 __ vinsd(V4, 0, V0, 0); | 2637 __ vinsd(V4, 0, V0, 0); |
2959 __ vinsd(V4, 1, V1, 0); | 2638 __ vinsd(V4, 1, V1, 0); |
2960 | 2639 |
2961 __ vdivd(V5, V4, V4); | 2640 __ vdivd(V5, V4, V4); |
2962 | 2641 |
2963 __ vinsd(V0, 0, V5, 0); | 2642 __ vinsd(V0, 0, V5, 0); |
2964 __ vinsd(V1, 0, V5, 1); | 2643 __ vinsd(V1, 0, V5, 1); |
2965 | 2644 |
2966 __ faddd(V0, V0, V1); | 2645 __ faddd(V0, V0, V1); |
2967 __ ret(); | 2646 __ ret(); |
2968 } | 2647 } |
2969 | 2648 |
2970 | |
2971 ASSEMBLER_TEST_RUN(Vdivd, test) { | 2649 ASSEMBLER_TEST_RUN(Vdivd, test) { |
2972 typedef double (*DoubleReturn)() DART_UNUSED; | 2650 typedef double (*DoubleReturn)() DART_UNUSED; |
2973 EXPECT_EQ(2.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2651 EXPECT_EQ(2.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2974 } | 2652 } |
2975 | 2653 |
2976 | |
2977 ASSEMBLER_TEST_GENERATE(Vdupd, assembler) { | 2654 ASSEMBLER_TEST_GENERATE(Vdupd, assembler) { |
2978 __ SetupDartSP(); | 2655 __ SetupDartSP(); |
2979 __ LoadDImmediate(V0, 21.0); | 2656 __ LoadDImmediate(V0, 21.0); |
2980 __ vdupd(V1, V0, 0); | 2657 __ vdupd(V1, V0, 0); |
2981 | 2658 |
2982 const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord); | 2659 const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord); |
2983 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); | 2660 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); |
2984 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); | 2661 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); |
2985 | 2662 |
2986 __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex)); | 2663 __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex)); |
2987 __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex)); | 2664 __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex)); |
2988 | 2665 |
2989 __ faddd(V0, V2, V3); | 2666 __ faddd(V0, V2, V3); |
2990 __ RestoreCSP(); | 2667 __ RestoreCSP(); |
2991 __ ret(); | 2668 __ ret(); |
2992 } | 2669 } |
2993 | 2670 |
2994 | |
2995 ASSEMBLER_TEST_RUN(Vdupd, test) { | 2671 ASSEMBLER_TEST_RUN(Vdupd, test) { |
2996 typedef double (*DoubleReturn)() DART_UNUSED; | 2672 typedef double (*DoubleReturn)() DART_UNUSED; |
2997 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2673 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
2998 } | 2674 } |
2999 | 2675 |
3000 | |
3001 ASSEMBLER_TEST_GENERATE(Vdups, assembler) { | 2676 ASSEMBLER_TEST_GENERATE(Vdups, assembler) { |
3002 __ SetupDartSP(); | 2677 __ SetupDartSP(); |
3003 __ LoadDImmediate(V0, 21.0); | 2678 __ LoadDImmediate(V0, 21.0); |
3004 __ fcvtsd(V0, V0); | 2679 __ fcvtsd(V0, V0); |
3005 __ vdups(V1, V0, 0); | 2680 __ vdups(V1, V0, 0); |
3006 | 2681 |
3007 const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord); | 2682 const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord); |
3008 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); | 2683 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); |
3009 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); | 2684 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); |
3010 | 2685 |
3011 __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2686 __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3012 __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2687 __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3013 __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2688 __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3014 __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2689 __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3015 | 2690 |
3016 __ fcvtds(V0, V0); | 2691 __ fcvtds(V0, V0); |
3017 __ fcvtds(V1, V1); | 2692 __ fcvtds(V1, V1); |
3018 __ fcvtds(V2, V2); | 2693 __ fcvtds(V2, V2); |
3019 __ fcvtds(V3, V3); | 2694 __ fcvtds(V3, V3); |
3020 | 2695 |
3021 __ faddd(V0, V1, V1); | 2696 __ faddd(V0, V1, V1); |
3022 __ faddd(V0, V0, V2); | 2697 __ faddd(V0, V0, V2); |
3023 __ faddd(V0, V0, V3); | 2698 __ faddd(V0, V0, V3); |
3024 __ RestoreCSP(); | 2699 __ RestoreCSP(); |
3025 __ ret(); | 2700 __ ret(); |
3026 } | 2701 } |
3027 | 2702 |
3028 | |
3029 ASSEMBLER_TEST_RUN(Vdups, test) { | 2703 ASSEMBLER_TEST_RUN(Vdups, test) { |
3030 typedef double (*DoubleReturn)() DART_UNUSED; | 2704 typedef double (*DoubleReturn)() DART_UNUSED; |
3031 EXPECT_EQ(84.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2705 EXPECT_EQ(84.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3032 } | 2706 } |
3033 | 2707 |
3034 | |
3035 ASSEMBLER_TEST_GENERATE(Vinsd, assembler) { | 2708 ASSEMBLER_TEST_GENERATE(Vinsd, assembler) { |
3036 __ SetupDartSP(); | 2709 __ SetupDartSP(); |
3037 __ LoadDImmediate(V5, 42.0); | 2710 __ LoadDImmediate(V5, 42.0); |
3038 __ vinsd(V1, 1, V5, 0); // V1[1] <- V0[0]. | 2711 __ vinsd(V1, 1, V5, 0); // V1[1] <- V0[0]. |
3039 | 2712 |
3040 const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord); | 2713 const int dword_bytes = 1 << Log2OperandSizeBytes(kDWord); |
3041 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); | 2714 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); |
3042 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); | 2715 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); |
3043 | 2716 |
3044 __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex)); | 2717 __ fldrd(V2, Address(SP, 1 * dword_bytes, Address::PostIndex)); |
3045 __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex)); | 2718 __ fldrd(V3, Address(SP, 1 * dword_bytes, Address::PostIndex)); |
3046 | 2719 |
3047 __ fmovdd(V0, V3); | 2720 __ fmovdd(V0, V3); |
3048 __ RestoreCSP(); | 2721 __ RestoreCSP(); |
3049 __ ret(); | 2722 __ ret(); |
3050 } | 2723 } |
3051 | 2724 |
3052 | |
3053 ASSEMBLER_TEST_RUN(Vinsd, test) { | 2725 ASSEMBLER_TEST_RUN(Vinsd, test) { |
3054 typedef double (*DoubleReturn)() DART_UNUSED; | 2726 typedef double (*DoubleReturn)() DART_UNUSED; |
3055 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2727 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3056 } | 2728 } |
3057 | 2729 |
3058 | |
3059 ASSEMBLER_TEST_GENERATE(Vinss, assembler) { | 2730 ASSEMBLER_TEST_GENERATE(Vinss, assembler) { |
3060 __ SetupDartSP(); | 2731 __ SetupDartSP(); |
3061 __ LoadDImmediate(V0, 21.0); | 2732 __ LoadDImmediate(V0, 21.0); |
3062 __ fcvtsd(V0, V0); | 2733 __ fcvtsd(V0, V0); |
3063 __ vinss(V1, 3, V0, 0); | 2734 __ vinss(V1, 3, V0, 0); |
3064 __ vinss(V1, 1, V0, 0); | 2735 __ vinss(V1, 1, V0, 0); |
3065 | 2736 |
3066 const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord); | 2737 const int sword_bytes = 1 << Log2OperandSizeBytes(kSWord); |
3067 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); | 2738 const int qword_bytes = 1 << Log2OperandSizeBytes(kQWord); |
3068 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); | 2739 __ fstrq(V1, Address(SP, -1 * qword_bytes, Address::PreIndex)); |
3069 | 2740 |
3070 __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2741 __ fldrs(V3, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3071 __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2742 __ fldrs(V2, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3072 __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2743 __ fldrs(V1, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3073 __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex)); | 2744 __ fldrs(V0, Address(SP, 1 * sword_bytes, Address::PostIndex)); |
3074 | 2745 |
3075 __ fcvtds(V0, V0); | 2746 __ fcvtds(V0, V0); |
3076 __ fcvtds(V1, V1); | 2747 __ fcvtds(V1, V1); |
3077 __ fcvtds(V2, V2); | 2748 __ fcvtds(V2, V2); |
3078 __ fcvtds(V3, V3); | 2749 __ fcvtds(V3, V3); |
3079 | 2750 |
3080 __ faddd(V0, V0, V1); | 2751 __ faddd(V0, V0, V1); |
3081 __ faddd(V0, V0, V2); | 2752 __ faddd(V0, V0, V2); |
3082 __ faddd(V0, V0, V3); | 2753 __ faddd(V0, V0, V3); |
3083 __ RestoreCSP(); | 2754 __ RestoreCSP(); |
3084 __ ret(); | 2755 __ ret(); |
3085 } | 2756 } |
3086 | 2757 |
3087 | |
3088 ASSEMBLER_TEST_RUN(Vinss, test) { | 2758 ASSEMBLER_TEST_RUN(Vinss, test) { |
3089 typedef double (*DoubleReturn)() DART_UNUSED; | 2759 typedef double (*DoubleReturn)() DART_UNUSED; |
3090 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2760 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3091 } | 2761 } |
3092 | 2762 |
3093 | |
3094 ASSEMBLER_TEST_GENERATE(Vand, assembler) { | 2763 ASSEMBLER_TEST_GENERATE(Vand, assembler) { |
3095 __ LoadDImmediate(V1, 21.0); | 2764 __ LoadDImmediate(V1, 21.0); |
3096 __ LoadImmediate(R0, 0xffffffff); | 2765 __ LoadImmediate(R0, 0xffffffff); |
3097 | 2766 |
3098 // V0 <- (0, 0xffffffff, 0, 0xffffffff) | 2767 // V0 <- (0, 0xffffffff, 0, 0xffffffff) |
3099 __ fmovdr(V0, R0); | 2768 __ fmovdr(V0, R0); |
3100 __ vinss(V0, 2, V0, 0); | 2769 __ vinss(V0, 2, V0, 0); |
3101 | 2770 |
3102 // V1 <- (21.0, 21.0, 21.0, 21.0) | 2771 // V1 <- (21.0, 21.0, 21.0, 21.0) |
3103 __ fcvtsd(V1, V1); | 2772 __ fcvtsd(V1, V1); |
(...skipping 10 matching lines...) Expand all Loading... |
3114 __ fcvtds(V4, V4); | 2783 __ fcvtds(V4, V4); |
3115 __ fcvtds(V5, V5); | 2784 __ fcvtds(V5, V5); |
3116 __ fcvtds(V6, V6); | 2785 __ fcvtds(V6, V6); |
3117 | 2786 |
3118 __ vaddd(V0, V3, V4); | 2787 __ vaddd(V0, V3, V4); |
3119 __ vaddd(V0, V0, V5); | 2788 __ vaddd(V0, V0, V5); |
3120 __ vaddd(V0, V0, V6); | 2789 __ vaddd(V0, V0, V6); |
3121 __ ret(); | 2790 __ ret(); |
3122 } | 2791 } |
3123 | 2792 |
3124 | |
3125 ASSEMBLER_TEST_RUN(Vand, test) { | 2793 ASSEMBLER_TEST_RUN(Vand, test) { |
3126 typedef double (*DoubleReturn)() DART_UNUSED; | 2794 typedef double (*DoubleReturn)() DART_UNUSED; |
3127 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2795 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3128 } | 2796 } |
3129 | 2797 |
3130 | |
3131 ASSEMBLER_TEST_GENERATE(Vorr, assembler) { | 2798 ASSEMBLER_TEST_GENERATE(Vorr, assembler) { |
3132 __ LoadDImmediate(V1, 10.5); | 2799 __ LoadDImmediate(V1, 10.5); |
3133 __ fcvtsd(V1, V1); | 2800 __ fcvtsd(V1, V1); |
3134 | 2801 |
3135 // V0 <- (0, 10.5, 0, 10.5) | 2802 // V0 <- (0, 10.5, 0, 10.5) |
3136 __ fmovdd(V0, V1); | 2803 __ fmovdd(V0, V1); |
3137 __ vinss(V0, 2, V0, 0); | 2804 __ vinss(V0, 2, V0, 0); |
3138 | 2805 |
3139 // V1 <- (10.5, 0, 10.5, 0) | 2806 // V1 <- (10.5, 0, 10.5, 0) |
3140 __ veor(V1, V1, V1); | 2807 __ veor(V1, V1, V1); |
(...skipping 11 matching lines...) Expand all Loading... |
3152 __ fcvtds(V4, V4); | 2819 __ fcvtds(V4, V4); |
3153 __ fcvtds(V5, V5); | 2820 __ fcvtds(V5, V5); |
3154 __ fcvtds(V6, V6); | 2821 __ fcvtds(V6, V6); |
3155 | 2822 |
3156 __ vaddd(V0, V3, V4); | 2823 __ vaddd(V0, V3, V4); |
3157 __ vaddd(V0, V0, V5); | 2824 __ vaddd(V0, V0, V5); |
3158 __ vaddd(V0, V0, V6); | 2825 __ vaddd(V0, V0, V6); |
3159 __ ret(); | 2826 __ ret(); |
3160 } | 2827 } |
3161 | 2828 |
3162 | |
3163 ASSEMBLER_TEST_RUN(Vorr, test) { | 2829 ASSEMBLER_TEST_RUN(Vorr, test) { |
3164 typedef double (*DoubleReturn)() DART_UNUSED; | 2830 typedef double (*DoubleReturn)() DART_UNUSED; |
3165 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 2831 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3166 } | 2832 } |
3167 | 2833 |
3168 | |
3169 ASSEMBLER_TEST_GENERATE(Veor, assembler) { | 2834 ASSEMBLER_TEST_GENERATE(Veor, assembler) { |
3170 __ LoadImmediate(R1, 0xffffffff); | 2835 __ LoadImmediate(R1, 0xffffffff); |
3171 __ LoadImmediate(R2, ~21); | 2836 __ LoadImmediate(R2, ~21); |
3172 | 2837 |
3173 __ vinsw(V1, 0, R1); | 2838 __ vinsw(V1, 0, R1); |
3174 __ vinsw(V1, 1, R2); | 2839 __ vinsw(V1, 1, R2); |
3175 __ vinsw(V1, 2, R1); | 2840 __ vinsw(V1, 2, R1); |
3176 __ vinsw(V1, 3, R2); | 2841 __ vinsw(V1, 3, R2); |
3177 | 2842 |
3178 __ vinsw(V2, 0, R1); | 2843 __ vinsw(V2, 0, R1); |
3179 __ vinsw(V2, 1, R1); | 2844 __ vinsw(V2, 1, R1); |
3180 __ vinsw(V2, 2, R1); | 2845 __ vinsw(V2, 2, R1); |
3181 __ vinsw(V2, 3, R1); | 2846 __ vinsw(V2, 3, R1); |
3182 | 2847 |
3183 __ veor(V0, V1, V2); | 2848 __ veor(V0, V1, V2); |
3184 | 2849 |
3185 __ vmovrs(R3, V0, 0); | 2850 __ vmovrs(R3, V0, 0); |
3186 __ vmovrs(R4, V0, 1); | 2851 __ vmovrs(R4, V0, 1); |
3187 __ vmovrs(R5, V0, 2); | 2852 __ vmovrs(R5, V0, 2); |
3188 __ vmovrs(R6, V0, 3); | 2853 __ vmovrs(R6, V0, 3); |
3189 | 2854 |
3190 __ add(R0, R3, Operand(R4)); | 2855 __ add(R0, R3, Operand(R4)); |
3191 __ add(R0, R0, Operand(R5)); | 2856 __ add(R0, R0, Operand(R5)); |
3192 __ add(R0, R0, Operand(R6)); | 2857 __ add(R0, R0, Operand(R6)); |
3193 __ ret(); | 2858 __ ret(); |
3194 } | 2859 } |
3195 | 2860 |
3196 | |
3197 ASSEMBLER_TEST_RUN(Veor, test) { | 2861 ASSEMBLER_TEST_RUN(Veor, test) { |
3198 typedef int64_t (*Int64Return)() DART_UNUSED; | 2862 typedef int64_t (*Int64Return)() DART_UNUSED; |
3199 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2863 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3200 } | 2864 } |
3201 | 2865 |
3202 | |
3203 ASSEMBLER_TEST_GENERATE(Vaddw, assembler) { | 2866 ASSEMBLER_TEST_GENERATE(Vaddw, assembler) { |
3204 __ LoadImmediate(R4, 21); | 2867 __ LoadImmediate(R4, 21); |
3205 | 2868 |
3206 __ vdupw(V1, R4); | 2869 __ vdupw(V1, R4); |
3207 __ vdupw(V2, R4); | 2870 __ vdupw(V2, R4); |
3208 | 2871 |
3209 __ vaddw(V0, V1, V2); | 2872 __ vaddw(V0, V1, V2); |
3210 | 2873 |
3211 __ vmovrs(R0, V0, 0); | 2874 __ vmovrs(R0, V0, 0); |
3212 __ vmovrs(R1, V0, 1); | 2875 __ vmovrs(R1, V0, 1); |
3213 __ vmovrs(R2, V0, 2); | 2876 __ vmovrs(R2, V0, 2); |
3214 __ vmovrs(R3, V0, 3); | 2877 __ vmovrs(R3, V0, 3); |
3215 __ add(R0, R0, Operand(R1)); | 2878 __ add(R0, R0, Operand(R1)); |
3216 __ add(R0, R0, Operand(R2)); | 2879 __ add(R0, R0, Operand(R2)); |
3217 __ add(R0, R0, Operand(R3)); | 2880 __ add(R0, R0, Operand(R3)); |
3218 __ ret(); | 2881 __ ret(); |
3219 } | 2882 } |
3220 | 2883 |
3221 | |
3222 ASSEMBLER_TEST_RUN(Vaddw, test) { | 2884 ASSEMBLER_TEST_RUN(Vaddw, test) { |
3223 typedef int64_t (*Int64Return)() DART_UNUSED; | 2885 typedef int64_t (*Int64Return)() DART_UNUSED; |
3224 EXPECT_EQ(168, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2886 EXPECT_EQ(168, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3225 } | 2887 } |
3226 | 2888 |
3227 | |
3228 ASSEMBLER_TEST_GENERATE(Vsubw, assembler) { | 2889 ASSEMBLER_TEST_GENERATE(Vsubw, assembler) { |
3229 __ LoadImmediate(R4, 31); | 2890 __ LoadImmediate(R4, 31); |
3230 __ LoadImmediate(R5, 10); | 2891 __ LoadImmediate(R5, 10); |
3231 | 2892 |
3232 __ vdupw(V1, R4); | 2893 __ vdupw(V1, R4); |
3233 __ vdupw(V2, R5); | 2894 __ vdupw(V2, R5); |
3234 | 2895 |
3235 __ vsubw(V0, V1, V2); | 2896 __ vsubw(V0, V1, V2); |
3236 | 2897 |
3237 __ vmovrs(R0, V0, 0); | 2898 __ vmovrs(R0, V0, 0); |
3238 __ vmovrs(R1, V0, 1); | 2899 __ vmovrs(R1, V0, 1); |
3239 __ vmovrs(R2, V0, 2); | 2900 __ vmovrs(R2, V0, 2); |
3240 __ vmovrs(R3, V0, 3); | 2901 __ vmovrs(R3, V0, 3); |
3241 __ add(R0, R0, Operand(R1)); | 2902 __ add(R0, R0, Operand(R1)); |
3242 __ add(R0, R0, Operand(R2)); | 2903 __ add(R0, R0, Operand(R2)); |
3243 __ add(R0, R0, Operand(R3)); | 2904 __ add(R0, R0, Operand(R3)); |
3244 __ ret(); | 2905 __ ret(); |
3245 } | 2906 } |
3246 | 2907 |
3247 | |
3248 ASSEMBLER_TEST_RUN(Vsubw, test) { | 2908 ASSEMBLER_TEST_RUN(Vsubw, test) { |
3249 typedef int64_t (*Int64Return)() DART_UNUSED; | 2909 typedef int64_t (*Int64Return)() DART_UNUSED; |
3250 EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2910 EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3251 } | 2911 } |
3252 | 2912 |
3253 | |
3254 ASSEMBLER_TEST_GENERATE(Vaddx, assembler) { | 2913 ASSEMBLER_TEST_GENERATE(Vaddx, assembler) { |
3255 __ LoadImmediate(R4, 21); | 2914 __ LoadImmediate(R4, 21); |
3256 | 2915 |
3257 __ vdupx(V1, R4); | 2916 __ vdupx(V1, R4); |
3258 __ vdupx(V2, R4); | 2917 __ vdupx(V2, R4); |
3259 | 2918 |
3260 __ vaddx(V0, V1, V2); | 2919 __ vaddx(V0, V1, V2); |
3261 | 2920 |
3262 __ vmovrd(R0, V0, 0); | 2921 __ vmovrd(R0, V0, 0); |
3263 __ vmovrd(R1, V0, 1); | 2922 __ vmovrd(R1, V0, 1); |
3264 __ add(R0, R0, Operand(R1)); | 2923 __ add(R0, R0, Operand(R1)); |
3265 __ ret(); | 2924 __ ret(); |
3266 } | 2925 } |
3267 | 2926 |
3268 | |
3269 ASSEMBLER_TEST_RUN(Vaddx, test) { | 2927 ASSEMBLER_TEST_RUN(Vaddx, test) { |
3270 typedef int64_t (*Int64Return)() DART_UNUSED; | 2928 typedef int64_t (*Int64Return)() DART_UNUSED; |
3271 EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2929 EXPECT_EQ(84, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3272 } | 2930 } |
3273 | 2931 |
3274 | |
3275 ASSEMBLER_TEST_GENERATE(Vsubx, assembler) { | 2932 ASSEMBLER_TEST_GENERATE(Vsubx, assembler) { |
3276 __ LoadImmediate(R4, 31); | 2933 __ LoadImmediate(R4, 31); |
3277 __ LoadImmediate(R5, 10); | 2934 __ LoadImmediate(R5, 10); |
3278 | 2935 |
3279 __ vdupx(V1, R4); | 2936 __ vdupx(V1, R4); |
3280 __ vdupx(V2, R5); | 2937 __ vdupx(V2, R5); |
3281 | 2938 |
3282 __ vsubx(V0, V1, V2); | 2939 __ vsubx(V0, V1, V2); |
3283 | 2940 |
3284 __ vmovrd(R0, V0, 0); | 2941 __ vmovrd(R0, V0, 0); |
3285 __ vmovrd(R1, V0, 1); | 2942 __ vmovrd(R1, V0, 1); |
3286 __ add(R0, R0, Operand(R1)); | 2943 __ add(R0, R0, Operand(R1)); |
3287 __ ret(); | 2944 __ ret(); |
3288 } | 2945 } |
3289 | 2946 |
3290 | |
3291 ASSEMBLER_TEST_RUN(Vsubx, test) { | 2947 ASSEMBLER_TEST_RUN(Vsubx, test) { |
3292 typedef int64_t (*Int64Return)() DART_UNUSED; | 2948 typedef int64_t (*Int64Return)() DART_UNUSED; |
3293 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2949 EXPECT_EQ(42, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3294 } | 2950 } |
3295 | 2951 |
3296 | |
3297 ASSEMBLER_TEST_GENERATE(Vceqs, assembler) { | 2952 ASSEMBLER_TEST_GENERATE(Vceqs, assembler) { |
3298 __ LoadDImmediate(V0, 42.0); | 2953 __ LoadDImmediate(V0, 42.0); |
3299 __ LoadDImmediate(V1, -42.0); | 2954 __ LoadDImmediate(V1, -42.0); |
3300 | 2955 |
3301 __ fcvtsd(V0, V0); | 2956 __ fcvtsd(V0, V0); |
3302 __ fcvtsd(V1, V1); | 2957 __ fcvtsd(V1, V1); |
3303 | 2958 |
3304 __ vdups(V2, V0, 0); | 2959 __ vdups(V2, V0, 0); |
3305 __ vinss(V3, 0, V0, 0); | 2960 __ vinss(V3, 0, V0, 0); |
3306 __ vinss(V3, 1, V1, 0); | 2961 __ vinss(V3, 1, V1, 0); |
3307 __ vinss(V3, 2, V0, 0); | 2962 __ vinss(V3, 2, V0, 0); |
3308 __ vinss(V3, 3, V1, 0); | 2963 __ vinss(V3, 3, V1, 0); |
3309 | 2964 |
3310 __ vceqs(V4, V2, V3); | 2965 __ vceqs(V4, V2, V3); |
3311 | 2966 |
3312 __ vmovrs(R1, V4, 0); | 2967 __ vmovrs(R1, V4, 0); |
3313 __ vmovrs(R2, V4, 1); | 2968 __ vmovrs(R2, V4, 1); |
3314 __ vmovrs(R3, V4, 2); | 2969 __ vmovrs(R3, V4, 2); |
3315 __ vmovrs(R4, V4, 3); | 2970 __ vmovrs(R4, V4, 3); |
3316 | 2971 |
3317 __ addw(R0, R1, Operand(R2)); | 2972 __ addw(R0, R1, Operand(R2)); |
3318 __ addw(R0, R0, Operand(R3)); | 2973 __ addw(R0, R0, Operand(R3)); |
3319 __ addw(R0, R0, Operand(R4)); | 2974 __ addw(R0, R0, Operand(R4)); |
3320 __ ret(); | 2975 __ ret(); |
3321 } | 2976 } |
3322 | 2977 |
3323 | |
3324 ASSEMBLER_TEST_RUN(Vceqs, test) { | 2978 ASSEMBLER_TEST_RUN(Vceqs, test) { |
3325 typedef int64_t (*Int64Return)() DART_UNUSED; | 2979 typedef int64_t (*Int64Return)() DART_UNUSED; |
3326 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 2980 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3327 } | 2981 } |
3328 | 2982 |
3329 | |
3330 ASSEMBLER_TEST_GENERATE(Vceqd, assembler) { | 2983 ASSEMBLER_TEST_GENERATE(Vceqd, assembler) { |
3331 __ LoadDImmediate(V0, 42.0); | 2984 __ LoadDImmediate(V0, 42.0); |
3332 __ LoadDImmediate(V1, -42.0); | 2985 __ LoadDImmediate(V1, -42.0); |
3333 | 2986 |
3334 __ vdupd(V2, V0, 0); | 2987 __ vdupd(V2, V0, 0); |
3335 __ vinsd(V3, 0, V0, 0); | 2988 __ vinsd(V3, 0, V0, 0); |
3336 __ vinsd(V3, 1, V1, 0); | 2989 __ vinsd(V3, 1, V1, 0); |
3337 | 2990 |
3338 __ vceqd(V4, V2, V3); | 2991 __ vceqd(V4, V2, V3); |
3339 | 2992 |
3340 __ vmovrd(R1, V4, 0); | 2993 __ vmovrd(R1, V4, 0); |
3341 __ vmovrd(R2, V4, 1); | 2994 __ vmovrd(R2, V4, 1); |
3342 | 2995 |
3343 __ add(R0, R1, Operand(R2)); | 2996 __ add(R0, R1, Operand(R2)); |
3344 __ ret(); | 2997 __ ret(); |
3345 } | 2998 } |
3346 | 2999 |
3347 | |
3348 ASSEMBLER_TEST_RUN(Vceqd, test) { | 3000 ASSEMBLER_TEST_RUN(Vceqd, test) { |
3349 typedef int64_t (*Int64Return)() DART_UNUSED; | 3001 typedef int64_t (*Int64Return)() DART_UNUSED; |
3350 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 3002 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3351 } | 3003 } |
3352 | 3004 |
3353 | |
3354 ASSEMBLER_TEST_GENERATE(Vcgts, assembler) { | 3005 ASSEMBLER_TEST_GENERATE(Vcgts, assembler) { |
3355 __ LoadDImmediate(V0, 42.0); | 3006 __ LoadDImmediate(V0, 42.0); |
3356 __ LoadDImmediate(V1, -42.0); | 3007 __ LoadDImmediate(V1, -42.0); |
3357 | 3008 |
3358 __ fcvtsd(V0, V0); | 3009 __ fcvtsd(V0, V0); |
3359 __ fcvtsd(V1, V1); | 3010 __ fcvtsd(V1, V1); |
3360 | 3011 |
3361 __ vdups(V2, V0, 0); | 3012 __ vdups(V2, V0, 0); |
3362 __ vinss(V3, 0, V0, 0); | 3013 __ vinss(V3, 0, V0, 0); |
3363 __ vinss(V3, 1, V1, 0); | 3014 __ vinss(V3, 1, V1, 0); |
3364 __ vinss(V3, 2, V0, 0); | 3015 __ vinss(V3, 2, V0, 0); |
3365 __ vinss(V3, 3, V1, 0); | 3016 __ vinss(V3, 3, V1, 0); |
3366 | 3017 |
3367 __ vcgts(V4, V2, V3); | 3018 __ vcgts(V4, V2, V3); |
3368 | 3019 |
3369 __ vmovrs(R1, V4, 0); | 3020 __ vmovrs(R1, V4, 0); |
3370 __ vmovrs(R2, V4, 1); | 3021 __ vmovrs(R2, V4, 1); |
3371 __ vmovrs(R3, V4, 2); | 3022 __ vmovrs(R3, V4, 2); |
3372 __ vmovrs(R4, V4, 3); | 3023 __ vmovrs(R4, V4, 3); |
3373 | 3024 |
3374 __ addw(R0, R1, Operand(R2)); | 3025 __ addw(R0, R1, Operand(R2)); |
3375 __ addw(R0, R0, Operand(R3)); | 3026 __ addw(R0, R0, Operand(R3)); |
3376 __ addw(R0, R0, Operand(R4)); | 3027 __ addw(R0, R0, Operand(R4)); |
3377 __ ret(); | 3028 __ ret(); |
3378 } | 3029 } |
3379 | 3030 |
3380 | |
3381 ASSEMBLER_TEST_RUN(Vcgts, test) { | 3031 ASSEMBLER_TEST_RUN(Vcgts, test) { |
3382 typedef int64_t (*Int64Return)() DART_UNUSED; | 3032 typedef int64_t (*Int64Return)() DART_UNUSED; |
3383 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 3033 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3384 } | 3034 } |
3385 | 3035 |
3386 | |
3387 ASSEMBLER_TEST_GENERATE(Vcgtd, assembler) { | 3036 ASSEMBLER_TEST_GENERATE(Vcgtd, assembler) { |
3388 __ LoadDImmediate(V0, 42.0); | 3037 __ LoadDImmediate(V0, 42.0); |
3389 __ LoadDImmediate(V1, -42.0); | 3038 __ LoadDImmediate(V1, -42.0); |
3390 | 3039 |
3391 __ vdupd(V2, V0, 0); | 3040 __ vdupd(V2, V0, 0); |
3392 __ vinsd(V3, 0, V0, 0); | 3041 __ vinsd(V3, 0, V0, 0); |
3393 __ vinsd(V3, 1, V1, 0); | 3042 __ vinsd(V3, 1, V1, 0); |
3394 | 3043 |
3395 __ vcgtd(V4, V2, V3); | 3044 __ vcgtd(V4, V2, V3); |
3396 | 3045 |
3397 __ vmovrd(R1, V4, 0); | 3046 __ vmovrd(R1, V4, 0); |
3398 __ vmovrd(R2, V4, 1); | 3047 __ vmovrd(R2, V4, 1); |
3399 | 3048 |
3400 __ add(R0, R1, Operand(R2)); | 3049 __ add(R0, R1, Operand(R2)); |
3401 __ ret(); | 3050 __ ret(); |
3402 } | 3051 } |
3403 | 3052 |
3404 | |
3405 ASSEMBLER_TEST_RUN(Vcgtd, test) { | 3053 ASSEMBLER_TEST_RUN(Vcgtd, test) { |
3406 typedef int64_t (*Int64Return)() DART_UNUSED; | 3054 typedef int64_t (*Int64Return)() DART_UNUSED; |
3407 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 3055 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3408 } | 3056 } |
3409 | 3057 |
3410 | |
3411 ASSEMBLER_TEST_GENERATE(Vcges, assembler) { | 3058 ASSEMBLER_TEST_GENERATE(Vcges, assembler) { |
3412 __ LoadDImmediate(V0, 42.0); | 3059 __ LoadDImmediate(V0, 42.0); |
3413 __ LoadDImmediate(V1, 43.0); | 3060 __ LoadDImmediate(V1, 43.0); |
3414 | 3061 |
3415 __ fcvtsd(V0, V0); | 3062 __ fcvtsd(V0, V0); |
3416 __ fcvtsd(V1, V1); | 3063 __ fcvtsd(V1, V1); |
3417 | 3064 |
3418 __ vdups(V2, V0, 0); | 3065 __ vdups(V2, V0, 0); |
3419 __ vinss(V3, 0, V0, 0); | 3066 __ vinss(V3, 0, V0, 0); |
3420 __ vinss(V3, 1, V1, 0); | 3067 __ vinss(V3, 1, V1, 0); |
3421 __ vinss(V3, 2, V0, 0); | 3068 __ vinss(V3, 2, V0, 0); |
3422 __ vinss(V3, 3, V1, 0); | 3069 __ vinss(V3, 3, V1, 0); |
3423 | 3070 |
3424 __ vcges(V4, V2, V3); | 3071 __ vcges(V4, V2, V3); |
3425 | 3072 |
3426 __ vmovrs(R1, V4, 0); | 3073 __ vmovrs(R1, V4, 0); |
3427 __ vmovrs(R2, V4, 1); | 3074 __ vmovrs(R2, V4, 1); |
3428 __ vmovrs(R3, V4, 2); | 3075 __ vmovrs(R3, V4, 2); |
3429 __ vmovrs(R4, V4, 3); | 3076 __ vmovrs(R4, V4, 3); |
3430 | 3077 |
3431 __ addw(R0, R1, Operand(R2)); | 3078 __ addw(R0, R1, Operand(R2)); |
3432 __ addw(R0, R0, Operand(R3)); | 3079 __ addw(R0, R0, Operand(R3)); |
3433 __ addw(R0, R0, Operand(R4)); | 3080 __ addw(R0, R0, Operand(R4)); |
3434 __ ret(); | 3081 __ ret(); |
3435 } | 3082 } |
3436 | 3083 |
3437 | |
3438 ASSEMBLER_TEST_RUN(Vcges, test) { | 3084 ASSEMBLER_TEST_RUN(Vcges, test) { |
3439 typedef int64_t (*Int64Return)() DART_UNUSED; | 3085 typedef int64_t (*Int64Return)() DART_UNUSED; |
3440 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 3086 EXPECT_EQ(0xfffffffe, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3441 } | 3087 } |
3442 | 3088 |
3443 | |
3444 ASSEMBLER_TEST_GENERATE(Vcged, assembler) { | 3089 ASSEMBLER_TEST_GENERATE(Vcged, assembler) { |
3445 __ LoadDImmediate(V0, 42.0); | 3090 __ LoadDImmediate(V0, 42.0); |
3446 __ LoadDImmediate(V1, 43.0); | 3091 __ LoadDImmediate(V1, 43.0); |
3447 | 3092 |
3448 __ vdupd(V2, V0, 0); | 3093 __ vdupd(V2, V0, 0); |
3449 __ vinsd(V3, 0, V0, 0); | 3094 __ vinsd(V3, 0, V0, 0); |
3450 __ vinsd(V3, 1, V1, 0); | 3095 __ vinsd(V3, 1, V1, 0); |
3451 | 3096 |
3452 __ vcged(V4, V2, V3); | 3097 __ vcged(V4, V2, V3); |
3453 | 3098 |
3454 __ vmovrd(R1, V4, 0); | 3099 __ vmovrd(R1, V4, 0); |
3455 __ vmovrd(R2, V4, 1); | 3100 __ vmovrd(R2, V4, 1); |
3456 | 3101 |
3457 __ add(R0, R1, Operand(R2)); | 3102 __ add(R0, R1, Operand(R2)); |
3458 __ ret(); | 3103 __ ret(); |
3459 } | 3104 } |
3460 | 3105 |
3461 | |
3462 ASSEMBLER_TEST_RUN(Vcged, test) { | 3106 ASSEMBLER_TEST_RUN(Vcged, test) { |
3463 typedef int64_t (*Int64Return)() DART_UNUSED; | 3107 typedef int64_t (*Int64Return)() DART_UNUSED; |
3464 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); | 3108 EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry())); |
3465 } | 3109 } |
3466 | 3110 |
3467 | |
3468 ASSEMBLER_TEST_GENERATE(Vmaxs, assembler) { | 3111 ASSEMBLER_TEST_GENERATE(Vmaxs, assembler) { |
3469 __ LoadDImmediate(V0, 10.5); | 3112 __ LoadDImmediate(V0, 10.5); |
3470 __ LoadDImmediate(V1, 10.0); | 3113 __ LoadDImmediate(V1, 10.0); |
3471 | 3114 |
3472 __ fcvtsd(V0, V0); | 3115 __ fcvtsd(V0, V0); |
3473 __ fcvtsd(V1, V1); | 3116 __ fcvtsd(V1, V1); |
3474 | 3117 |
3475 __ vdups(V2, V0, 0); | 3118 __ vdups(V2, V0, 0); |
3476 __ vinss(V3, 0, V0, 0); | 3119 __ vinss(V3, 0, V0, 0); |
3477 __ vinss(V3, 1, V1, 0); | 3120 __ vinss(V3, 1, V1, 0); |
(...skipping 11 matching lines...) Expand all Loading... |
3489 __ fcvtds(V1, V1); | 3132 __ fcvtds(V1, V1); |
3490 __ fcvtds(V2, V2); | 3133 __ fcvtds(V2, V2); |
3491 __ fcvtds(V3, V3); | 3134 __ fcvtds(V3, V3); |
3492 | 3135 |
3493 __ faddd(V0, V0, V1); | 3136 __ faddd(V0, V0, V1); |
3494 __ faddd(V0, V0, V2); | 3137 __ faddd(V0, V0, V2); |
3495 __ faddd(V0, V0, V3); | 3138 __ faddd(V0, V0, V3); |
3496 __ ret(); | 3139 __ ret(); |
3497 } | 3140 } |
3498 | 3141 |
3499 | |
3500 ASSEMBLER_TEST_RUN(Vmaxs, test) { | 3142 ASSEMBLER_TEST_RUN(Vmaxs, test) { |
3501 typedef double (*DoubleReturn)() DART_UNUSED; | 3143 typedef double (*DoubleReturn)() DART_UNUSED; |
3502 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3144 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3503 } | 3145 } |
3504 | 3146 |
3505 | |
3506 ASSEMBLER_TEST_GENERATE(Vmaxd, assembler) { | 3147 ASSEMBLER_TEST_GENERATE(Vmaxd, assembler) { |
3507 __ LoadDImmediate(V0, 21.0); | 3148 __ LoadDImmediate(V0, 21.0); |
3508 __ LoadDImmediate(V1, 20.5); | 3149 __ LoadDImmediate(V1, 20.5); |
3509 | 3150 |
3510 __ vdupd(V2, V0, 0); | 3151 __ vdupd(V2, V0, 0); |
3511 __ vinsd(V3, 0, V0, 0); | 3152 __ vinsd(V3, 0, V0, 0); |
3512 __ vinsd(V3, 1, V1, 0); | 3153 __ vinsd(V3, 1, V1, 0); |
3513 | 3154 |
3514 __ vmaxd(V4, V2, V3); | 3155 __ vmaxd(V4, V2, V3); |
3515 | 3156 |
3516 __ vinsd(V0, 0, V4, 0); | 3157 __ vinsd(V0, 0, V4, 0); |
3517 __ vinsd(V1, 0, V4, 1); | 3158 __ vinsd(V1, 0, V4, 1); |
3518 | 3159 |
3519 __ faddd(V0, V0, V1); | 3160 __ faddd(V0, V0, V1); |
3520 __ ret(); | 3161 __ ret(); |
3521 } | 3162 } |
3522 | 3163 |
3523 | |
3524 ASSEMBLER_TEST_RUN(Vmaxd, test) { | 3164 ASSEMBLER_TEST_RUN(Vmaxd, test) { |
3525 typedef double (*DoubleReturn)() DART_UNUSED; | 3165 typedef double (*DoubleReturn)() DART_UNUSED; |
3526 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3166 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3527 } | 3167 } |
3528 | 3168 |
3529 | |
3530 ASSEMBLER_TEST_GENERATE(Vmins, assembler) { | 3169 ASSEMBLER_TEST_GENERATE(Vmins, assembler) { |
3531 __ LoadDImmediate(V0, 10.5); | 3170 __ LoadDImmediate(V0, 10.5); |
3532 __ LoadDImmediate(V1, 11.0); | 3171 __ LoadDImmediate(V1, 11.0); |
3533 | 3172 |
3534 __ fcvtsd(V0, V0); | 3173 __ fcvtsd(V0, V0); |
3535 __ fcvtsd(V1, V1); | 3174 __ fcvtsd(V1, V1); |
3536 | 3175 |
3537 __ vdups(V2, V0, 0); | 3176 __ vdups(V2, V0, 0); |
3538 __ vinss(V3, 0, V0, 0); | 3177 __ vinss(V3, 0, V0, 0); |
3539 __ vinss(V3, 1, V1, 0); | 3178 __ vinss(V3, 1, V1, 0); |
(...skipping 11 matching lines...) Expand all Loading... |
3551 __ fcvtds(V1, V1); | 3190 __ fcvtds(V1, V1); |
3552 __ fcvtds(V2, V2); | 3191 __ fcvtds(V2, V2); |
3553 __ fcvtds(V3, V3); | 3192 __ fcvtds(V3, V3); |
3554 | 3193 |
3555 __ faddd(V0, V0, V1); | 3194 __ faddd(V0, V0, V1); |
3556 __ faddd(V0, V0, V2); | 3195 __ faddd(V0, V0, V2); |
3557 __ faddd(V0, V0, V3); | 3196 __ faddd(V0, V0, V3); |
3558 __ ret(); | 3197 __ ret(); |
3559 } | 3198 } |
3560 | 3199 |
3561 | |
3562 ASSEMBLER_TEST_RUN(Vmins, test) { | 3200 ASSEMBLER_TEST_RUN(Vmins, test) { |
3563 typedef double (*DoubleReturn)() DART_UNUSED; | 3201 typedef double (*DoubleReturn)() DART_UNUSED; |
3564 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3202 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3565 } | 3203 } |
3566 | 3204 |
3567 | |
3568 ASSEMBLER_TEST_GENERATE(Vmind, assembler) { | 3205 ASSEMBLER_TEST_GENERATE(Vmind, assembler) { |
3569 __ LoadDImmediate(V0, 21.0); | 3206 __ LoadDImmediate(V0, 21.0); |
3570 __ LoadDImmediate(V1, 21.5); | 3207 __ LoadDImmediate(V1, 21.5); |
3571 | 3208 |
3572 __ vdupd(V2, V0, 0); | 3209 __ vdupd(V2, V0, 0); |
3573 __ vinsd(V3, 0, V0, 0); | 3210 __ vinsd(V3, 0, V0, 0); |
3574 __ vinsd(V3, 1, V1, 0); | 3211 __ vinsd(V3, 1, V1, 0); |
3575 | 3212 |
3576 __ vmind(V4, V2, V3); | 3213 __ vmind(V4, V2, V3); |
3577 | 3214 |
3578 __ vinsd(V0, 0, V4, 0); | 3215 __ vinsd(V0, 0, V4, 0); |
3579 __ vinsd(V1, 0, V4, 1); | 3216 __ vinsd(V1, 0, V4, 1); |
3580 | 3217 |
3581 __ faddd(V0, V0, V1); | 3218 __ faddd(V0, V0, V1); |
3582 __ ret(); | 3219 __ ret(); |
3583 } | 3220 } |
3584 | 3221 |
3585 | |
3586 ASSEMBLER_TEST_RUN(Vmind, test) { | 3222 ASSEMBLER_TEST_RUN(Vmind, test) { |
3587 typedef double (*DoubleReturn)() DART_UNUSED; | 3223 typedef double (*DoubleReturn)() DART_UNUSED; |
3588 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3224 EXPECT_EQ(42.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3589 } | 3225 } |
3590 | 3226 |
3591 | |
3592 ASSEMBLER_TEST_GENERATE(Vsqrts, assembler) { | 3227 ASSEMBLER_TEST_GENERATE(Vsqrts, assembler) { |
3593 __ LoadDImmediate(V0, 64.0); | 3228 __ LoadDImmediate(V0, 64.0); |
3594 __ LoadDImmediate(V1, 49.0); | 3229 __ LoadDImmediate(V1, 49.0); |
3595 | 3230 |
3596 __ fcvtsd(V0, V0); | 3231 __ fcvtsd(V0, V0); |
3597 __ fcvtsd(V1, V1); | 3232 __ fcvtsd(V1, V1); |
3598 | 3233 |
3599 __ veor(V3, V3, V3); | 3234 __ veor(V3, V3, V3); |
3600 __ vinss(V3, 1, V0, 0); | 3235 __ vinss(V3, 1, V0, 0); |
3601 __ vinss(V3, 3, V1, 0); | 3236 __ vinss(V3, 3, V1, 0); |
3602 | 3237 |
3603 __ vsqrts(V4, V3); | 3238 __ vsqrts(V4, V3); |
3604 | 3239 |
3605 __ vinss(V5, 0, V4, 1); | 3240 __ vinss(V5, 0, V4, 1); |
3606 __ vinss(V6, 0, V4, 3); | 3241 __ vinss(V6, 0, V4, 3); |
3607 | 3242 |
3608 __ fcvtds(V5, V5); | 3243 __ fcvtds(V5, V5); |
3609 __ fcvtds(V6, V6); | 3244 __ fcvtds(V6, V6); |
3610 | 3245 |
3611 __ faddd(V0, V5, V6); | 3246 __ faddd(V0, V5, V6); |
3612 __ ret(); | 3247 __ ret(); |
3613 } | 3248 } |
3614 | 3249 |
3615 | |
3616 ASSEMBLER_TEST_RUN(Vsqrts, test) { | 3250 ASSEMBLER_TEST_RUN(Vsqrts, test) { |
3617 typedef double (*DoubleReturn)() DART_UNUSED; | 3251 typedef double (*DoubleReturn)() DART_UNUSED; |
3618 EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3252 EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3619 } | 3253 } |
3620 | 3254 |
3621 | |
3622 ASSEMBLER_TEST_GENERATE(Vsqrtd, assembler) { | 3255 ASSEMBLER_TEST_GENERATE(Vsqrtd, assembler) { |
3623 __ LoadDImmediate(V0, 64.0); | 3256 __ LoadDImmediate(V0, 64.0); |
3624 __ LoadDImmediate(V1, 49.0); | 3257 __ LoadDImmediate(V1, 49.0); |
3625 | 3258 |
3626 __ vinsd(V3, 0, V0, 0); | 3259 __ vinsd(V3, 0, V0, 0); |
3627 __ vinsd(V3, 1, V1, 0); | 3260 __ vinsd(V3, 1, V1, 0); |
3628 | 3261 |
3629 __ vsqrtd(V4, V3); | 3262 __ vsqrtd(V4, V3); |
3630 | 3263 |
3631 __ vinsd(V5, 0, V4, 0); | 3264 __ vinsd(V5, 0, V4, 0); |
3632 __ vinsd(V6, 0, V4, 1); | 3265 __ vinsd(V6, 0, V4, 1); |
3633 | 3266 |
3634 __ faddd(V0, V5, V6); | 3267 __ faddd(V0, V5, V6); |
3635 __ ret(); | 3268 __ ret(); |
3636 } | 3269 } |
3637 | 3270 |
3638 | |
3639 ASSEMBLER_TEST_RUN(Vsqrtd, test) { | 3271 ASSEMBLER_TEST_RUN(Vsqrtd, test) { |
3640 typedef double (*DoubleReturn)() DART_UNUSED; | 3272 typedef double (*DoubleReturn)() DART_UNUSED; |
3641 EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); | 3273 EXPECT_EQ(15.0, EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry())); |
3642 } | 3274 } |
3643 | 3275 |
3644 | |
3645 // This is the same function as in the Simulator. | 3276 // This is the same function as in the Simulator. |
3646 static float arm_recip_estimate(float a) { | 3277 static float arm_recip_estimate(float a) { |
3647 // From the ARM Architecture Reference Manual A2-85. | 3278 // From the ARM Architecture Reference Manual A2-85. |
3648 if (isinf(a) || (fabs(a) >= exp2f(126))) | 3279 if (isinf(a) || (fabs(a) >= exp2f(126))) |
3649 return 0.0; | 3280 return 0.0; |
3650 else if (a == 0.0) | 3281 else if (a == 0.0) |
3651 return kPosInfinity; | 3282 return kPosInfinity; |
3652 else if (isnan(a)) | 3283 else if (isnan(a)) |
3653 return a; | 3284 return a; |
3654 | 3285 |
(...skipping 17 matching lines...) Expand all Loading... |
3672 double estimate = static_cast<double>(s) / 256.0; | 3303 double estimate = static_cast<double>(s) / 256.0; |
3673 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); | 3304 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); |
3674 | 3305 |
3675 // result = sign : result_exp<7:0> : estimate<51:29> | 3306 // result = sign : result_exp<7:0> : estimate<51:29> |
3676 int32_t result_bits = | 3307 int32_t result_bits = |
3677 (a_bits & 0x80000000) | ((result_exp & 0xff) << 23) | | 3308 (a_bits & 0x80000000) | ((result_exp & 0xff) << 23) | |
3678 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); | 3309 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); |
3679 return bit_cast<float, int32_t>(result_bits); | 3310 return bit_cast<float, int32_t>(result_bits); |
3680 } | 3311 } |
3681 | 3312 |
3682 | |
3683 ASSEMBLER_TEST_GENERATE(Vrecpes, assembler) { | 3313 ASSEMBLER_TEST_GENERATE(Vrecpes, assembler) { |
3684 __ LoadDImmediate(V1, 147.0); | 3314 __ LoadDImmediate(V1, 147.0); |
3685 __ fcvtsd(V1, V1); | 3315 __ fcvtsd(V1, V1); |
3686 __ vinss(V2, 0, V1, 0); | 3316 __ vinss(V2, 0, V1, 0); |
3687 __ vinss(V2, 1, V1, 0); | 3317 __ vinss(V2, 1, V1, 0); |
3688 __ vinss(V2, 2, V1, 0); | 3318 __ vinss(V2, 2, V1, 0); |
3689 __ vinss(V2, 3, V1, 0); | 3319 __ vinss(V2, 3, V1, 0); |
3690 __ vrecpes(V0, V2); | 3320 __ vrecpes(V0, V2); |
3691 __ fcvtds(V0, V0); | 3321 __ fcvtds(V0, V0); |
3692 __ ret(); | 3322 __ ret(); |
3693 } | 3323 } |
3694 | 3324 |
3695 | |
3696 ASSEMBLER_TEST_RUN(Vrecpes, test) { | 3325 ASSEMBLER_TEST_RUN(Vrecpes, test) { |
3697 EXPECT(test != NULL); | 3326 EXPECT(test != NULL); |
3698 typedef double (*DoubleReturn)() DART_UNUSED; | 3327 typedef double (*DoubleReturn)() DART_UNUSED; |
3699 float res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3328 float res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3700 EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001); | 3329 EXPECT_FLOAT_EQ(arm_recip_estimate(147.0), res, 0.0001); |
3701 } | 3330 } |
3702 | 3331 |
3703 | |
3704 ASSEMBLER_TEST_GENERATE(Vrecpss, assembler) { | 3332 ASSEMBLER_TEST_GENERATE(Vrecpss, assembler) { |
3705 __ LoadDImmediate(V1, 5.0); | 3333 __ LoadDImmediate(V1, 5.0); |
3706 __ LoadDImmediate(V2, 10.0); | 3334 __ LoadDImmediate(V2, 10.0); |
3707 | 3335 |
3708 __ fcvtsd(V1, V1); | 3336 __ fcvtsd(V1, V1); |
3709 __ fcvtsd(V2, V2); | 3337 __ fcvtsd(V2, V2); |
3710 | 3338 |
3711 __ vrecpss(V0, V1, V2); | 3339 __ vrecpss(V0, V1, V2); |
3712 | 3340 |
3713 __ fcvtds(V0, V0); | 3341 __ fcvtds(V0, V0); |
3714 __ ret(); | 3342 __ ret(); |
3715 } | 3343 } |
3716 | 3344 |
3717 | |
3718 ASSEMBLER_TEST_RUN(Vrecpss, test) { | 3345 ASSEMBLER_TEST_RUN(Vrecpss, test) { |
3719 EXPECT(test != NULL); | 3346 EXPECT(test != NULL); |
3720 typedef double (*DoubleReturn)() DART_UNUSED; | 3347 typedef double (*DoubleReturn)() DART_UNUSED; |
3721 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3348 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3722 EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001); | 3349 EXPECT_FLOAT_EQ(2.0 - 10.0 * 5.0, res, 0.0001); |
3723 } | 3350 } |
3724 | 3351 |
3725 | |
3726 ASSEMBLER_TEST_GENERATE(VRecps, assembler) { | 3352 ASSEMBLER_TEST_GENERATE(VRecps, assembler) { |
3727 __ LoadDImmediate(V0, 1.0 / 10.5); | 3353 __ LoadDImmediate(V0, 1.0 / 10.5); |
3728 __ fcvtsd(V0, V0); | 3354 __ fcvtsd(V0, V0); |
3729 | 3355 |
3730 __ vdups(V1, V0, 0); | 3356 __ vdups(V1, V0, 0); |
3731 | 3357 |
3732 __ VRecps(V2, V1); | 3358 __ VRecps(V2, V1); |
3733 | 3359 |
3734 __ vinss(V0, 0, V2, 0); | 3360 __ vinss(V0, 0, V2, 0); |
3735 __ vinss(V1, 0, V2, 1); | 3361 __ vinss(V1, 0, V2, 1); |
3736 __ vinss(V2, 0, V2, 2); | 3362 __ vinss(V2, 0, V2, 2); |
3737 __ vinss(V3, 0, V2, 3); | 3363 __ vinss(V3, 0, V2, 3); |
3738 | 3364 |
3739 __ fcvtds(V0, V0); | 3365 __ fcvtds(V0, V0); |
3740 __ fcvtds(V1, V1); | 3366 __ fcvtds(V1, V1); |
3741 __ fcvtds(V2, V2); | 3367 __ fcvtds(V2, V2); |
3742 __ fcvtds(V3, V3); | 3368 __ fcvtds(V3, V3); |
3743 | 3369 |
3744 __ faddd(V0, V0, V1); | 3370 __ faddd(V0, V0, V1); |
3745 __ faddd(V0, V0, V2); | 3371 __ faddd(V0, V0, V2); |
3746 __ faddd(V0, V0, V3); | 3372 __ faddd(V0, V0, V3); |
3747 __ ret(); | 3373 __ ret(); |
3748 } | 3374 } |
3749 | 3375 |
3750 | |
3751 ASSEMBLER_TEST_RUN(VRecps, test) { | 3376 ASSEMBLER_TEST_RUN(VRecps, test) { |
3752 typedef double (*DoubleReturn)() DART_UNUSED; | 3377 typedef double (*DoubleReturn)() DART_UNUSED; |
3753 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3378 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3754 EXPECT_FLOAT_EQ(42.0, res, 0.0001); | 3379 EXPECT_FLOAT_EQ(42.0, res, 0.0001); |
3755 } | 3380 } |
3756 | 3381 |
3757 | |
3758 static float arm_reciprocal_sqrt_estimate(float a) { | 3382 static float arm_reciprocal_sqrt_estimate(float a) { |
3759 // From the ARM Architecture Reference Manual A2-87. | 3383 // From the ARM Architecture Reference Manual A2-87. |
3760 if (isinf(a) || (fabs(a) >= exp2f(126))) | 3384 if (isinf(a) || (fabs(a) >= exp2f(126))) |
3761 return 0.0; | 3385 return 0.0; |
3762 else if (a == 0.0) | 3386 else if (a == 0.0) |
3763 return kPosInfinity; | 3387 return kPosInfinity; |
3764 else if (isnan(a)) | 3388 else if (isnan(a)) |
3765 return a; | 3389 return a; |
3766 | 3390 |
3767 uint32_t a_bits = bit_cast<uint32_t, float>(a); | 3391 uint32_t a_bits = bit_cast<uint32_t, float>(a); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3802 double estimate = static_cast<double>(s) / 256.0; | 3426 double estimate = static_cast<double>(s) / 256.0; |
3803 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); | 3427 ASSERT((estimate >= 1.0) && (estimate <= (511.0 / 256.0))); |
3804 | 3428 |
3805 // result = 0 : result_exp<7:0> : estimate<51:29> | 3429 // result = 0 : result_exp<7:0> : estimate<51:29> |
3806 int32_t result_bits = | 3430 int32_t result_bits = |
3807 ((result_exp & 0xff) << 23) | | 3431 ((result_exp & 0xff) << 23) | |
3808 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); | 3432 ((bit_cast<uint64_t, double>(estimate) >> 29) & 0x7fffff); |
3809 return bit_cast<float, int32_t>(result_bits); | 3433 return bit_cast<float, int32_t>(result_bits); |
3810 } | 3434 } |
3811 | 3435 |
3812 | |
3813 ASSEMBLER_TEST_GENERATE(Vrsqrtes, assembler) { | 3436 ASSEMBLER_TEST_GENERATE(Vrsqrtes, assembler) { |
3814 __ LoadDImmediate(V1, 147.0); | 3437 __ LoadDImmediate(V1, 147.0); |
3815 __ fcvtsd(V1, V1); | 3438 __ fcvtsd(V1, V1); |
3816 | 3439 |
3817 __ vrsqrtes(V0, V1); | 3440 __ vrsqrtes(V0, V1); |
3818 | 3441 |
3819 __ fcvtds(V0, V0); | 3442 __ fcvtds(V0, V0); |
3820 __ ret(); | 3443 __ ret(); |
3821 } | 3444 } |
3822 | 3445 |
3823 | |
3824 ASSEMBLER_TEST_RUN(Vrsqrtes, test) { | 3446 ASSEMBLER_TEST_RUN(Vrsqrtes, test) { |
3825 EXPECT(test != NULL); | 3447 EXPECT(test != NULL); |
3826 typedef double (*DoubleReturn)() DART_UNUSED; | 3448 typedef double (*DoubleReturn)() DART_UNUSED; |
3827 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3449 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3828 EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001); | 3450 EXPECT_FLOAT_EQ(arm_reciprocal_sqrt_estimate(147.0), res, 0.0001); |
3829 } | 3451 } |
3830 | 3452 |
3831 | |
3832 ASSEMBLER_TEST_GENERATE(Vrsqrtss, assembler) { | 3453 ASSEMBLER_TEST_GENERATE(Vrsqrtss, assembler) { |
3833 __ LoadDImmediate(V1, 5.0); | 3454 __ LoadDImmediate(V1, 5.0); |
3834 __ LoadDImmediate(V2, 10.0); | 3455 __ LoadDImmediate(V2, 10.0); |
3835 | 3456 |
3836 __ fcvtsd(V1, V1); | 3457 __ fcvtsd(V1, V1); |
3837 __ fcvtsd(V2, V2); | 3458 __ fcvtsd(V2, V2); |
3838 | 3459 |
3839 __ vrsqrtss(V0, V1, V2); | 3460 __ vrsqrtss(V0, V1, V2); |
3840 | 3461 |
3841 __ fcvtds(V0, V0); | 3462 __ fcvtds(V0, V0); |
3842 __ ret(); | 3463 __ ret(); |
3843 } | 3464 } |
3844 | 3465 |
3845 | |
3846 ASSEMBLER_TEST_RUN(Vrsqrtss, test) { | 3466 ASSEMBLER_TEST_RUN(Vrsqrtss, test) { |
3847 EXPECT(test != NULL); | 3467 EXPECT(test != NULL); |
3848 typedef double (*DoubleReturn)() DART_UNUSED; | 3468 typedef double (*DoubleReturn)() DART_UNUSED; |
3849 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3469 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3850 EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0) / 2.0, res, 0.0001); | 3470 EXPECT_FLOAT_EQ((3.0 - 10.0 * 5.0) / 2.0, res, 0.0001); |
3851 } | 3471 } |
3852 | 3472 |
3853 | |
3854 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) { | 3473 ASSEMBLER_TEST_GENERATE(ReciprocalSqrt, assembler) { |
3855 __ LoadDImmediate(V1, 147000.0); | 3474 __ LoadDImmediate(V1, 147000.0); |
3856 __ fcvtsd(V1, V1); | 3475 __ fcvtsd(V1, V1); |
3857 | 3476 |
3858 __ VRSqrts(V0, V1); | 3477 __ VRSqrts(V0, V1); |
3859 | 3478 |
3860 __ fcvtds(V0, V0); | 3479 __ fcvtds(V0, V0); |
3861 __ ret(); | 3480 __ ret(); |
3862 } | 3481 } |
3863 | 3482 |
3864 | |
3865 ASSEMBLER_TEST_RUN(ReciprocalSqrt, test) { | 3483 ASSEMBLER_TEST_RUN(ReciprocalSqrt, test) { |
3866 EXPECT(test != NULL); | 3484 EXPECT(test != NULL); |
3867 typedef double (*DoubleReturn)() DART_UNUSED; | 3485 typedef double (*DoubleReturn)() DART_UNUSED; |
3868 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); | 3486 double res = EXECUTE_TEST_CODE_DOUBLE(DoubleReturn, test->entry()); |
3869 EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001); | 3487 EXPECT_FLOAT_EQ(1.0 / sqrt(147000.0), res, 0.0001); |
3870 } | 3488 } |
3871 | 3489 |
3872 | |
3873 // Called from assembler_test.cc. | 3490 // Called from assembler_test.cc. |
3874 // LR: return address. | 3491 // LR: return address. |
3875 // R0: value. | 3492 // R0: value. |
3876 // R1: growable array. | 3493 // R1: growable array. |
3877 // R2: current thread. | 3494 // R2: current thread. |
3878 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) { | 3495 ASSEMBLER_TEST_GENERATE(StoreIntoObject, assembler) { |
3879 __ SetupDartSP(); | 3496 __ SetupDartSP(); |
3880 __ Push(CODE_REG); | 3497 __ Push(CODE_REG); |
3881 __ Push(THR); | 3498 __ Push(THR); |
3882 __ Push(LR); | 3499 __ Push(LR); |
3883 __ mov(THR, R2); | 3500 __ mov(THR, R2); |
3884 __ StoreIntoObject(R1, FieldAddress(R1, GrowableObjectArray::data_offset()), | 3501 __ StoreIntoObject(R1, FieldAddress(R1, GrowableObjectArray::data_offset()), |
3885 R0); | 3502 R0); |
3886 __ Pop(LR); | 3503 __ Pop(LR); |
3887 __ Pop(THR); | 3504 __ Pop(THR); |
3888 __ Pop(CODE_REG); | 3505 __ Pop(CODE_REG); |
3889 __ RestoreCSP(); | 3506 __ RestoreCSP(); |
3890 __ ret(); | 3507 __ ret(); |
3891 } | 3508 } |
3892 | 3509 |
3893 } // namespace dart | 3510 } // namespace dart |
3894 | 3511 |
3895 #endif // defined(TARGET_ARCH_ARM64) | 3512 #endif // defined(TARGET_ARCH_ARM64) |
OLD | NEW |