ARM: Port r7089 to ARM...

src/arm/assembler-arm.cc

 // Copyright (c) 1994-2006 Sun Microsystems Inc.
 // 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.
 //
@@ skipping 749 matching lines @@
     }
 #endif  // def DEBUG
     return Serializer::enabled();
   } else if (rmode_ == RelocInfo::NONE) {
     return false;
   }
   return true;
 }
 
 
-bool Operand::is_single_instruction() const {
+bool Operand::is_single_instruction(Instr instr) const {
   if (rm_.is_valid()) return true;
-  if (must_use_constant_pool()) return false;
   uint32_t dummy1, dummy2;

[Lasse Reichstein, 2011/03/10 11:58:48]

So the change here is that even if must_use_constant_pool(), it may be a single
instruction if it's just the load, whereas before it was assumed that it was
never a single instruction?

[Søren Thygesen Gjesse, 2011/03/10 12:47:02]

Before this was never used to check a mov instruction, and actually gave the
wrong answer if it was. A mov using the constant pool is always a single
instruction where the mov is transformed to an ldr.

-  return fits_shifter(imm32_, &dummy1, &dummy2, NULL);
+  if (must_use_constant_pool() ||
+      !fits_shifter(imm32_, &dummy1, &dummy2, &instr)) {
+    // The immediate operand cannot be encoded as a shifter operand, or use of
+    // constant pool is required. For a mov instruction not setting the
+    // condition code additional instruction conventions can be used.
+    if ((instr & ~kCondMask) == 13*B21) {  // mov, S not set
+      if (must_use_constant_pool() || !CpuFeatures::IsSupported(ARMv7)) {

[Lasse Reichstein, 2011/03/10 11:58:48]

Could you force using the constant pool for some instructions, to disable the
movw/t sequence?
It might be useful in cases like this?

[Søren Thygesen Gjesse, 2011/03/10 12:47:02]

The only case where movw and movt will be used is when romde is RlocInfo::NONE
or romde is RlocInfo::EXTERNAL_REFERENCE and we are not serializing.

We could, but I think it is better to use movw/movt whenever possible.

+        // mov instruction will be an ldr from constant pool (one instruction).
+        return true;
+      } else {
+        // mov instruction will be a mov or movw followed by movt (two
+        // instructions).
+        return false;
+      }
+    } else {
+      // If this is not a mov or mvn instruction there will always an additional
+      // instructions - either mov or ldr. The mov might actually be two
+      // instructions mov or movw followed by movt so including the actual
+      // instruction two or three instructions will be generated.
+      return false;
+    }
+  } else {
+    // No use of constant pool and the immediate operand can be encoded as a
+    // shifter operand.
+    return true;
+  }
 }
 
 
 void Assembler::addrmod1(Instr instr,
                          Register rn,
                          Register rd,
                          const Operand& x) {
   CheckBuffer();
   ASSERT((instr & ~(kCondMask | kOpCodeMask | S)) == 0);
   if (!x.rm_.is_valid()) {
@@ skipping 1962 matching lines @@
 
   // Since a constant pool was just emitted, move the check offset forward by
   // the standard interval.
   next_buffer_check_ = pc_offset() + kCheckConstInterval;
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_ARM