Revert "Fix compilation with C++11." and "Allocation site support for monomorphic StringAdds in Bin…

src/ic.cc

 // Copyright 2012 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 2380 matching lines @@
   GENERATE(Token::ADD, NUMBER, SMI, NUMBER, OVERWRITE_LEFT);
   GENERATE(Token::ADD, NUMBER, SMI, NUMBER, OVERWRITE_RIGHT);
   GENERATE(Token::ADD, SMI, INT32, INT32, NO_OVERWRITE);
   GENERATE(Token::ADD, SMI, INT32, INT32, OVERWRITE_LEFT);
   GENERATE(Token::ADD, SMI, INT32, NUMBER, NO_OVERWRITE);
   GENERATE(Token::ADD, SMI, NUMBER, NUMBER, NO_OVERWRITE);
   GENERATE(Token::ADD, SMI, NUMBER, NUMBER, OVERWRITE_LEFT);
   GENERATE(Token::ADD, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT);
   GENERATE(Token::ADD, SMI, SMI, INT32, OVERWRITE_LEFT);
   GENERATE(Token::ADD, SMI, SMI, SMI, OVERWRITE_RIGHT);
-  GENERATE(Token::ADD, STRING, SMI, STRING, NO_OVERWRITE);
-  GENERATE(Token::ADD, SMI, STRING, STRING, NO_OVERWRITE);
-  GENERATE(Token::ADD, STRING, NUMBER, STRING, NO_OVERWRITE);
-  GENERATE(Token::ADD, NUMBER, STRING, STRING, NO_OVERWRITE);
-  GENERATE(Token::ADD, STRING, STRING, STRING, NO_OVERWRITE);
   GENERATE(Token::BIT_AND, INT32, INT32, INT32, NO_OVERWRITE);
   GENERATE(Token::BIT_AND, INT32, INT32, INT32, OVERWRITE_LEFT);
   GENERATE(Token::BIT_AND, INT32, INT32, INT32, OVERWRITE_RIGHT);
   GENERATE(Token::BIT_AND, INT32, INT32, SMI, NO_OVERWRITE);
   GENERATE(Token::BIT_AND, INT32, INT32, SMI, OVERWRITE_RIGHT);
   GENERATE(Token::BIT_AND, INT32, SMI, INT32, NO_OVERWRITE);
   GENERATE(Token::BIT_AND, INT32, SMI, INT32, OVERWRITE_RIGHT);
   GENERATE(Token::BIT_AND, INT32, SMI, SMI, NO_OVERWRITE);
   GENERATE(Token::BIT_AND, INT32, SMI, SMI, OVERWRITE_LEFT);
   GENERATE(Token::BIT_AND, INT32, SMI, SMI, OVERWRITE_RIGHT);
@@ skipping 179 matching lines @@
   }
   ASSERT_NE(GENERIC, result_kind);
   return KindToType(result_kind, isolate);
 }
 
 
 void BinaryOpIC::State::Print(StringStream* stream) const {
   stream->Add("(%s", Token::Name(op_));
   if (mode_ == OVERWRITE_LEFT) stream->Add("_ReuseLeft");
   else if (mode_ == OVERWRITE_RIGHT) stream->Add("_ReuseRight");
-  if (CouldCreateAllocationMementos()) stream->Add("_CreateAllocationMementos");
   stream->Add(":%s*", KindToString(left_kind_));
   if (fixed_right_arg_.has_value) {
     stream->Add("%d", fixed_right_arg_.value);
   } else {
     stream->Add("%s", KindToString(right_kind_));
   }
   stream->Add("->%s)", KindToString(result_kind_));
 }
 
 
@@ skipping 19 matching lines @@
 
   result_kind_ = UpdateKind(result, result_kind_);
 
   if (!Token::IsTruncatingBinaryOp(op_)) {
     Kind input_kind = Max(left_kind_, right_kind_);
     if (result_kind_ < input_kind && input_kind <= NUMBER) {
       result_kind_ = input_kind;
     }
   }
 
-  // We don't want to distinguish INT32 and NUMBER for string add (because
-  // NumberToString can't make use of this anyway).
-  if (left_kind_ == STRING && right_kind_ == INT32) {
-    ASSERT_EQ(STRING, result_kind_);
-    ASSERT_EQ(Token::ADD, op_);
-    right_kind_ = NUMBER;
-  } else if (right_kind_ == STRING && left_kind_ == INT32) {
-    ASSERT_EQ(STRING, result_kind_);
-    ASSERT_EQ(Token::ADD, op_);
-    left_kind_ = NUMBER;
-  }
-
   // Reset overwrite mode unless we can actually make use of it, or may be able
   // to make use of it at some point in the future.
   if ((mode_ == OVERWRITE_LEFT && left_kind_ > NUMBER) ||
       (mode_ == OVERWRITE_RIGHT && right_kind_ > NUMBER) ||
       result_kind_ > NUMBER) {
     mode_ = NO_OVERWRITE;
   }
 
   if (old_extra_ic_state == GetExtraICState()) {
     // Tagged operations can lead to non-truncating HChanges
@@ skipping 65 matching lines @@
     case SMI: type = Type::Smi(); break;
     case INT32: type = Type::Signed32(); break;
     case NUMBER: type = Type::Number(); break;
     case STRING: type = Type::String(); break;
     case GENERIC: type = Type::Any(); break;
   }
   return handle(type, isolate);
 }
 
 
