fix the compare nil ic

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 27 matching lines @@
 namespace internal {
 
 
 CodeStubInterfaceDescriptor::CodeStubInterfaceDescriptor()
     : register_param_count_(-1),
       stack_parameter_count_(NULL),
       hint_stack_parameter_count_(-1),
       function_mode_(NOT_JS_FUNCTION_STUB_MODE),
       register_params_(NULL),
       deoptimization_handler_(NULL),
-      miss_handler_(IC_Utility(IC::kUnreachable), Isolate::Current()) { }
+      miss_handler_(IC_Utility(IC::kUnreachable), Isolate::Current()),
+      has_miss_handler_(false) { }
 
 
 bool CodeStub::FindCodeInCache(Code** code_out, Isolate* isolate) {
   UnseededNumberDictionary* stubs = isolate->heap()->code_stubs();
   int index = stubs->FindEntry(GetKey());
   if (index != UnseededNumberDictionary::kNotFound) {
     *code_out = Code::cast(stubs->ValueAt(index));
     return true;
   }
   return false;
@@ skipping 344 matching lines @@
       break;
     case CompareIC::GENERIC:
       GenerateGeneric(masm);
       break;
   }
 }
 
 
 void CompareNilICStub::Record(Handle<Object> object) {
   ASSERT(types_ != Types::FullCompare());
+  Types old_types(types_);
   if (equality_kind_ == kStrictEquality) {
     // When testing for strict equality only one value will evaluate to true
     types_.RemoveAll();
     types_.Add((nil_value_ == kNullValue) ? NULL_TYPE:
                                             UNDEFINED);
   } else {
     if (object->IsNull()) {
       types_.Add(NULL_TYPE);
     } else if (object->IsUndefined()) {
       types_.Add(UNDEFINED);
     } else if (object->IsUndetectableObject() ||
                object->IsOddball() ||
                !object->IsHeapObject()) {
       types_ = Types::FullCompare();
     } else if (IsMonomorphic()) {
       types_ = Types::FullCompare();
     } else {
       types_.Add(MONOMORPHIC_MAP);
     }
   }
+  old_types.TraceTransition(types_);
 }
 
 
+void CompareNilICStub::Types::TraceTransition(Types to) const {
+  if (!FLAG_trace_ic) return;
+  char buffer[100];
+  NoAllocationStringAllocator allocator(buffer,
+                                        static_cast<unsigned>(sizeof(buffer)));
+  StringStream stream(&allocator);
+  stream.Add("[CompareNilIC (");
+  Print(&stream);
+  stream.Add("->");
+  to.Print(&stream);
+  stream.Add(")]\n");
+  stream.OutputToStdOut();
+}
+
+
 void CompareNilICStub::PrintName(StringStream* stream) {
   stream->Add("CompareNilICStub_");
   types_.Print(stream);
   stream->Add((nil_value_ == kNullValue) ? "(NullValue|":
                                            "(UndefinedValue|");
   stream->Add((equality_kind_ == kStrictEquality) ? "StrictEquality)":
                                                     "NonStrictEquality)");
 }
 
 
@@ skipping 297 matching lines @@
   } else if (argument_count >= 2) {
     argument_count_ = MORE_THAN_ONE;
   } else {
     UNREACHABLE();
   }
   ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 }
 
 
 } }  // namespace v8::internal