Experimental: cleanup of the code generator source file. Some simple...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 700 matching lines @@
   }
 }
 
 
 class DeferredInlineBinaryOperation: public DeferredCode {
  public:
   DeferredInlineBinaryOperation(CodeGenerator* generator,
                                 Token::Value op,
                                 OverwriteMode mode,
                                 GenericBinaryFlags flags)
-      : DeferredCode(generator),
-        stub_(op, mode, flags),
-        op_(op) {
+      : DeferredCode(generator), stub_(op, mode, flags), op_(op) {
+    set_comment("[ DeferredInlineBinaryOperation");
   }
 
-  // The binary operation's arguments are on top of the code generator's frame.
   Result GenerateInlineCode();
 
-  virtual void Generate() {
-    Result left(generator());
-    Result right(generator());
-    enter()->Bind(&left, &right);
-    generator()->frame()->Push(&left);
-    generator()->frame()->Push(&right);
-    Result answer = generator()->frame()->CallStub(&stub_, 2);
-    exit()->Jump(&answer);
-  }
+  virtual void Generate();
 
  private:
   GenericBinaryOpStub stub_;
   Token::Value op_;
 };
 
 
+void DeferredInlineBinaryOperation::Generate() {
+  Result left(generator());
+  Result right(generator());
+  enter()->Bind(&left, &right);
+  generator()->frame()->Push(&left);
+  generator()->frame()->Push(&right);
+  Result answer = generator()->frame()->CallStub(&stub_, 2);
+  exit()->Jump(&answer);
+}
+
+
 void CodeGenerator::GenericBinaryOperation(Token::Value op,
                                            StaticType* type,
                                            OverwriteMode overwrite_mode) {
   Comment cmnt(masm_, "[ BinaryOperation");
   Comment cmnt_token(masm_, Token::String(op));
 
   if (op == Token::COMMA) {
     // Simply discard left value.
     frame_->Nip(1);
     return;
@@ skipping 38 matching lines @@
     GenericBinaryOpStub stub(op, overwrite_mode, flags);
     Result answer = frame_->CallStub(&stub, 2);
     frame_->Push(&answer);
   }
 }
 
 
 class DeferredInlinedSmiOperation: public DeferredCode {
  public:
   DeferredInlinedSmiOperation(CodeGenerator* generator,
-                              Token::Value op, int value,
-                              OverwriteMode overwrite_mode) :
-      DeferredCode(generator), op_(op), value_(value),
-      overwrite_mode_(overwrite_mode) {
+                              Token::Value op,
+                              int value,
+                              OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        op_(op),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiOperation");
   }
-  virtual void Generate() {
-    // The argument is actually passed in eax.
-    enter()->Bind();
-    VirtualFrame::SpilledScope spilled_scope(generator());
-    generator()->frame()->EmitPush(eax);
-    generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
-    GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-    generator()->frame()->CallStub(&igostub, 2);
-    // The result is actually returned in eax.
-    exit()->Jump();
-  }
+
+  virtual void Generate();
 
  private:
   Token::Value op_;
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiOperation::Generate() {
+  // The argument is passed in eax.
+  enter()->Bind();
+  VirtualFrame::SpilledScope spilled_scope(generator());
+  generator()->frame()->EmitPush(eax);
+  generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
+  GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
+  generator()->frame()->CallStub(&igostub, 2);
+  // The result is returned in eax.
+  exit()->Jump();
+}
+
+
 class DeferredInlinedSmiOperationReversed: public DeferredCode {
  public:
   DeferredInlinedSmiOperationReversed(CodeGenerator* generator,
-                                      Token::Value op, int value,
-                                      OverwriteMode overwrite_mode) :
-      DeferredCode(generator), op_(op), value_(value),
-      overwrite_mode_(overwrite_mode) {
+                                      Token::Value op,
+                                      int value,
+                                      OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        op_(op),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiOperationReversed");
   }
-  virtual void Generate() {
-    // The argument is actually passed in eax.
-    enter()->Bind();
-    VirtualFrame::SpilledScope spilled_scope(generator());
-    generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
-    generator()->frame()->EmitPush(eax);
-    GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
-    generator()->frame()->CallStub(&igostub, 2);
-    // The result is actually returned in eax.
-    exit()->Jump();

[William Hesse, 2009/01/26 10:07:50]

The other change list returns a result through Jump(&result), as is done the
deferred addition and subtraction cases.
Should that be done here, or when the change is merged in?

[Kevin Millikin (Chromium), 2009/01/26 10:36:00]

This is spilled code jumping into spilled code, so I won't bother.

-  }
+
+  virtual void Generate();
 
  private:
   Token::Value op_;
   int value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiOperationReversed::Generate() {
+  // The argument is passed in eax.
+  enter()->Bind();
+  VirtualFrame::SpilledScope spilled_scope(generator());
+  generator()->frame()->EmitPush(Immediate(Smi::FromInt(value_)));
+  generator()->frame()->EmitPush(eax);
+  GenericBinaryOpStub igostub(op_, overwrite_mode_, SMI_CODE_INLINED);
+  generator()->frame()->CallStub(&igostub, 2);
+  // The result is returned in eax.
+  exit()->Jump();
+}
+
+
 class DeferredInlinedSmiAdd: public DeferredCode {
  public:
-  DeferredInlinedSmiAdd(CodeGenerator* generator, Smi* value,
-                        OverwriteMode overwrite_mode) :
-      DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
+  DeferredInlinedSmiAdd(CodeGenerator* generator,
+                        Smi* value,
+                        OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAdd");
   }
 
-  virtual void Generate() {
-    Result arg(generator());
-    enter()->Bind(&arg);
-    arg.ToRegister();
-    generator()->frame()->Spill(arg.reg());
-    // Undo the optimistic add operation and call the shared stub.
-    __ sub(Operand(arg.reg()), Immediate(value_));
-    generator()->frame()->Push(&arg);
-    generator()->frame()->Push(value_);
-    GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    Result result = generator()->frame()->CallStub(&igostub, 2);
-    exit()->Jump(&result);
-  }
+  virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiAdd::Generate() {
+  // Undo the optimistic add operation and call the shared stub.
+  Result left(generator());  // Initially left + value_.
+  enter()->Bind(&left);
+  left.ToRegister();
+  generator()->frame()->Spill(left.reg());
+  __ sub(Operand(left.reg()), Immediate(value_));
+  generator()->frame()->Push(&left);
+  generator()->frame()->Push(value_);
+  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  exit()->Jump(&answer);
+}
+
+
 class DeferredInlinedSmiAddReversed: public DeferredCode {
  public:
-  DeferredInlinedSmiAddReversed(CodeGenerator* generator, Smi* value,
-                        OverwriteMode overwrite_mode) :
-      DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
+  DeferredInlinedSmiAddReversed(CodeGenerator* generator,
+                                Smi* value,
+                                OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiAddReversed");
   }
 
-  virtual void Generate() {
-    Result arg(generator());
-    enter()->Bind(&arg);
-    arg.ToRegister();
-    generator()->frame()->Spill(arg.reg());
-    // Undo the optimistic add operation and call the shared stub.
-    __ sub(Operand(arg.reg()), Immediate(value_));
-    generator()->frame()->Push(value_);
-    generator()->frame()->Push(&arg);
-    GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
-    arg = generator()->frame()->CallStub(&igostub, 2);
-    exit()->Jump(&arg);
-  }
+  virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiAddReversed::Generate() {
+  // Undo the optimistic add operation and call the shared stub.
+  Result right(generator());  // Initially value_ + right.
+  enter()->Bind(&right);
+  right.ToRegister();
+  generator()->frame()->Spill(right.reg());
+  __ sub(Operand(right.reg()), Immediate(value_));
+  generator()->frame()->Push(value_);
+  generator()->frame()->Push(&right);
+  GenericBinaryOpStub igostub(Token::ADD, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  exit()->Jump(&answer);
+}
+
+
 class DeferredInlinedSmiSub: public DeferredCode {
  public:
   DeferredInlinedSmiSub(CodeGenerator* generator,
                         Smi* value,
-                        OverwriteMode overwrite_mode) :
-      DeferredCode(generator), value_(value), overwrite_mode_(overwrite_mode) {
+                        OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiSub");
   }
 
-  virtual void Generate() {
-    Result argument(generator());
-    enter()->Bind(&argument);
-    argument.ToRegister();
-    generator()->frame()->Spill(argument.reg());
-    // Undo the optimistic sub operation and call the shared stub.
-    __ add(Operand(argument.reg()), Immediate(value_));
-    generator()->frame()->Push(&argument);
-    generator()->frame()->Push(value_);
-    GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-    Result answer = generator()->frame()->CallStub(&igostub, 2);
-    // The result is actually returned in eax.
-    exit()->Jump(&answer);
-  }
+  virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiSub::Generate() {
+  // Undo the optimistic sub operation and call the shared stub.
+  Result left(generator());  // Initially left - value_.
+  enter()->Bind(&left);
+  left.ToRegister();
+  generator()->frame()->Spill(left.reg());
+  __ add(Operand(left.reg()), Immediate(value_));
+  generator()->frame()->Push(&left);
+  generator()->frame()->Push(value_);
+  GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  exit()->Jump(&answer);
+}
+
+
 class DeferredInlinedSmiSubReversed: public DeferredCode {
  public:
   DeferredInlinedSmiSubReversed(CodeGenerator* generator,
                                 Smi* value,
-                                OverwriteMode overwrite_mode) :
-      DeferredCode(generator), value_(value),
-      overwrite_mode_(overwrite_mode) {
+                                OverwriteMode overwrite_mode)
+      : DeferredCode(generator),
+        value_(value),
+        overwrite_mode_(overwrite_mode) {
     set_comment("[ DeferredInlinedSmiSubReversed");
   }
 
-  virtual void Generate() {
-    Result rhs(generator());
-    enter()->Bind(&rhs);
-    generator()->frame()->Push(value_);
-    generator()->frame()->Push(&rhs);
-    GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
-    Result answer = generator()->frame()->CallStub(&igostub, 2);
-    exit()->Jump(&answer);
-  }
+  virtual void Generate();
 
  private:
   Smi* value_;
   OverwriteMode overwrite_mode_;
 };
 
 
+void DeferredInlinedSmiSubReversed::Generate() {
+  // Call the shared stub.
+  Result right(generator());
+  enter()->Bind(&right);
+  generator()->frame()->Push(value_);
+  generator()->frame()->Push(&right);
+  GenericBinaryOpStub igostub(Token::SUB, overwrite_mode_, SMI_CODE_INLINED);
+  Result answer = generator()->frame()->CallStub(&igostub, 2);
+  exit()->Jump(&answer);
+}
+
+
 void CodeGenerator::SmiOperation(Token::Value op,
                                  StaticType* type,
                                  Handle<Object> value,
                                  bool reversed,
                                  OverwriteMode overwrite_mode) {
   // NOTE: This is an attempt to inline (a bit) more of the code for
   // some possible smi operations (like + and -) when (at least) one
   // of the operands is a literal smi. With this optimization, the
   // performance of the system is increased by ~15%, and the generated
   // code size is increased by ~1% (measured on a combination of
@@ skipping 358 matching lines @@
   Result answer = frame_->CallStub(&call_function, arg_count + 1);
   // Restore context and replace function on the stack with the
   // result of the stub invocation.
   frame_->RestoreContextRegister();
   frame_->SetElementAt(0, &answer);
 }
 
 
 class DeferredStackCheck: public DeferredCode {
  public:
-  DeferredStackCheck(CodeGenerator* generator)
+  explicit DeferredStackCheck(CodeGenerator* generator)
       : DeferredCode(generator) {
     set_comment("[ DeferredStackCheck");
   }
 
   virtual void Generate();
 };
 
 
 void DeferredStackCheck::Generate() {
   enter()->Bind();
@@ skipping 239 matching lines @@
     CodeForStatement(node);
     Load(node->expression());
 
     // Pop the result from the frame and prepare the frame for
     // returning thus making it easier to merge.
     Result result = frame_->Pop();
     frame_->PrepareForReturn();
 
     // Move the result into register eax where it belongs.
     result.ToRegister(eax);
-    // TODO(): Instead of explictly calling Unuse on the result, it
+    // TODO(203): Instead of explictly calling Unuse on the result, it
     // might be better to pass the result to Jump and Bind below.
     result.Unuse();
 
     // If the function return label is already bound, we reuse the
     // code by jumping to the return site.
     if (function_return_.is_bound()) {
       function_return_.Jump();
     } else {
       function_return_.Bind();
       GenerateReturnSequence();
@@ skipping 1102 matching lines @@
       // The other slot types (LOOKUP and GLOBAL) cannot reach here.
       ASSERT(slot->type() == Slot::CONTEXT);
       frame_->Dup();
       Result value = frame_->Pop();
       value.ToRegister();
       Result start = allocator_->Allocate();
       ASSERT(start.is_valid());
       __ mov(SlotOperand(slot, start.reg()), value.reg());
       // RecordWrite may destroy the value registers.
       //
-      // TODO(): Avoid actually spilling when the value is not needed
-      // (probably the common case).
+      // TODO(204): Avoid actually spilling when the value is not
+      // needed (probably the common case).
       frame_->Spill(value.reg());
       int offset = FixedArray::kHeaderSize + slot->index() * kPointerSize;
       Result temp = allocator_->Allocate();
       ASSERT(temp.is_valid());
       __ RecordWrite(start.reg(), offset, value.reg(), temp.reg());
       // The results start, value, and temp are unused by going out of
       // scope.
     }
 
     // If we definitely did not jump over the assignment, we do not need
@@ skipping 50 matching lines @@
   }
 }
 
 
 class DeferredRegExpLiteral: public DeferredCode {
  public:
   DeferredRegExpLiteral(CodeGenerator* generator, RegExpLiteral* node)
       : DeferredCode(generator), node_(node) {
     set_comment("[ DeferredRegExpLiteral");
   }
+
   virtual void Generate();
+
  private:
   RegExpLiteral* node_;
 };
 
 
 void DeferredRegExpLiteral::Generate() {
   // The argument is actually passed in ecx.
   enter()->Bind();
   VirtualFrame::SpilledScope spilled_scope(generator());
   // If the entry is undefined we call the runtime system to compute the
@@ skipping 48 matching lines @@
 // by calling Runtime_CreateObjectLiteral.
 // Each created boilerplate is stored in the JSFunction and they are
 // therefore context dependent.
 class DeferredObjectLiteral: public DeferredCode {
  public:
   DeferredObjectLiteral(CodeGenerator* generator,
                         ObjectLiteral* node)
       : DeferredCode(generator), node_(node) {
     set_comment("[ DeferredObjectLiteral");
   }
+
   virtual void Generate();
+
  private:
   ObjectLiteral* node_;
 };
 
 
 void DeferredObjectLiteral::Generate() {
   // The argument is actually passed in ecx.
   enter()->Bind();
   VirtualFrame::SpilledScope spilled_scope(generator());
   // If the entry is undefined we call the runtime system to compute
@@ skipping 380 matching lines @@
   Load(node->expression());
   LoadGlobal();
 
   // Push the arguments ("left-to-right") on the stack.
   ZoneList<Expression*>* args = node->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Load(args->at(i));
   }
 
-  // TODO(): Get rid of this spilling. It is only necessary because we
-  // load the function from the non-virtual stack.
+  // TODO(205): Get rid of this spilling. It is only necessary because
+  // we load the function from the non-virtual stack.
   frame_->SpillAll();
 
   // Constructors are called with the number of arguments in register
   // eax for now. Another option would be to have separate construct
   // call trampolines per different arguments counts encountered.
   __ Set(eax, Immediate(arg_count));
 
   // Load the function into temporary function slot as per calling
   // convention.
   __ mov(edi, frame_->ElementAt(arg_count + 1));
@@ skipping 1076 matching lines @@
 #endif
 
 
 class DeferredReferenceGetKeyedValue: public DeferredCode {
  public:
   DeferredReferenceGetKeyedValue(CodeGenerator* generator, bool is_global)
       : DeferredCode(generator), is_global_(is_global) {
     set_comment("[ DeferredReferenceGetKeyedValue");
   }
 
-  virtual void Generate() {
-    CodeGenerator* cgen = generator();
-    Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
-    Result receiver(cgen);
-    Result key(cgen);
-    enter()->Bind(&receiver, &key);
-    VirtualFrame* frame = generator()->frame();
-    frame->Push(&receiver);  // First IC argument.
-    frame->Push(&key);       // Second IC argument.
-
-    // Calculate the delta from the IC call instruction to the map
-    // check cmp instruction in the inlined version.  This delta is
-    // stored in a test(eax, delta) instruction after the call so that
-    // we can find it in the IC initialization code and patch the cmp
-    // instruction.  This means that we cannot allow test instructions
-    // after calls to KeyedLoadIC stubs in other places.
-    //
-    // The virtual frame should be spilled fully before the call so
-    // that the call itself does not generate extra code to spill
-    // values.
-    frame->SpillAll();
-    int delta_to_patch_site = __ SizeOfCodeGeneratedSince(patch_site());
-    Result value(cgen);
-    if (is_global_) {
-      value = frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
-    } else {
-      value = frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
-    }
-    // The result needs to be specifically the eax register because
-    // the offset to the patch site will be expected in a test eax
-    // instruction.
-    ASSERT(value.is_register() && value.reg().is(eax));
-    __ test(value.reg(), Immediate(-delta_to_patch_site));
-    __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
-    exit()->Jump(&value);
-  }
+  virtual void Generate();
 
   Label* patch_site() { return &patch_site_; }
 
  private:
   Label patch_site_;
   bool is_global_;
 };
 
 
+void DeferredReferenceGetKeyedValue::Generate() {
+  CodeGenerator* cgen = generator();
+  Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
+  Result receiver(cgen);
+  Result key(cgen);
+  enter()->Bind(&receiver, &key);
+  cgen->frame()->Push(&receiver);  // First IC argument.
+  cgen->frame()->Push(&key);       // Second IC argument.
+
+  // Calculate the delta from the IC call instruction to the map check
+  // cmp instruction in the inlined version.  This delta is stored in
+  // a test(eax, delta) instruction after the call so that we can find
+  // it in the IC initialization code and patch the cmp instruction.
+  // This means that we cannot allow test instructions after calls to
+  // KeyedLoadIC stubs in other places.
+  //
+  // The virtual frame should be spilled fully before the call so that
+  // the call itself does not generate extra code to spill values,
+  // which would invalidate the delta calculation.
+  cgen->frame()->SpillAll();
+  int delta_to_patch_site = __ SizeOfCodeGeneratedSince(patch_site());
+  Result value(cgen);
+  if (is_global_) {
+    value = cgen->frame()->CallCodeObject(ic,
+                                          RelocInfo::CODE_TARGET_CONTEXT,
+                                          0);
+  } else {
+    value = cgen->frame()->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
+  }
+  // The result needs to be specifically the eax register because the
+  // offset to the patch site will be expected in a test eax
+  // instruction.
+  ASSERT(value.is_register() && value.reg().is(eax));
+  __ test(value.reg(), Immediate(-delta_to_patch_site));
+  __ IncrementCounter(&Counters::keyed_load_inline_miss, 1);
+  exit()->Jump(&value);
+}
+
+
 #undef __
 #define __ masm->
 
 Handle<String> Reference::GetName() {
   ASSERT(type_ == NAMED);
   Property* property = expression_->AsProperty();
   if (property == NULL) {
     // Global variable reference treated as a named property reference.
     VariableProxy* proxy = expression_->AsVariableProxy();
     ASSERT(proxy->AsVariable() != NULL);
@@ skipping 101 matching lines @@
         ASSERT(index.is_valid());
         __ mov(index.reg(), key.reg());
         __ sar(index.reg(), kSmiTagSize);
         __ cmp(index.reg(),
                FieldOperand(elements.reg(), Array::kLengthOffset));
         deferred->enter()->Branch(above_equal, &receiver, &key, not_taken);
 
         // Load and check that the result is not the hole.  We could
         // reuse the index or elements register for the value.
         //
-        // TODO(): Consider whether it makes sense to try some
+        // TODO(206): Consider whether it makes sense to try some
         // heuristic about which register to reuse.  For example, if
         // one is eax, the we can reuse that one because the value
         // coming from the deferred code will be in eax.
         Result value = index;
         __ mov(value.reg(), Operand(elements.reg(),
                                     index.reg(),
                                     times_4,
                                     Array::kHeaderSize - kHeapObjectTag));
         elements.Unuse();
         index.Unuse();
@@ skipping 388 matching lines @@
           ASSERT(kSmiTag == 0);
           __ shl(left.reg(), kSmiTagSize);
           __ shl(right.reg(), kSmiTagSize);
           enter()->Jump(&left, &right);
           result_ok.Bind(&left, &right);
           break;
         }
         case Token::SHL: {
           __ shl(left.reg());
           // Check that the *signed* result fits in a smi.
-          // TODO(): Can reduce registers from 4 to 3 by preallocating ecx.
+          //
+          // TODO(207): Can reduce registers from 4 to 3 by
+          // preallocating ecx.
           JumpTarget result_ok(generator());
           Result smi_test_reg = generator()->allocator()->Allocate();
           ASSERT(smi_test_reg.is_valid());
           __ lea(smi_test_reg.reg(), Operand(left.reg(), 0x40000000));
           __ test(smi_test_reg.reg(), Immediate(0x80000000));
           smi_test_reg.Unuse();
           result_ok.Branch(zero, &left, &right, taken);
           __ shr(left.reg());
           ASSERT(kSmiTag == 0);
           __ shl(left.reg(), kSmiTagSize);
@@ skipping 1185 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal