Improve our type feedback by recogizining never-executed IC calls for binary ...

src/ia32/full-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 1530 matching lines @@
 }
 
 
 void FullCodeGenerator::EmitKeyedPropertyLoad(Property* prop) {
   SetSourcePosition(prop->position());
   Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
   EmitCallIC(ic, RelocInfo::CODE_TARGET);
 }
 
 
+class JumpPatchSite BASE_EMBEDDED {
+ public:
+  JumpPatchSite(MacroAssembler* masm, NearLabel* target, Condition cc)
+      : masm_(masm), jump_target_(target), cc_(cc) { }
+
+  void EmitJump() {
+    masm_->bind(&patch_site_);

[Vitaly Repeshko, 2010/12/09 15:59:01]

In debug mode in ~JumpPatchSite we could assert that patch info is emitted if
patch_site is bound.

[fschneider, 2010/12/10 13:19:24]

Done.

+    masm_->jmp(jump_target_);
+  }
+
+  void EmitPatchInfo() {
+    int delta_to_patch_site = masm_->SizeOfCodeGeneratedSince(&patch_site_);
+    __ test(eax, Immediate(delta_to_patch_site << 16 | cc_));

[Vitaly Repeshko, 2010/12/09 15:59:01]

For smi checks the condition is always not_zero. We could save 3 bytes by using
short form of test here. Of course, this makes JumpPatchSite less generic. On
the other hand, we could specialize it even more for smi checks, e.g.:
SmiCheckPatchSite smi_check(masm_, &call_stub);
smi_check.EmitCheck(eax);
...
CallStub(...);
smi_check.EmitPatchInfo();

[fschneider, 2010/12/10 13:19:24]

Done.

+  }
+
+ private:
+  MacroAssembler* masm_;
+  Label patch_site_;
+  NearLabel* jump_target_;
+  Condition cc_;
+};
+
+
 void FullCodeGenerator::EmitConstantSmiAdd(Expression* expr,
                                            OverwriteMode mode,
                                            bool left_is_constant_smi,
                                            Smi* value) {
-  NearLabel call_stub;
-  Label done;
+  NearLabel call_stub, done;
   __ add(Operand(eax), Immediate(value));
   __ j(overflow, &call_stub);
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &done);
+  JumpPatchSite patch_site(masm_, &call_stub, not_zero);
+  patch_site.EmitJump();
+  __ jmp(&done);
 
   // Undo the optimistic add operation and call the shared stub.
   __ bind(&call_stub);
   __ sub(Operand(eax), Immediate(value));
   Token::Value op = Token::ADD;
   TypeRecordingBinaryOpStub stub(op, mode);
   if (left_is_constant_smi) {
     __ mov(edx, Immediate(value));
   } else {
     __ mov(edx, eax);
     __ mov(eax, Immediate(value));
   }
   __ CallStub(&stub);

[Vitaly Repeshko, 2010/12/09 15:59:01]

Consider adding a function like EmitCallIC that takes both a stub to call and an
optional patch site. Patch site should be used if it is bound, otherwise nop is
emitted.

[William Hesse, 2010/12/09 16:27:58]

I'm not sure this is a good idea, since the existing call to CallStub is at a
nice low level, and all the other JumpSitePatch relevant stuff is right here in
the same code.

[Kevin Millikin (Chromium), 2010/12/10 06:41:41]

I like Vitaly's idea because it's safer.  I think the jumping/branching and the
calling is something you want to see in this code generator code.  The required
__nop() or EmitPatchInfo is bookkeeping and doesn't need to be seen here.

 Taking it a step further, you could make it read more like a jump by making the
interface:

JumpPatchSite patch_site(masm_);
patch_site.EmitJump(not_zero, &call_stub);
...

EmitCallStub(&stub, &patch_site);

[fschneider, 2010/12/10 13:19:24]

Done.