-MaybeObject* BinaryOpIC::Transition(Handle<AllocationSite> allocation_site,
-                                    Handle<Object> left,
-                                    Handle<Object> right) {
+MaybeObject* BinaryOpIC::Transition(Handle<Object> left, Handle<Object> right) {
   State state(target()->extended_extra_ic_state());
 
   // Compute the actual result using the builtin for the binary operation.
   Object* builtin = isolate()->js_builtins_object()->javascript_builtin(
       TokenToJSBuiltin(state.op()));
   Handle<JSFunction> function = handle(JSFunction::cast(builtin), isolate());
   bool caught_exception;
   Handle<Object> result = Execution::Call(
       isolate(), function, left, 1, &right, &caught_exception);
   if (caught_exception) return Failure::Exception();
 
   // Compute the new state.
   State old_state = state;
   state.Update(left, right, result);
 
-  // Check if we have a string operation here.
-  Handle<Code> target;
-  if (!allocation_site.is_null() || state.ShouldCreateAllocationMementos()) {
-    // Setup the allocation site on-demand.
-    if (allocation_site.is_null()) {
-      allocation_site = isolate()->factory()->NewAllocationSite();
-    }
-
-    // Install the stub with an allocation site.
-    BinaryOpICWithAllocationSiteStub stub(state);
-    target = stub.GetCodeCopyFromTemplate(isolate(), allocation_site);
-
-    // Sanity check the trampoline stub.
-    ASSERT_EQ(*allocation_site, target->FindFirstAllocationSite());
-  } else {
-    // Install the generic stub.
-    BinaryOpICStub stub(state);
-    target = stub.GetCode(isolate());
-
-    // Sanity check the generic stub.
-    ASSERT_EQ(NULL, target->FindFirstAllocationSite());
-  }
-  set_target(*target);
+  // Install the new stub.
+  BinaryOpICStub stub(state);
+  set_target(*stub.GetCode(isolate()));
 
   if (FLAG_trace_ic) {
     char buffer[150];
     NoAllocationStringAllocator allocator(
         buffer, static_cast<unsigned>(sizeof(buffer)));
     StringStream stream(&allocator);
     stream.Add("[BinaryOpIC");
     old_state.Print(&stream);
     stream.Add(" => ");
     state.Print(&stream);
-    stream.Add(" @ %p <- ", static_cast<void*>(*target));
+    stream.Add(" @ %p <- ", static_cast<void*>(*target()));
     stream.OutputToStdOut();
     JavaScriptFrame::PrintTop(isolate(), stdout, false, true);
-    if (!allocation_site.is_null()) {
-      PrintF(" using allocation site %p", static_cast<void*>(*allocation_site));
-    }
     PrintF("]\n");
   }
 
   // Patch the inlined smi code as necessary.
   if (!old_state.UseInlinedSmiCode() && state.UseInlinedSmiCode()) {
     PatchInlinedSmiCode(address(), ENABLE_INLINED_SMI_CHECK);
   } else if (old_state.UseInlinedSmiCode() && !state.UseInlinedSmiCode()) {
     PatchInlinedSmiCode(address(), DISABLE_INLINED_SMI_CHECK);
   }
 
   return *result;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, BinaryOpIC_Miss) {
   HandleScope scope(isolate);
-  ASSERT_EQ(2, args.length());
   Handle<Object> left = args.at<Object>(BinaryOpICStub::kLeft);
   Handle<Object> right = args.at<Object>(BinaryOpICStub::kRight);
   BinaryOpIC ic(isolate);
-  return ic.Transition(Handle<AllocationSite>::null(), left, right);
+  return ic.Transition(left, right);
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, BinaryOpIC_MissWithAllocationSite) {
-  HandleScope scope(isolate);
-  ASSERT_EQ(3, args.length());
-  Handle<AllocationSite> allocation_site = args.at<AllocationSite>(
-      BinaryOpWithAllocationSiteStub::kAllocationSite);
-  Handle<Object> left = args.at<Object>(
-      BinaryOpWithAllocationSiteStub::kLeft);
-  Handle<Object> right = args.at<Object>(
-      BinaryOpWithAllocationSiteStub::kRight);
-  BinaryOpIC ic(isolate);
-  return ic.Transition(allocation_site, left, right);
-}
-
-
 Code* CompareIC::GetRawUninitialized(Isolate* isolate, Token::Value op) {
   ICCompareStub stub(op, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED);
   Code* code = NULL;
   CHECK(stub.FindCodeInCache(&code, isolate));
   return code;
 }
 
 
 Handle<Code> CompareIC::GetUninitialized(Isolate* isolate, Token::Value op) {
   ICCompareStub stub(op, UNINITIALIZED, UNINITIALIZED, UNINITIALIZED);
@@ skipping 350 matching lines @@
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) {
   return IC_utilities[id];
 }
 
 
 } }  // namespace v8::internal