Support unaligned integer loads on ARM and MIPS.

runtime/vm/assembler_arm_test.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
@@ skipping 79 matching lines @@
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediate, test) {
   EXPECT(test != NULL);
   typedef int (*LoadImmediate)() DART_UNUSED;
   EXPECT_EQ(0x12345678, EXECUTE_TEST_CODE_INT32(LoadImmediate, test->entry()));
 }
 
 
+ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) {
+  __ LoadHalfWordUnaligned(R1, R0, TMP);
+  __ mov(R0, Operand(R1));
+  __ bx(LR);
+}
+
+
+ASSEMBLER_TEST_RUN(LoadHalfWordUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef intptr_t (*LoadHalfWordUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[4] = {
+    0x89, 0xAB, 0xCD, 0xEF,
+  };
+
+  EXPECT_EQ(static_cast<int16_t>(static_cast<uint16_t>(0xAB89)),
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadHalfWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(static_cast<int16_t>(static_cast<uint16_t>(0xCDAB)),
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadHalfWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+}
+
+
+ASSEMBLER_TEST_GENERATE(LoadHalfWordUnsignedUnaligned, assembler) {
+  __ LoadHalfWordUnsignedUnaligned(R1, R0, TMP);
+  __ mov(R0, Operand(R1));
+  __ bx(LR);
+}
+
+
+ASSEMBLER_TEST_RUN(LoadHalfWordUnsignedUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef intptr_t (*LoadHalfWordUnsignedUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[4] = {
+    0x89, 0xAB, 0xCD, 0xEF,
+  };
+
+  EXPECT_EQ(0xAB89,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadHalfWordUnsignedUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(0xCDAB,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadHalfWordUnsignedUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+}
+
+
+ASSEMBLER_TEST_GENERATE(StoreHalfWordUnaligned, assembler) {
+  __ LoadImmediate(R1, 0xABCD);
+  __ StoreWordUnaligned(R1, R0, TMP);
+  __ mov(R0, Operand(R1));
+  __ bx(LR);
+}
+
+
+ASSEMBLER_TEST_RUN(StoreHalfWordUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef intptr_t (*StoreHalfWordUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[4] = {
+    0, 0, 0, 0,
+  };
+
+  EXPECT_EQ(0xABCD,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreHalfWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(0xCD, buffer[0]);
+  EXPECT_EQ(0xAB, buffer[1]);
+  EXPECT_EQ(0, buffer[2]);
+
+  EXPECT_EQ(0xABCD,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreHalfWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_EQ(0xCD, buffer[1]);
+  EXPECT_EQ(0xAB, buffer[2]);
+  EXPECT_EQ(0, buffer[3]);
+}
+
+
+ASSEMBLER_TEST_GENERATE(LoadWordUnaligned, assembler) {
+  __ LoadWordUnaligned(R1, R0, TMP);
+  __ mov(R0, Operand(R1));
+  __ bx(LR);
+}
+
+
+ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef intptr_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[8] = {
+    0x12, 0x34, 0x56, 0x78,
+    0x9A, 0xBC, 0xDE, 0xF0
+  };
+
+  EXPECT_EQ(0x78563412,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(0x9A785634,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_EQ(0xBC9A7856,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[2])));
+  EXPECT_EQ(0xDEBC9A78,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[3])));
+}
+
+
+ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) {
+  __ LoadImmediate(R1, 0x12345678);
+  __ StoreWordUnaligned(R1, R0, TMP);
+  __ mov(R0, Operand(R1));
+  __ bx(LR);
+}
+
+
+ASSEMBLER_TEST_RUN(StoreWordUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef intptr_t (*StoreWordUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[8] = {
+    0, 0, 0, 0,
+    0, 0, 0, 0
+  };
+
+  EXPECT_EQ(0x12345678,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(0x78, buffer[0]);
+  EXPECT_EQ(0x56, buffer[1]);
+  EXPECT_EQ(0x34, buffer[2]);
+  EXPECT_EQ(0x12, buffer[3]);
+
+  EXPECT_EQ(0x12345678,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_EQ(0x78, buffer[1]);
+  EXPECT_EQ(0x56, buffer[2]);
+  EXPECT_EQ(0x34, buffer[3]);
+  EXPECT_EQ(0x12, buffer[4]);
+
+  EXPECT_EQ(0x12345678,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[2])));
+  EXPECT_EQ(0x78, buffer[2]);
+  EXPECT_EQ(0x56, buffer[3]);
+  EXPECT_EQ(0x34, buffer[4]);
+  EXPECT_EQ(0x12, buffer[5]);
+
+  EXPECT_EQ(0x12345678,
+            EXECUTE_TEST_CODE_INTPTR_INTPTR(
+                StoreWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[3])));
+  EXPECT_EQ(0x78, buffer[3]);
+  EXPECT_EQ(0x56, buffer[4]);
+  EXPECT_EQ(0x34, buffer[5]);
+  EXPECT_EQ(0x12, buffer[6]);
+}
+
+
 ASSEMBLER_TEST_GENERATE(Vmov, assembler) {
   if (TargetCPUFeatures::vfp_supported()) {
     __ mov(R3, Operand(43));
     __ mov(R1, Operand(41));
     __ vmovsrr(S1, R1, R3);  // S1:S2 = 41:43
     __ vmovs(S0, S2);  // S0 = S2, S0:S1 == 43:41
     __ vmovd(D2, D0);  // D2 = D0, S4:S5 == 43:41
     __ vmovrs(R3, S5);  // R3 = S5, R3 == 41
     __ vmovrrs(R1, R2, S4);  // R1:R2 = S4:S5, R1:R2 == 43:41
     __ vmovdrr(D3, R3, R2);  // D3 = R3:R2, S6:S7 == 41:41
@@ skipping 3847 matching lines @@
   __ StoreIntoObject(R1,
                      FieldAddress(R1, GrowableObjectArray::data_offset()),
                      R0);
   __ PopList((1 << LR) | (1 << THR));
   __ Ret();
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM