Support unaligned integer loads on ARM and MIPS.

runtime/vm/assembler_arm64_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_ARM64)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
@@ skipping 1666 matching lines @@
   __ ret();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadImmediateMedNeg4, test) {
   typedef int64_t (*Int64Return)() DART_UNUSED;
   EXPECT_EQ(-0x12341234, EXECUTE_TEST_CODE_INT64(Int64Return, test->entry()));
 }
 
 
+ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) {
+  __ LoadUnaligned(R1, R0, TMP, kHalfword);
+  __ mov(R0, R1);
+  __ ret();
+}
+
+
+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) {
+  __ LoadUnaligned(R1, R0, TMP, kUnsignedHalfword);
+  __ mov(R0, R1);
+  __ ret();
+}
+
+
+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);
+  __ StoreUnaligned(R1, R0, TMP, kHalfword);
+  __ mov(R0, R1);
+  __ ret();
+}
+
+
+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) {
+  __ LoadUnaligned(R1, R0, TMP, kUnsignedWord);
+  __ mov(R0, R1);
+  __ ret();
+}
+
+
+ASSEMBLER_TEST_RUN(LoadWordUnaligned, test) {
+  EXPECT(test != NULL);
+  typedef int32_t (*LoadWordUnaligned)(intptr_t) DART_UNUSED;
+  uint8_t buffer[8] = {
+    0x12, 0x34, 0x56, 0x78,
+    0x9A, 0xBC, 0xDE, 0xF0
+  };
+
+  EXPECT_EQ(static_cast<int32_t>(0x78563412),
+            EXECUTE_TEST_CODE_INT32_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[0])));
+  EXPECT_EQ(static_cast<int32_t>(0x9A785634),
+            EXECUTE_TEST_CODE_INT32_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[1])));
+  EXPECT_EQ(static_cast<int32_t>(0xBC9A7856),
+            EXECUTE_TEST_CODE_INT32_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[2])));
+  EXPECT_EQ(static_cast<int32_t>(0xDEBC9A78),
+            EXECUTE_TEST_CODE_INT32_INTPTR(
+                LoadWordUnaligned,
+                test->entry(),
+                reinterpret_cast<intptr_t>(&buffer[3])));
+}
+
+
+ASSEMBLER_TEST_GENERATE(StoreWordUnaligned, assembler) {
+  __ LoadImmediate(R1, 0x12345678);
+  __ StoreUnaligned(R1, R0, TMP, kUnsignedWord);
+  __ mov(R0, R1);
+  __ ret();
+}
+
+
+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]);
+}
+
+
 static void EnterTestFrame(Assembler* assembler) {
   __ EnterFrame(0);
   __ Push(CODE_REG);
   __ Push(THR);
   __ TagAndPushPP();
   __ ldr(CODE_REG, Address(R0, VMHandles::kOffsetOfRawPtrInHandle));
   __ mov(THR, R1);
   __ LoadPoolPointer(PP);
 }
 
@@ skipping 1931 matching lines @@
   __ Pop(LR);
   __ Pop(THR);
   __ Pop(CODE_REG);
   __ RestoreCSP();
   __ ret();
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_ARCH_ARM64)