+  patch_site.EmitPatchInfo();
+
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiSub(Expression* expr,
                                            OverwriteMode mode,
                                            bool left_is_constant_smi,
                                            Smi* value) {
-  Label call_stub, done;
+  NearLabel call_stub, done;
   if (left_is_constant_smi) {
     __ mov(ecx, eax);
     __ mov(eax, Immediate(value));
     __ sub(Operand(eax), ecx);
   } else {
     __ sub(Operand(eax), Immediate(value));
   }
   __ j(overflow, &call_stub);
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &done);
+  JumpPatchSite patch_site(masm_, &call_stub, not_zero);
+  patch_site.EmitJump();
+  __ jmp(&done);
 
   __ bind(&call_stub);
   if (left_is_constant_smi) {
     __ mov(edx, Immediate(value));
     __ mov(eax, ecx);
   } else {
     __ add(Operand(eax), Immediate(value));  // Undo the subtraction.
     __ mov(edx, eax);
     __ mov(eax, Immediate(value));
   }
   Token::Value op = Token::SUB;
   TypeRecordingBinaryOpStub stub(op, mode);
   __ CallStub(&stub);
+  patch_site.EmitPatchInfo();
+
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiShiftOp(Expression* expr,
                                                Token::Value op,
                                                OverwriteMode mode,
                                                Smi* value) {
-  Label call_stub, smi_case, done;
+  NearLabel call_stub, done;
   int shift_value = value->value() & 0x1f;
 
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &smi_case);
+  // Patch site.
+  JumpPatchSite patch_site(masm_, &call_stub, not_zero);
+  patch_site.EmitJump();
 
