Add debug code assertions where we expect smi inputs.

src/ia32/codegen-ia32.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 814 matching lines @@
   Comment cmnt(masm_, "[ ToBoolean");
 
   // The value to convert should be popped from the frame.
   Result value = frame_->Pop();
   value.ToRegister();
 
   if (value.is_integer32()) {  // Also takes Smi case.
     Comment cmnt(masm_, "ONLY_INTEGER_32");
     if (FLAG_debug_code) {
       Label ok;
-      __ AbortIfNotNumber(value.reg(), "ToBoolean operand is not a number.");
+      __ AbortIfNotNumber(value.reg());
       __ test(value.reg(), Immediate(kSmiTagMask));
       __ j(zero, &ok);
       __ fldz();
       __ fld_d(FieldOperand(value.reg(), HeapNumber::kValueOffset));
       __ FCmp();
       __ j(not_zero, &ok);
       __ Abort("Smi was wrapped in HeapNumber in output from bitop");
       __ bind(&ok);
     }
     // In the integer32 case there are no Smis hidden in heap numbers, so we
     // need only test for Smi zero.
     __ test(value.reg(), Operand(value.reg()));
     dest->false_target()->Branch(zero);
     value.Unuse();
     dest->Split(not_zero);
   } else if (value.is_number()) {
     Comment cmnt(masm_, "ONLY_NUMBER");
     // Fast case if NumberInfo indicates only numbers.
     if (FLAG_debug_code) {
-      __ AbortIfNotNumber(value.reg(), "ToBoolean operand is not a number.");
+      __ AbortIfNotNumber(value.reg());
     }
     // Smi => false iff zero.
     ASSERT(kSmiTag == 0);
     __ test(value.reg(), Operand(value.reg()));
     dest->false_target()->Branch(zero);
     __ test(value.reg(), Immediate(kSmiTagMask));
     dest->true_target()->Branch(zero);
     __ fldz();
     __ fld_d(FieldOperand(value.reg(), HeapNumber::kValueOffset));
     __ FCmp();
@@ skipping 165 matching lines @@
                Factory::heap_number_map());
         __ j(not_equal, &call_runtime);
       }
       __ movdbl(xmm0, FieldOperand(left_, HeapNumber::kValueOffset));
       if (mode_ == OVERWRITE_LEFT) {
         __ mov(dst_, left_);
       }
       __ jmp(&load_right);
 
       __ bind(&left_smi);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(left_);
     }
     __ SmiUntag(left_);
     __ cvtsi2sd(xmm0, Operand(left_));
     __ SmiTag(left_);
     if (mode_ == OVERWRITE_LEFT) {
       Label alloc_failure;
       __ push(left_);
       __ AllocateHeapNumber(dst_, left_, no_reg, &after_alloc_failure);
       __ pop(left_);
     }
@@ skipping 12 matching lines @@
         __ mov(dst_, right_);
       } else if (mode_ == NO_OVERWRITE) {
         Label alloc_failure;
         __ push(left_);
         __ AllocateHeapNumber(dst_, left_, no_reg, &after_alloc_failure);
         __ pop(left_);
       }
       __ jmp(&do_op);
 
       __ bind(&right_smi);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(right_);
     }
     __ SmiUntag(right_);
     __ cvtsi2sd(xmm1, Operand(right_));
     __ SmiTag(right_);
     if (mode_ == OVERWRITE_RIGHT || mode_ == NO_OVERWRITE) {
       Label alloc_failure;
       __ push(left_);
       __ AllocateHeapNumber(dst_, left_, no_reg, &after_alloc_failure);
       __ pop(left_);
     }
@@ skipping 485 matching lines @@
     DeferredInlineBinaryOperation* deferred =
         new DeferredInlineBinaryOperation(op,
                                           answer.reg(),
                                           left->reg(),
                                           ecx,
                                           left->number_info(),
                                           right->number_info(),
                                           overwrite_mode);
 
     Label do_op, left_nonsmi;
