Support unaligned integer loads on ARM and MIPS.

runtime/vm/assembler_mips_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_MIPS)
 
 #include "vm/assembler.h"
 #include "vm/cpu.h"
 #include "vm/os.h"
@@ skipping 302 matching lines @@
   __ jr(RA);
 }
 
 
 ASSEMBLER_TEST_RUN(Lw, test) {
   typedef int (*SimpleCode)() DART_UNUSED;
   EXPECT_EQ(-1, EXECUTE_TEST_CODE_INT32(SimpleCode, test->entry()));
 }
 
 
+ASSEMBLER_TEST_GENERATE(LoadHalfWordUnaligned, assembler) {
+  __ LoadHalfWordUnaligned(V0, A0, TMP);
+  __ jr(RA);
+}
+
+
+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(V0, A0, TMP);
+  __ jr(RA);
+}
+
+
+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(A1, 0xABCD);
+  __ StoreWordUnaligned(A1, A0, TMP);
+  __ mov(V0, A1);
+  __ jr(RA);
+}
+
+
+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(V0, A0, TMP);
+  __ jr(RA);
+}
+
+
+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(A1, 0x12345678);
+  __ StoreWordUnaligned(A1, A0, TMP);
+  __ mov(V0, A1);
+  __ jr(RA);
+}
+
+
+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(Lui, assembler) {
   __ lui(V0, Immediate(42));
   __ jr(RA);
 }
 
 
 ASSEMBLER_TEST_RUN(Lui, test) {
   typedef int (*SimpleCode)() DART_UNUSED;
   EXPECT_EQ(42 << 16, EXECUTE_TEST_CODE_INT32(SimpleCode, test->entry()));
 }
@@ skipping 1828 matching lines @@
 ASSEMBLER_TEST_RUN(Semaphore, test) {
   EXPECT(test != NULL);
   typedef int (*Semaphore)() DART_UNUSED;
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INT32(Semaphore, test->entry()));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_MIPS