-  __ bind(&call_stub);
-  __ mov(edx, eax);
-  __ mov(eax, Immediate(value));
-  TypeRecordingBinaryOpStub stub(op, mode);
-  __ CallStub(&stub);
-  __ jmp(&done);
-
-  __ bind(&smi_case);
+  // Smi case.
   switch (op) {
     case Token::SHL:
       if (shift_value != 0) {
         __ mov(edx, eax);
         if (shift_value > 1) {
           __ shl(edx, 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(edx, Operand(edx));
@@ skipping 18 matching lines @@
         __ mov(eax, edx);  // Put result back into eax.
       } else {
         __ SmiUntag(eax);
         __ shr(eax, shift_value);
         __ SmiTag(eax);
       }
       break;
     default:
       UNREACHABLE();
   }
+  __ jmp(&done);
+
+  // Call stub.
+  __ bind(&call_stub);
+  __ mov(edx, eax);
+  __ mov(eax, Immediate(value));
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  patch_site.EmitPatchInfo();
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiBitOp(Expression* expr,
                                              Token::Value op,
                                              OverwriteMode mode,
                                              Smi* value) {
-  Label smi_case, done;
+  NearLabel call_stub, done;
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &smi_case);
+  // Patch site. The first invocation of the stub will be patch the jmp with
+  // the required conditional jump.
+  JumpPatchSite patch_site(masm_, &call_stub, not_zero);
+  patch_site.EmitJump();
 
-  // The order of the arguments does not matter for bit-ops with a
-  // constant operand.
-  __ mov(edx, Immediate(value));
-  TypeRecordingBinaryOpStub stub(op, mode);
-  __ CallStub(&stub);
-  __ jmp(&done);
-
-  __ bind(&smi_case);
+  // Smi case.
   switch (op) {
     case Token::BIT_OR:
       __ or_(Operand(eax), Immediate(value));
       break;
     case Token::BIT_XOR:
       __ xor_(Operand(eax), Immediate(value));
       break;
     case Token::BIT_AND:
       __ and_(Operand(eax), Immediate(value));
       break;
     default:
       UNREACHABLE();
   }
+  __ jmp(&done);
+
+  // The order of the arguments does not matter for bit-ops with a
+  // constant operand.
+  __ bind(&call_stub);
+  __ mov(edx, Immediate(value));
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  patch_site.EmitPatchInfo();
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitConstantSmiBinaryOp(Expression* expr,
                                                 Token::Value op,
                                                 OverwriteMode mode,
                                                 bool left_is_constant_smi,
@@ skipping 33 matching lines @@
     EmitConstantSmiBinaryOp(expr, op, mode, false, value);
     return;
   } else if (constant == kLeftConstant) {
     Smi* value =  Smi::cast(*left->AsLiteral()->handle());
     EmitConstantSmiBinaryOp(expr, op, mode, true, value);
     return;
   }
 
   // Do combined smi check of the operands. Left operand is on the
   // stack. Right operand is in eax.
-  Label done, stub_call, smi_case;
+  NearLabel done, stub_call;
   __ pop(edx);
   __ mov(ecx, eax);
   __ or_(eax, Operand(edx));
   __ test(eax, Immediate(kSmiTagMask));
-  __ j(zero, &smi_case);
+  JumpPatchSite patch_site(masm_, &stub_call, not_zero);
+  patch_site.EmitJump();
 
-  __ bind(&stub_call);
-  __ mov(eax, ecx);
-  TypeRecordingBinaryOpStub stub(op, mode);
-  __ CallStub(&stub);
-  __ jmp(&done);
-
-  __ bind(&smi_case);
+  // Smi case.
   __ mov(eax, edx);  // Copy left operand in case of a stub call.
 
   switch (op) {
     case Token::SAR:
       __ SmiUntag(eax);
       __ SmiUntag(ecx);
       __ sar_cl(eax);  // No checks of result necessary
       __ SmiTag(eax);
       break;
     case Token::SHL: {
@@ skipping 47 matching lines @@
       break;
     case Token::BIT_AND:
       __ and_(eax, Operand(ecx));
       break;
     case Token::BIT_XOR:
       __ xor_(eax, Operand(ecx));
       break;
     default:
       UNREACHABLE();
   }
+  __ jmp(&done);
+
+  __ bind(&stub_call);
+  __ mov(eax, ecx);
+  TypeRecordingBinaryOpStub stub(op, mode);
+  __ CallStub(&stub);
+  patch_site.EmitPatchInfo();
 
   __ bind(&done);
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitBinaryOp(Token::Value op,
                                      OverwriteMode mode) {
   __ pop(edx);
   TypeRecordingBinaryOpStub stub(op, mode);
   __ CallStub(&stub);
+  __ nop();  // Signals no inlined smi code.
   context()->Plug(eax);
 }
 
 
 void FullCodeGenerator::EmitAssignment(Expression* expr) {
   // Invalid left-hand sides are rewritten to have a 'throw
   // ReferenceError' on the left-hand side.
   if (!expr->IsValidLeftHandSide()) {
     VisitForEffect(expr);
     return;
@@ skipping 1844 matching lines @@
           break;
         case KEYED_PROPERTY:
           __ mov(Operand(esp, 2 * kPointerSize), eax);
           break;
       }
     }
   }
 
   // Inline smi case if we are in a loop.
   NearLabel stub_call;
+  JumpPatchSite patch_site(masm_, &stub_call, not_zero);
   Label done;
   if (ShouldInlineSmiCase(expr->op())) {
     if (expr->op() == Token::INC) {
       __ add(Operand(eax), Immediate(Smi::FromInt(1)));
     } else {
       __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
     }
     __ j(overflow, &stub_call);
     // We could eliminate this smi check if we split the code at
     // the first smi check before calling ToNumber.
     __ test(eax, Immediate(kSmiTagMask));
-    __ j(zero, &done);
+    patch_site.EmitJump();
+    __ jmp(&done);

[William Hesse, 2010/12/09 16:27:58]

Too bad that you have to put an extra jump here, to make it work.

+
     __ bind(&stub_call);
     // Call stub. Undo operation first.
     if (expr->op() == Token::INC) {
       __ sub(Operand(eax), Immediate(Smi::FromInt(1)));
     } else {
       __ add(Operand(eax), Immediate(Smi::FromInt(1)));
     }
   }
 
   // Record position before stub call.
   SetSourcePosition(expr->position());
 
   // Call stub for +1/-1.
   __ mov(edx, eax);
   __ mov(eax, Immediate(Smi::FromInt(1)));
   TypeRecordingBinaryOpStub stub(expr->binary_op(),
                                  NO_OVERWRITE);
   __ CallStub(&stub);
+  // Indicate here if smi code was inlined.
+  if (ShouldInlineSmiCase(expr->op())) {
+    patch_site.EmitPatchInfo();
+  } else {
+    __ nop();  // Signals no inlined code.
+  }
+
   __ bind(&done);
-
   // Store the value returned in eax.
   switch (assign_type) {
     case VARIABLE:
       if (expr->is_postfix()) {
         // Perform the assignment as if via '='.
         { EffectContext context(this);
           EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
                                  Token::ASSIGN);
         }
         // For all contexts except EffectContext We have the result on
@@ skipping 409 matching lines @@
   // And return.
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32