OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2012 The Native Client Authors. All rights reserved. | 2 * Copyright (c) 2012 The Native Client Authors. All rights reserved. |
3 * Use of this source code is governed by a BSD-style license that can be | 3 * Use of this source code is governed by a BSD-style license that can be |
4 * found in the LICENSE file. | 4 * found in the LICENSE file. |
5 */ | 5 */ |
6 | 6 |
7 #include "native_client/tests/common/register_set.h" | 7 #include "native_client/tests/common/register_set.h" |
8 | 8 |
9 #include <assert.h> | 9 #include <assert.h> |
10 #include <stddef.h> | 10 #include <stddef.h> |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
80 DEFINE_REG(r7), | 80 DEFINE_REG(r7), |
81 DEFINE_REG(r8), | 81 DEFINE_REG(r8), |
82 DEFINE_REG(r9), | 82 DEFINE_REG(r9), |
83 DEFINE_REG(r10), | 83 DEFINE_REG(r10), |
84 DEFINE_REG(r11), | 84 DEFINE_REG(r11), |
85 DEFINE_REG(r12), | 85 DEFINE_REG(r12), |
86 DEFINE_REG(stack_ptr), | 86 DEFINE_REG(stack_ptr), |
87 DEFINE_REG(lr), | 87 DEFINE_REG(lr), |
88 DEFINE_REG(prog_ctr), | 88 DEFINE_REG(prog_ctr), |
89 DEFINE_REG(cpsr) | 89 DEFINE_REG(cpsr) |
90 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips | |
91 DEFINE_REG(zero), | |
92 DEFINE_REG(at), | |
93 DEFINE_REG(v0), | |
94 DEFINE_REG(v1), | |
95 DEFINE_REG(a0), | |
96 DEFINE_REG(a1), | |
97 DEFINE_REG(a2), | |
98 DEFINE_REG(a3), | |
99 DEFINE_REG(t0), | |
100 DEFINE_REG(t1), | |
101 DEFINE_REG(t2), | |
102 DEFINE_REG(t3), | |
103 DEFINE_REG(t4), | |
104 DEFINE_REG(t5), | |
105 DEFINE_REG(t6), | |
106 DEFINE_REG(t7), | |
107 DEFINE_REG(s0), | |
108 DEFINE_REG(s1), | |
109 DEFINE_REG(s2), | |
110 DEFINE_REG(s3), | |
111 DEFINE_REG(s4), | |
112 DEFINE_REG(s5), | |
113 DEFINE_REG(s6), | |
114 DEFINE_REG(s7), | |
115 DEFINE_REG(t8), | |
116 DEFINE_REG(t9), | |
117 DEFINE_REG(k0), | |
118 DEFINE_REG(k1), | |
119 DEFINE_REG(global_ptr), | |
120 DEFINE_REG(stack_ptr), | |
121 DEFINE_REG(frame_ptr), | |
122 DEFINE_REG(return_addr), | |
123 DEFINE_REG(prog_ctr) | |
90 #else | 124 #else |
91 # error Unsupported architecture | 125 # error Unsupported architecture |
92 #endif | 126 #endif |
93 }; | 127 }; |
94 | 128 |
95 #undef DEFINE_REG | 129 #undef DEFINE_REG |
96 | 130 |
97 /* Flags readable and writable by untrusted code. */ | 131 /* Flags readable and writable by untrusted code. */ |
98 const uint8_t kX86FlagBits[5] = { 0, 2, 6, 7, 11 }; | 132 const uint8_t kX86FlagBits[5] = { 0, 2, 6, 7, 11 }; |
99 /* | 133 /* |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
152 fprintf(stderr, " %s=0x%llx (%lld)\n", | 186 fprintf(stderr, " %s=0x%llx (%lld)\n", |
153 kRegs[regnum].reg_name, value, value); | 187 kRegs[regnum].reg_name, value, value); |
154 } | 188 } |
155 } | 189 } |
156 | 190 |
157 static void RegsNormalizeFlags(struct NaClSignalContext *regs) { | 191 static void RegsNormalizeFlags(struct NaClSignalContext *regs) { |
158 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 | 192 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 |
159 regs->flags &= kX86KnownFlagsMask; | 193 regs->flags &= kX86KnownFlagsMask; |
160 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm | 194 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm |
161 regs->cpsr &= REGS_ARM_USER_CPSR_FLAGS_MASK; | 195 regs->cpsr &= REGS_ARM_USER_CPSR_FLAGS_MASK; |
196 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips | |
197 /* No flags field on MIPS. */ | |
198 UNREFERENCED_PARAMETER(regs); | |
162 #endif | 199 #endif |
163 } | 200 } |
164 | 201 |
165 void RegsAssertEqual(const struct NaClSignalContext *actual, | 202 void RegsAssertEqual(const struct NaClSignalContext *actual, |
166 const struct NaClSignalContext *expected) { | 203 const struct NaClSignalContext *expected) { |
167 int match = 1; | 204 int match = 1; |
168 unsigned int regnum; | 205 unsigned int regnum; |
169 | 206 |
170 /* Make a copy so that we can ignore some of the x86/ARM flags. */ | 207 /* Make a copy so that we can ignore some of the x86/ARM flags. */ |
171 struct NaClSignalContext copy_actual = *actual; | 208 struct NaClSignalContext copy_actual = *actual; |
172 struct NaClSignalContext copy_expected = *expected; | 209 struct NaClSignalContext copy_expected = *expected; |
173 RegsNormalizeFlags(©_actual); | 210 RegsNormalizeFlags(©_actual); |
174 RegsNormalizeFlags(©_expected); | 211 RegsNormalizeFlags(©_expected); |
175 | 212 |
176 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm | 213 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm |
177 /* | 214 /* |
178 * We skip comparison of r9 because it is not supposed to be | 215 * We skip comparison of r9 because it is not supposed to be |
179 * settable or readable by untrusted code. However, for debugging | 216 * settable or readable by untrusted code. However, for debugging |
180 * purposes we still include r9 in register dumps printed by | 217 * purposes we still include r9 in register dumps printed by |
181 * RegsDump(), so r9 remains listed in kRegs[]. | 218 * RegsDump(), so r9 remains listed in kRegs[]. |
182 */ | 219 */ |
183 copy_expected.r9 = copy_actual.r9; | 220 copy_expected.r9 = copy_actual.r9; |
221 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips | |
222 /* | |
223 * For t6 and t7 we expect to hold control flow masks. For t8, which holds TLS | |
Mark Seaborn
2013/03/11 15:54:38
How about: "The registers below are all read-only,
| |
224 * index, we skip comparison. Zero register holds zero allways. All of the | |
Mark Seaborn
2013/03/11 15:54:38
"always"
| |
225 * above named registers are not settable by untrusted code. We also skip | |
226 * comparison for k0 and k1 registers because those are registers reserved for | |
227 * use by interrupt/trap handler and therefore volatile. | |
Mark Seaborn
2013/03/11 15:54:38
Does this mean untrusted code can read the values
| |
228 * However, for debugging purposes we still include those in register dumps | |
229 * printed by RegsDump(), so they remain listed in kRegs[]. | |
230 */ | |
231 copy_expected.zero = 0; | |
232 copy_expected.t6 = NACL_CONTROL_FLOW_MASK; | |
233 copy_expected.t7 = NACL_DATA_FLOW_MASK; | |
234 copy_expected.t8 = copy_actual.t8; | |
235 copy_expected.k0 = copy_actual.k0; | |
236 copy_expected.k1 = copy_actual.k1; | |
184 #endif | 237 #endif |
185 | 238 |
186 for (regnum = 0; regnum < NACL_ARRAY_SIZE(kRegs); regnum++) { | 239 for (regnum = 0; regnum < NACL_ARRAY_SIZE(kRegs); regnum++) { |
187 if (RegsGetRegValue(©_actual, regnum) != | 240 if (RegsGetRegValue(©_actual, regnum) != |
188 RegsGetRegValue(©_expected, regnum)) { | 241 RegsGetRegValue(©_expected, regnum)) { |
189 fprintf(stderr, "Mismatch in register %s\n", kRegs[regnum].reg_name); | 242 fprintf(stderr, "Mismatch in register %s\n", kRegs[regnum].reg_name); |
190 match = 0; | 243 match = 0; |
191 } | 244 } |
192 } | 245 } |
193 if (!match) { | 246 if (!match) { |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
233 regs->r11 = 0; | 286 regs->r11 = 0; |
234 regs->flags = 0; | 287 regs->flags = 0; |
235 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm | 288 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm |
236 regs->r0 = 0; | 289 regs->r0 = 0; |
237 regs->r1 = 0; | 290 regs->r1 = 0; |
238 regs->r2 = 0; | 291 regs->r2 = 0; |
239 regs->r3 = 0; | 292 regs->r3 = 0; |
240 regs->r12 = 0; | 293 regs->r12 = 0; |
241 regs->lr = 0; | 294 regs->lr = 0; |
242 regs->cpsr = 0; | 295 regs->cpsr = 0; |
296 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips | |
297 regs->zero = 0; | |
298 regs->at = 0; | |
299 regs->v0 = 0; | |
300 regs->v1 = 0; | |
301 regs->a0 = 0; | |
302 regs->a1 = 0; | |
303 regs->a2 = 0; | |
304 regs->a3 = 0; | |
305 regs->t0 = 0; | |
306 regs->t1 = 0; | |
307 regs->t2 = 0; | |
308 regs->t3 = 0; | |
309 regs->t4 = 0; | |
310 regs->t5 = 0; | |
311 regs->t9 = 0; | |
312 regs->k0 = 0; | |
313 regs->k1 = 0; | |
314 regs->global_ptr = 0; | |
315 regs->return_addr = 0; | |
243 #else | 316 #else |
244 # error Unsupported architecture | 317 # error Unsupported architecture |
245 #endif | 318 #endif |
246 } | 319 } |
247 | 320 |
248 #if defined(__native_client__) | 321 #if defined(__native_client__) |
249 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 32 | 322 #if NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 32 |
250 | 323 |
251 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { | 324 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { |
252 return ((uint32_t *) regs->stack_ptr)[1]; | 325 return ((uint32_t *) regs->stack_ptr)[1]; |
253 } | 326 } |
254 | 327 |
255 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 64 | 328 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_x86 && NACL_BUILD_SUBARCH == 64 |
256 | 329 |
257 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { | 330 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { |
258 return regs->rdi; | 331 return regs->rdi; |
259 } | 332 } |
260 | 333 |
261 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm | 334 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_arm |
262 | 335 |
263 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { | 336 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { |
264 return regs->r0; | 337 return regs->r0; |
265 } | 338 } |
266 | 339 |
340 #elif NACL_ARCH(NACL_BUILD_ARCH) == NACL_mips | |
341 | |
342 uintptr_t RegsGetArg1(const struct NaClSignalContext *regs) { | |
343 return regs->a0; | |
344 } | |
345 | |
267 #else | 346 #else |
268 # error Unsupported architecture | 347 # error Unsupported architecture |
269 #endif | 348 #endif |
270 #endif | 349 #endif |
OLD | NEW |