Change BKPT and UDF encodings on ARM.

tests/dynamic_code_loading/dynamic_load_test.c

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "native_client/tests/dynamic_code_loading/dynamic_load_test.h"
 
 #include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/mman.h>
 
 #include <nacl/nacl_dyncode.h>
 
+#include "native_client/src/include/arm_sandbox.h"
 #include "native_client/tests/dynamic_code_loading/dynamic_segment.h"
 #include "native_client/tests/dynamic_code_loading/templates.h"
 #include "native_client/tests/inbrowser_test_runner/test_runner.h"
 
 #if defined(__x86_64__)
 /* On x86-64, template functions do not fit in 32-byte buffers */
 #define BUF_SIZE 64
 #elif defined(__i386__) || defined(__arm__)
 #define BUF_SIZE 32
 #else
@@ skipping 47 matching lines @@
   fill_int32(data, size, 0xe1a00000); /* NOP (MOV r0, r0) */
 #else
 # error "Unknown arch"
 #endif
 }
 
 void fill_hlts(uint8_t *data, size_t size) {
 #if defined(__i386__) || defined(__x86_64__)
   memset(data, 0xf4, size); /* HLTs */
 #elif defined(__arm__)
-  fill_int32(data, size, 0xe1266676); /* BKPT 0x6666 */
+  fill_int32(data, size, NACL_INSTR_HALT_FILL);
 #else
 # error "Unknown arch"
 #endif
 }
 
 /*
  * Getting the assembler to pad our code fragments in templates.S is
  * awkward because we have to output them in data mode, in which the
  * assembler wants to output zeroes instead of NOPs for padding.
  */
@@ skipping 382 matching lines @@
   rc = nacl_dyncode_delete(load_addr + NACL_BUNDLE_SIZE,
                            sizeof(buf) - NACL_BUNDLE_SIZE);
   assert(rc == -1);
   assert(errno == EFAULT);
   /* The correct range should work, though. */
   rc = nacl_dyncode_delete(load_addr, sizeof(buf));
   assert(rc == 0);
 }
 
 void check_region_is_filled_with_hlts(const char *data, size_t size) {
-  uint8_t halts[] =
+  uint8_t halts[] = {
 #if defined(__i386__) || defined(__x86_64__)
-    { 0xf4 }; /* HLT */
+    0xf4 /* HLT */
 #elif defined(__arm__)
-    { 0x76, 0x66, 0x26, 0xe1 }; /* 0xe1266676 - BKPT 0x6666 */
+    (NACL_INSTR_HALT_FILL >>  0) & 0xFF,

[Mark Seaborn, 2012/10/18 22:05:30]

You can just do:

#if x86...
uint8_t halts = 0xf4;
#if arm...
uint32_t halts = NACL_INSTR_HALT_FILL;
#else ...

since we just use memcmp() below.

+    (NACL_INSTR_HALT_FILL >>  8) & 0xFF,
+    (NACL_INSTR_HALT_FILL >> 16) & 0xFF,
+    (NACL_INSTR_HALT_FILL >> 24) & 0xFF
 #else
 # error "Unknown arch"
 #endif
+  };
   const char *ptr;
   for (ptr = data; ptr < data + size; ptr += sizeof(halts)) {
     assert(memcmp(ptr, halts, sizeof(halts)) == 0);
   }
 }
 
 /*
  * Check that regions surrounding the region we load code into are
  * correctly filled with halt instructions.  Loading code causes the
  * pages to become allocated, and unused parts of these pages should
@@ skipping 92 matching lines @@
 
   /* Test again to make sure we didn't run out of space. */
   RUN_TEST(test_loading_code);
 
   return 0;
 }
 
 int main() {
   return RunTests(TestMain);
 }