ARM optimize loading of immediates.

test/cctest/test-assembler-arm.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 265 matching lines @@
     t.b = 2.75;
     t.c = 17.17;
     Object* dummy = CALL_GENERATED_CODE(f, &t, 0, 0, 0, 0);
     USE(dummy);
     CHECK_EQ(4.25, t.c);
     CHECK_EQ(4.25, t.b);
     CHECK_EQ(1.5, t.a);
   }
 }
 
+
+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 __