Small changes to improve test coverage in codegen-ia32.cc.

Review URL: http://codereview.chromium.org/92008

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@1769 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/codegen-ia32.cc

@@ -1274,12 +1274,9 @@ void CodeGenerator::ConstantSmiBinaryOperation(Token::Value op,
                                                     smi_value,
                                                     overwrite_mode);
         __ Set(answer.reg(), Immediate(value));
-        if (operand->is_register()) {
+        // We are in the reversed case so they can't both be Smi constants.
+        ASSERT(operand->is_register());
         __ sub(answer.reg(), Operand(operand->reg()));
-        } else {
-          ASSERT(operand->is_constant());
-          __ sub(Operand(answer.reg()), Immediate(operand->handle()));
-        }
       } else {
         operand->ToRegister();
         frame_->Spill(operand->reg());
@@ -1374,6 +1371,7 @@ void CodeGenerator::ConstantSmiBinaryOperation(Token::Value op,
         operand->ToRegister();
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->enter()->Branch(not_zero, operand, not_taken);
+        if (shift_value != 0) {
           Result answer = allocator()->Allocate();
           ASSERT(answer.is_valid());
           __ mov(answer.reg(), operand->reg());
@@ -1391,6 +1389,10 @@ void CodeGenerator::ConstantSmiBinaryOperation(Token::Value op,
           operand->Unuse();
           deferred->BindExit(&answer);
           frame_->Push(&answer);
+        } else {
+          deferred->BindExit(operand);
+          frame_->Push(operand);
+        }
       }
       break;
     }
@@ -1411,11 +1413,7 @@ void CodeGenerator::ConstantSmiBinaryOperation(Token::Value op,
       deferred->enter()->Branch(not_zero, operand, not_taken);
       frame_->Spill(operand->reg());
       if (op == Token::BIT_AND) {
-        if (int_value == 0) {
-          __ xor_(Operand(operand->reg()), operand->reg());
-        } else {
         __ and_(Operand(operand->reg()), Immediate(value));
-        }
       } else if (op == Token::BIT_XOR) {
         if (int_value != 0) {
           __ xor_(Operand(operand->reg()), Immediate(value));
@@ -5278,9 +5276,9 @@ void DeferredReferenceGetKeyedValue::Generate() {
   ASSERT(value.is_register() && value.reg().is(eax));
   // The delta from the start of the map-compare instruction to the
   // test eax instruction.  We use masm_ directly here instead of the
-  // __ macro because the __ macro sometimes uses macro expansion to turn
-  // into something that can't return a value.  This is encountered when
-  // doing generated code coverage tests.
+  // double underscore macro because the macro sometimes uses macro
+  // expansion to turn into something that can't return a value.  This
+  // is encountered when doing generated code coverage tests.
   int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(patch_site());
   __ test(value.reg(), Immediate(-delta_to_patch_site));
   __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
@@ -5381,7 +5379,9 @@ void Reference::GetValue(TypeofState typeof_state) {
         // Initially, use an invalid map. The map is patched in the IC
         // initialization code.
         __ bind(deferred->patch_site());
-        __ cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
+        // Use masm-> here instead of the double underscore macro since extra
+        // coverage code can interfere with the patching.
+        masm->cmp(FieldOperand(receiver.reg(), HeapObject::kMapOffset),
                Immediate(Factory::null_value()));
         deferred->enter()->Branch(not_equal, &receiver, &key, not_taken);
 

test/mjsunit/constant-folding.js

@@ -192,5 +192,41 @@ function BoolTest() {
 }
 
 
+// Some tests of shifts that get into the corners in terms of coverage.
+// We generate different code for the case where the operand is a constant.
+function ShiftTest() {
+  var x = 123;
+  assertEquals(x, x >> 0);
+  assertEquals(x, x << 0);
+  assertEquals(x, x >>> 0);
+  assertEquals(61, x >> 1);
+  assertEquals(246, x << 1);
+  assertEquals(61, x >>> 1);
+  x = -123;
+  assertEquals(x, x >> 0);
+  assertEquals(x, x << 0);
+  assertEquals(0x10000 * 0x10000 + x, x >>> 0);
+  assertEquals(-62, x >> 1);
+  assertEquals(-246, x << 1);
+  assertEquals(0x10000 * 0x8000 - 62, x >>> 1);
+  // Answer is non-Smi so the subtraction is not folded in the code
+  // generator.
+  assertEquals(-0x40000001, -0x3fffffff - 2);
+
+  x = 123;
+  assertEquals(0, x & 0);
+
+  // Answer is non-smi and lhs of << is a temporary heap number that we can
+  // overwrite.
+  x = 123.0001;
+  assertEquals(1073741824, (x * x) << 30);
+  x = 123;
+  // Answer is non-smi and lhs of << is a temporary heap number that we think
+  // we can overwrite (but we can't because it's a Smi).
+  assertEquals(1073741824, (x * x) << 30);
+}
+
+
 test();
 BoolTest();
+ShiftTest();

test/mjsunit/keyed-ic.js

@@ -144,6 +144,35 @@ runTest = function() {
 runTest();
 
 
+// ----------------------------------------------------------------------
+// Indexed access.
+// ----------------------------------------------------------------------
+runTest = function() {
+  var o = [ 42, 43 ];
+
+  var initial_X = 0;
+  var X = initial_X;
+  var Y = 1;
+
+  function fieldTest(change_index) {
+    for (var i = 0; i < 10; i++) {
+      var property = o[X];
+      if (i <= change_index) {
+        assertEquals(42, property);
+      } else {
+        assertEquals(43, property);
+      }
+      if (i == change_index) X = Y;
+    }
+    X = initial_X;
+  };
+
+  for (var i = 0; i < 10; i++) fieldTest(i);
+}
+
+runTest();
+
+
 // ----------------------------------------------------------------------
 // Constant function access.
 // ----------------------------------------------------------------------