-    // if right is a smi we make a fast case if left is either a smi
+    // If right is a smi we make a fast case if left is either a smi
     // or a heapnumber.
     if (CpuFeatures::IsSupported(SSE2) && right->number_info().IsSmi()) {
       CpuFeatures::Scope use_sse2(SSE2);
       __ mov(answer.reg(), left->reg());
       // Fast case - both are actually smis.
       if (!left->number_info().IsSmi()) {
         __ test(answer.reg(), Immediate(kSmiTagMask));
         __ j(not_zero, &left_nonsmi);
+      } else {
+        if (FLAG_debug_code) __ AbortIfNotSmi(left->reg());
       }
+      if (FLAG_debug_code) __ AbortIfNotSmi(right->reg());
       __ SmiUntag(answer.reg());
       __ jmp(&do_op);
 
       __ bind(&left_nonsmi);
       // Branch if not a heapnumber.
       __ cmp(FieldOperand(answer.reg(), HeapObject::kMapOffset),
              Factory::heap_number_map());
       deferred->Branch(not_equal);
 
       // Load integer value into answer register using truncation.
@@ skipping 398 matching lines @@
         deferred = new DeferredInlineSmiAdd(operand->reg(),
                                             operand->number_info(),
                                             smi_value,
                                             overwrite_mode);
       }
       __ add(Operand(operand->reg()), Immediate(value));
       deferred->Branch(overflow);
       if (!operand->number_info().IsSmi()) {
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->Branch(not_zero);
+      } else {
+        if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
       }
       deferred->BindExit();
       answer = *operand;
       break;
     }
 
     case Token::SUB: {
       DeferredCode* deferred = NULL;
       if (reversed) {
         // The reversed case is only hit when the right operand is not a
@@ skipping 17 matching lines @@
         deferred = new DeferredInlineSmiSub(operand->reg(),
                                             operand->number_info(),
                                             smi_value,
                                             overwrite_mode);
         __ sub(Operand(operand->reg()), Immediate(value));
       }
       deferred->Branch(overflow);
       if (!operand->number_info().IsSmi()) {
         __ test(answer.reg(), Immediate(kSmiTagMask));
         deferred->Branch(not_zero);
+      } else {
+        if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
       }
       deferred->BindExit();
       operand->Unuse();
       break;
     }
 
     case Token::SAR:
       if (reversed) {
         Result constant_operand(value);
         answer = LikelySmiBinaryOperation(op, &constant_operand, operand,
@@ skipping 13 matching lines @@
                                              smi_value,
                                              overwrite_mode);
           __ test(operand->reg(), Immediate(kSmiTagMask));
           deferred->Branch(not_zero);
           if (shift_value > 0) {
             __ sar(operand->reg(), shift_value);
             __ and_(operand->reg(), ~kSmiTagMask);
           }
           deferred->BindExit();
         } else {
+          if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
           if (shift_value > 0) {
             __ sar(operand->reg(), shift_value);
             __ and_(operand->reg(), ~kSmiTagMask);
           }
         }
         answer = *operand;
       }
       break;
 
     case Token::SHR:
@@ skipping 11 matching lines @@
         DeferredInlineSmiOperation* deferred =
             new DeferredInlineSmiOperation(op,
                                            answer.reg(),
                                            operand->reg(),
                                            operand->number_info(),
                                            smi_value,
                                            overwrite_mode);
         if (!operand->number_info().IsSmi()) {
           __ test(operand->reg(), Immediate(kSmiTagMask));
           deferred->Branch(not_zero);
+        } else {
+          if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
         }
         __ mov(answer.reg(), operand->reg());
         __ SmiUntag(answer.reg());
         __ shr(answer.reg(), shift_value);
         // A negative Smi shifted right two is in the positive Smi range.
         if (shift_value < 2) {
           __ test(answer.reg(), Immediate(0xc0000000));
           deferred->Branch(not_zero);
         }
         operand->Unuse();
