ARM optimize loading of immediates.

test/cctest/test-assembler-arm.cc

Index: test/cctest/test-assembler-arm.cc
diff --git a/test/cctest/test-assembler-arm.cc b/test/cctest/test-assembler-arm.cc
index 459b8624c082bd758dd108d6be93a648288a46e9..09253be7adcb1a6ce839304ec4f68b4ed976b6ab 100644
--- a/test/cctest/test-assembler-arm.cc
+++ b/test/cctest/test-assembler-arm.cc
@@ -283,4 +283,126 @@ TEST(4) {
   }
 }
 
+
+static void TestImmediate(uint32_t imm) {
+  v8::HandleScope scope;
+
+  // Each section uses Operand(imm) and should end with imm in r2.
+  // If not, we exit with the number of the test that failed.
+  Assembler assm(NULL, 0);
+  Label done;
+  __ eor(r3, r3, Operand(r3));
+  __ mvn(r3, Operand(r3));  // Set all bits in r3. Use leading zeros as counter.
+  // 1. MOV.
+  __ mov(r3, Operand(r3, LSR, 1));  // Count without using immediate.
+  __ mov(r2, Operand(imm));
+  __ cmp(r2, Operand(r0));
+  __ b(ne, &done);
+  // 2. MVN.
+  __ mov(r3, Operand(r3, LSR, 1));
+  __ mvn(r2, Operand(imm));  // Load negated
+  __ mvn(r2, Operand(r2));  // Negate back.
+  __ cmp(r2, Operand(r0));
+  __ b(ne, &done);
+  // 3. ADD.
+  __ mov(r3, Operand(r3, LSR, 1));
+  __ eor(r2, r2, Operand(r2));
+  __ add(r2, r2, Operand(imm));
+  __ cmp(r2, Operand(r0));
+  __ b(ne, &done);
+  // 4. AND.
+  __ mov(r3, Operand(r3, LSR, 1));
+  __ eor(r2, r2, Operand(r2));
+  __ mvn(r2, Operand(r2));
+  __ and_(r2, r2, Operand(imm));
+  __ cmp(r2, Operand(r0));
+  __ b(ne, &done);
+  // 5. BIC
+  __ mov(r3, Operand(r3, LSR, 1));
+  // Set all bits, clear the bits in imm, then flip all bits.
+  __ eor(r2, r2, Operand(r2));
+  __ mvn(r2, Operand(r2));
+  __ bic(r2, r2, Operand(imm));
+  __ mvn(r2, Operand(r2));
+  __ cmp(r2, Operand(r0));
+  __ b(ne, &done);
+    // Put more tests here.
+
+  // Reset counter to zero.
+  __ eor(r3, r3, Operand(r3));
+  __ mvn(r3, Operand(r3));
+  __ bind(&done);
+  __ clz(r0, r3);
+  __ str(r2, MemOperand(r1));
+  __ mov(pc, lr);
+
+  CodeDesc desc;
+  assm.GetCode(&desc);
+  Object* code = Heap::CreateCode(desc,
+                                  NULL,
+                                  Code::ComputeFlags(Code::STUB),
+                                  Handle<Object>(Heap::undefined_value()));
+  F2 f = FUNCTION_CAST<F2>(Code::cast(code)->entry());
+  int32_t bad_result = imm;
+  int32_t res = reinterpret_cast<int32_t >(
+      CALL_GENERATED_CODE(f, imm,
+                          reinterpret_cast<int32_t>(&bad_result), 0, 0, 0));
+  if (res != 0) {
+#ifdef DEBUG
+    Code::cast(code)->Print();
+#endif
+    printf("Test %d.\n", res);
+  }
+  CHECK_EQ(imm, bad_result);
+}
+
+
+TEST(Immediates) {
+  InitializeVM();
+
+  TestImmediate(0);
+  TestImmediate(~0);
+  for (int i = 0; i < 32; i++) {
+    TestImmediate(1u << i);
+    TestImmediate(~(1u << i));
+  }
+  for (int i = 0; i <= 25; i++) {
+    TestImmediate(65u << i);
+    TestImmediate(~(65u << i));
+  }
+  for (int i = 0; i <= 24; i++) {
+    TestImmediate(255u << i);
+    TestImmediate(~(255u << i));
+  }
+
+  for (int i = 0; i <= 16; i++) {
+    for (int j = i + 8; j <= 24 ; j++) {
+      TestImmediate((255u << i) | (255u << j));
+    }
+  }
+  // Wrapped.
+  for (int i = 1; i <= 7; i++) {
+    TestImmediate((0x255u >> i) | (0x255u << (32 - i)));
+  }
+  for (int i = 1; i <= 7; i++) {
+    for (int j = 8 - i; j < 24 + i; j++) {
+      TestImmediate((0x255u >> i) | (0x255u << (32 - i)) | (255u << j));
+    }
+  }
+  TestImmediate(0x55555555u);
+  TestImmediate(0xAAAAAAAAu);
+  TestImmediate(0x33333333u);
+  TestImmediate(0xCCCCCCCCu);
+  TestImmediate(0x0F0F0F0Fu);
+  TestImmediate(0x00F0F0F0u);
+  TestImmediate(0xF00FF00Fu);
+  TestImmediate(0xFF00FF00u);
+  TestImmediate(0x0FF00FF0u);
+  TestImmediate(0x00FF00FFu);
+  TestImmediate(0xFFFF0000u);
+  TestImmediate(0x00FFFF00u);
+  TestImmediate(0x0000FFFFu);
+  TestImmediate(0xFF0000FFu);
+}
+
 #undef __