Clean some unuse code of unary negation

src/code-stubs.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 190 matching lines @@
 void CodeStub::PrintName(StringStream* stream) {
   PrintBaseName(stream);
   PrintState(stream);
 }
 
 
 Builtins::JavaScript UnaryOpStub::ToJSBuiltin() {
   switch (operation_) {
     default:
       UNREACHABLE();
-    case Token::SUB:
-      return Builtins::UNARY_MINUS;

[Sven Panne, 2013/08/05 06:22:43]

I think that the whole builtin can be nuked, I'll do that separately.

     case Token::BIT_NOT:
       return Builtins::BIT_NOT;
   }
 }
 
 
 Handle<JSFunction> UnaryOpStub::ToJSFunction(Isolate* isolate) {
   Handle<JSBuiltinsObject> builtins(isolate->js_builtins_object());
   Object* builtin = builtins->javascript_builtin(ToJSBuiltin());
   return Handle<JSFunction>(JSFunction::cast(builtin), isolate);
 }
 
 
 MaybeObject* UnaryOpStub::Result(Handle<Object> object, Isolate* isolate) {
   Handle<JSFunction> builtin_function = ToJSFunction(isolate);
   bool caught_exception;
   Handle<Object> result = Execution::Call(builtin_function, object,
                                           0, NULL, &caught_exception);
   if (caught_exception) {
     return Failure::Exception();
   }
   return *result;
 }
 
 
 void UnaryOpStub::UpdateStatus(Handle<Object> object) {
   State old_state(state_);
   if (object->IsSmi()) {
     state_.Add(SMI);
-    if (operation_ == Token::SUB && *object == 0) {
-      // The result (-0) has to be represented as double.
-      state_.Add(HEAP_NUMBER);
-    }
   } else if (object->IsHeapNumber()) {
     state_.Add(HEAP_NUMBER);
   } else {
     state_.Add(GENERIC);
   }
   TraceTransition(old_state, state_);
 }
 
 
 Handle<Type> UnaryOpStub::GetType(Isolate* isolate) {
@@ skipping 93 matching lines @@
       UNREACHABLE();
   }
 }
 
 
 #undef __
 
 
 void UnaryOpStub::PrintBaseName(StringStream* stream) {
   CodeStub::PrintBaseName(stream);
-  if (operation_ == Token::SUB) stream->Add("Minus");
   if (operation_ == Token::BIT_NOT) stream->Add("Not");
 }
 
 
 void UnaryOpStub::PrintState(StringStream* stream) {
   state_.Print(stream);
 }
 
 
 void UnaryOpStub::State::Print(StringStream* stream) const {
@@ skipping 514 matching lines @@
   InstallDescriptor(isolate, &stub3);
 }
 
 InternalArrayConstructorStub::InternalArrayConstructorStub(
     Isolate* isolate) {
   InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
 } }  // namespace v8::internal