@@ skipping 28 matching lines @@
             new DeferredInlineSmiOperationReversed(op,
                                                    answer.reg(),
                                                    smi_value,
                                                    right.reg(),
                                                    right.number_info(),
                                                    overwrite_mode);
         __ mov(answer.reg(), Immediate(int_value));
         __ sar(ecx, kSmiTagSize);
         if (!right.number_info().IsSmi()) {
           deferred->Branch(carry);
+        } else {
+          if (FLAG_debug_code) __ AbortIfNotSmi(right.reg());
         }
         __ shl_cl(answer.reg());
         __ cmp(answer.reg(), 0xc0000000);
         deferred->Branch(sign);
         __ SmiTag(answer.reg());
 
         deferred->BindExit();
       } else {
         // Only the least significant 5 bits of the shift value are used.
         // In the slow case, this masking is done inside the runtime call.
@@ skipping 20 matching lines @@
           DeferredInlineSmiOperation* deferred =
               new DeferredInlineSmiOperation(op,
                                              answer.reg(),
                                              operand->reg(),
                                              operand->number_info(),
                                              smi_value,
                                              overwrite_mode);
           if (!operand->number_info().IsSmi()) {
             __ test(operand->reg(), Immediate(kSmiTagMask));
             deferred->Branch(not_zero);
+          } else {
+            if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
           }
           __ mov(answer.reg(), operand->reg());
           ASSERT(kSmiTag == 0);  // adjust code if not the case
           // We do no shifts, only the Smi conversion, if shift_value is 1.
           if (shift_value > 1) {
             __ shl(answer.reg(), shift_value - 1);
           }
           // Convert int result to Smi, checking that it is in int range.
           ASSERT(kSmiTagSize == 1);  // adjust code if not the case
           __ add(answer.reg(), Operand(answer.reg()));
@@ skipping 22 matching lines @@
         deferred =  new DeferredInlineSmiOperation(op,
                                                    operand->reg(),
                                                    operand->reg(),
                                                    operand->number_info(),
                                                    smi_value,
                                                    overwrite_mode);
       }
       if (!operand->number_info().IsSmi()) {
         __ test(operand->reg(), Immediate(kSmiTagMask));
         deferred->Branch(not_zero);
+      } else {
+        if (FLAG_debug_code) __ AbortIfNotSmi(operand->reg());
       }
       if (op == Token::BIT_AND) {
         __ and_(Operand(operand->reg()), Immediate(value));
       } else if (op == Token::BIT_XOR) {
         if (int_value != 0) {
           __ xor_(Operand(operand->reg()), Immediate(value));
         }
       } else {
         ASSERT(op == Token::BIT_OR);
         if (int_value != 0) {
@@ skipping 173 matching lines @@
       Register left_reg = left_side.reg();
       Handle<Object> right_val = right_side.handle();
 
       // Here we split control flow to the stub call and inlined cases
       // before finally splitting it to the control destination.  We use
       // a jump target and branching to duplicate the virtual frame at
       // the first split.  We manually handle the off-frame references
       // by reconstituting them on the non-fall-through path.
 
       if (left_side.is_smi()) {
-        if (FLAG_debug_code) {
-          __ AbortIfNotSmi(left_side.reg(), "Argument not a smi");
-        }
+        if (FLAG_debug_code) __ AbortIfNotSmi(left_side.reg());
       } else {
         JumpTarget is_smi;
         __ test(left_side.reg(), Immediate(kSmiTagMask));
         is_smi.Branch(zero, taken);
 
         bool is_for_loop_compare = (node->AsCompareOperation() != NULL)
             && node->AsCompareOperation()->is_for_loop_condition();
         if (!is_for_loop_compare
             && CpuFeatures::IsSupported(SSE2)
             && right_val->IsSmi()) {
@@ skipping 1290 matching lines @@
 
   if (node->is_fast_smi_loop()) {
     // Set number type of the loop variable to smi.
     Slot* slot = node->loop_variable()->slot();
     ASSERT(slot->type() == Slot::LOCAL);
     frame_->SetTypeForLocalAt(slot->index(), NumberInfo::Smi());
     if (FLAG_debug_code) {
       frame_->PushLocalAt(slot->index());
       Result var = frame_->Pop();
       var.ToRegister();
-      __ AbortIfNotSmi(var.reg(), "Loop variable not a smi.");
+      __ AbortIfNotSmi(var.reg());
     }
   }
 
   Visit(node->body());
 
   // If there is an update expression, compile it if necessary.
   if (node->next() != NULL) {
     if (node->continue_target()->is_linked()) {
       node->continue_target()->Bind();
     }
@@ skipping 13 matching lines @@
   // set it to smi before compiling the test expression.
   if (node->is_fast_smi_loop()) {
     // Set number type of the loop variable to smi.
     Slot* slot = node->loop_variable()->slot();
     ASSERT(slot->type() == Slot::LOCAL);
     frame_->SetTypeForLocalAt(slot->index(), NumberInfo::Smi());
     if (FLAG_debug_code) {
       frame_->PushLocalAt(slot->index());
       Result var = frame_->Pop();
       var.ToRegister();
-      __ AbortIfNotSmi(var.reg(), "Loop variable not a smi.");
+      __ AbortIfNotSmi(var.reg());
     }
   }
 
   // Based on the condition analysis, compile the backward jump as
   // necessary.
   switch (info) {
     case ALWAYS_TRUE:
       if (has_valid_frame()) {
         if (node->next() == NULL) {
           node->continue_target()->Jump();
@@ skipping 2896 matching lines @@
           break;
         }
         case Token::BIT_NOT: {
           // Smi check.
           JumpTarget smi_label;
           JumpTarget continue_label;
           Result operand = frame_->Pop();
           NumberInfo operand_info = operand.number_info();
           operand.ToRegister();
           if (operand_info.IsSmi()) {
-            if (FLAG_debug_code) {
-              __ AbortIfNotSmi(operand.reg(), "Operand not a smi.");
-            }
+            if (FLAG_debug_code) __ AbortIfNotSmi(operand.reg());
             frame_->Spill(operand.reg());
             // Set smi tag bit. It will be reset by the not operation.
             __ lea(operand.reg(), Operand(operand.reg(), kSmiTagMask));
             __ not_(operand.reg());
             Result answer = operand;
             answer.set_number_info(NumberInfo::Smi());
             frame_->Push(&answer);
           } else {
             __ test(operand.reg(), Immediate(kSmiTagMask));
             smi_label.Branch(zero, &operand, taken);
@@ skipping 179 matching lines @@
       // The old value that is return for postfix operations has the
       // same type as the input value we got from the frame.
       old_value.set_number_info(new_value.number_info());
     }
 
     // Ensure the new value is writable.
     frame_->Spill(new_value.reg());
 
     Result tmp;
     if (new_value.is_smi()) {
-      if (FLAG_debug_code) {
-        __ AbortIfNotSmi(new_value.reg(), "Operand not a smi");
-      }
+      if (FLAG_debug_code) __ AbortIfNotSmi(new_value.reg());
     } else {
       // We don't know statically if the input is a smi.
       // In order to combine the overflow and the smi tag check, we need
       // to be able to allocate a byte register.  We attempt to do so
       // without spilling.  If we fail, we will generate separate overflow
       // and smi tag checks.
       // We allocate and clear a temporary byte register before performing
       // the count operation since clearing the register using xor will clear
       // the overflow flag.
       tmp = allocator_->AllocateByteRegisterWithoutSpilling();
@@ skipping 938 matching lines @@
     // 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->Branch(not_equal);
 
     // Check that the key is a smi.
     if (!key.is_smi()) {
       __ test(key.reg(), Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(key.reg());
     }
 
     // Get the elements array from the receiver and check that it
     // is not a dictionary.
     __ mov(elements.reg(),
            FieldOperand(receiver.reg(), JSObject::kElementsOffset));
     __ cmp(FieldOperand(elements.reg(), HeapObject::kMapOffset),
            Immediate(Factory::fixed_array_map()));
     deferred->Branch(not_equal);
 
@@ skipping 133 matching lines @@
 
 
 static void CheckTwoForSminess(MacroAssembler* masm,
                                Register left, Register right, Register scratch,
                                NumberInfo left_info, NumberInfo right_info,
                                DeferredInlineBinaryOperation* deferred) {
   if (left.is(right)) {
     if (!left_info.IsSmi()) {
       __ test(left, Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(left);
     }
   } else if (!left_info.IsSmi()) {
     if (!right_info.IsSmi()) {
       __ mov(scratch, left);
       __ or_(scratch, Operand(right));
       __ test(scratch, Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
     } else {
       __ test(left, Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
+      if (FLAG_debug_code) __ AbortIfNotSmi(right);
     }
   } else {
+    if (FLAG_debug_code) __ AbortIfNotSmi(left);
     if (!right_info.IsSmi()) {
       __ test(right, Immediate(kSmiTagMask));
       deferred->Branch(not_zero);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(right);
     }
   }
 }
 
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
   if (property == NULL) {
     // Global variable reference treated as a named property reference.
@@ skipping 486 matching lines @@
       __ mov(ebx, eax);
       __ mov(eax, edx);
     }
   }
   if (!HasArgsInRegisters()) {
     __ mov(right, Operand(esp, 1 * kPointerSize));
     __ mov(left, Operand(esp, 2 * kPointerSize));
   }
 
   if (static_operands_type_.IsSmi()) {
+    if (FLAG_debug_code) {
+      __ AbortIfNotSmi(left);
+      __ AbortIfNotSmi(right);
+    }
     if (op_ == Token::BIT_OR) {
       __ or_(right, Operand(left));
       GenerateReturn(masm);
       return;
     } else if (op_ == Token::BIT_AND) {
       __ and_(right, Operand(left));
       GenerateReturn(masm);
       return;
     } else if (op_ == Token::BIT_XOR) {
       __ xor_(right, Operand(left));
@@ skipping 334 matching lines @@
           // forever for all other operations (also if smi code is skipped).
           GenerateTypeTransition(masm);
         }
 
         Label not_floats;
         if (CpuFeatures::IsSupported(SSE2)) {
           CpuFeatures::Scope use_sse2(SSE2);
           if (static_operands_type_.IsNumber()) {
             if (FLAG_debug_code) {
               // Assert at runtime that inputs are only numbers.
-              __ AbortIfNotNumber(edx,
-                                  "GenericBinaryOpStub operand not a number.");
-              __ AbortIfNotNumber(eax,
-                                  "GenericBinaryOpStub operand not a number.");
+              __ AbortIfNotNumber(edx);
+              __ AbortIfNotNumber(eax);
             }
             if (static_operands_type_.IsSmi()) {
+              if (FLAG_debug_code) {
+                __ AbortIfNotSmi(edx);
+                __ AbortIfNotSmi(eax);
+              }
               FloatingPointHelper::LoadSSE2Smis(masm, ecx);
             } else {
               FloatingPointHelper::LoadSSE2Operands(masm);
             }
           } else {
             FloatingPointHelper::LoadSSE2Operands(masm, &call_runtime);
           }
 
           switch (op_) {
             case Token::ADD: __ addsd(xmm0, xmm1); break;
             case Token::SUB: __ subsd(xmm0, xmm1); break;
             case Token::MUL: __ mulsd(xmm0, xmm1); break;
             case Token::DIV: __ divsd(xmm0, xmm1); break;
             default: UNREACHABLE();
           }
           GenerateHeapResultAllocation(masm, &call_runtime);
           __ movdbl(FieldOperand(eax, HeapNumber::kValueOffset), xmm0);
           GenerateReturn(masm);
         } else {  // SSE2 not available, use FPU.
           if (static_operands_type_.IsNumber()) {
             if (FLAG_debug_code) {
               // Assert at runtime that inputs are only numbers.
-              __ AbortIfNotNumber(edx,
-                                  "GenericBinaryOpStub operand not a number.");
-              __ AbortIfNotNumber(eax,
-                                  "GenericBinaryOpStub operand not a number.");
+              __ AbortIfNotNumber(edx);
+              __ AbortIfNotNumber(eax);
             }
           } else {
             FloatingPointHelper::CheckFloatOperands(masm, &call_runtime, ebx);
           }
           FloatingPointHelper::LoadFloatOperands(
               masm,
               ecx,
               FloatingPointHelper::ARGS_IN_REGISTERS);
           switch (op_) {
             case Token::ADD: __ faddp(1); break;
@@ skipping 709 matching lines @@
                                                 Label* conversion_failure) {
   // Check float operands.
   Label arg1_is_object, check_undefined_arg1;
   Label arg2_is_object, check_undefined_arg2;
   Label load_arg2, done;
 
   if (!number_info.IsHeapNumber()) {
     if (!number_info.IsSmi()) {
       __ test(edx, Immediate(kSmiTagMask));
       __ j(not_zero, &arg1_is_object);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(edx);
     }
     __ SmiUntag(edx);
     __ jmp(&load_arg2);
   }
 
   __ bind(&arg1_is_object);
 
   // Get the untagged integer version of the edx heap number in ecx.
   IntegerConvert(masm, edx, number_info, use_sse3, conversion_failure);
   __ mov(edx, ecx);
 
   // Here edx has the untagged integer, eax has a Smi or a heap number.
   __ bind(&load_arg2);
   if (!number_info.IsHeapNumber()) {
     // Test if arg2 is a Smi.
     if (!number_info.IsSmi()) {
       __ test(eax, Immediate(kSmiTagMask));
       __ j(not_zero, &arg2_is_object);
+    } else {
+      if (FLAG_debug_code) __ AbortIfNotSmi(eax);
     }
     __ SmiUntag(eax);
     __ mov(ecx, eax);
     __ jmp(&done);
   }
 
   __ bind(&arg2_is_object);
 
   // Get the untagged integer version of the eax heap number in ecx.
   IntegerConvert(masm, eax, number_info, use_sse3, conversion_failure);
@@ skipping 2568 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal