Remove prototype checks for leaf maps in optimized code.

src/objects-inl.h

 // 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 571 matching lines @@
 bool Object::IsDeoptimizationOutputData() {
   if (!IsFixedArray()) return false;
   // There's actually no way to see the difference between a fixed array and
   // a deoptimization data array.  Since this is used for asserts we can check
   // that the length is plausible though.
   if (FixedArray::cast(this)->length() % 2 != 0) return false;
   return true;
 }
 
 
-bool Object::IsDependentCodes() {
+bool Object::IsDependentCode() {
   if (!IsFixedArray()) return false;
   // There's actually no way to see the difference between a fixed array and
   // a dependent codes array.
   return true;
 }
 
 
 bool Object::IsTypeFeedbackCells() {
   if (!IsFixedArray()) return false;
   // There's actually no way to see the difference between a fixed array and
@@ skipping 1787 matching lines @@
 
 // ------------------------------------
 // Cast operations
 
 
 CAST_ACCESSOR(FixedArray)
 CAST_ACCESSOR(FixedDoubleArray)
 CAST_ACCESSOR(DescriptorArray)
 CAST_ACCESSOR(DeoptimizationInputData)
 CAST_ACCESSOR(DeoptimizationOutputData)
-CAST_ACCESSOR(DependentCodes)
+CAST_ACCESSOR(DependentCode)
 CAST_ACCESSOR(TypeFeedbackCells)
 CAST_ACCESSOR(SymbolTable)
 CAST_ACCESSOR(JSFunctionResultCache)
 CAST_ACCESSOR(NormalizedMapCache)
 CAST_ACCESSOR(ScopeInfo)
 CAST_ACCESSOR(CompilationCacheTable)
 CAST_ACCESSOR(CodeCacheHashTable)
 CAST_ACCESSOR(PolymorphicCodeCacheHashTable)
 CAST_ACCESSOR(MapCache)
 CAST_ACCESSOR(String)
@@ skipping 1013 matching lines @@
          has_slow_elements_kind() || has_external_array_elements());
   set_bit_field3(IsObserved::update(bit_field3(), is_observed));
 }
 
 
 bool Map::is_observed() {
   return IsObserved::decode(bit_field3());
 }
 
 
-void Map::AddDependentCode(Handle<Code> code) {
-  Handle<DependentCodes> codes =
-      DependentCodes::Append(Handle<DependentCodes>(dependent_codes()), code);
-  if (*codes != dependent_codes()) {
-    set_dependent_codes(*codes);
+void Map::NotifyObjectLayoutChange() {
+  dependent_code()->DeoptimizeDependentCodeGroup(
+      DependentCode::kPrototypeCheckGroup);
+}
+
+
+bool Map::CanOmitPrototypeChecks() {
+  return !HasTransitionArray() && !is_dictionary_map();
+}
+
+
+void Map::AddDependentCode(DependentCode::DependencyGroup group,
+                           Handle<Code> code) {
+  Handle<DependentCode> codes =
+      DependentCode::Insert(Handle<DependentCode>(dependent_code()),
+                             group, code);
+  if (*codes != dependent_code()) {
+    set_dependent_code(*codes);
   }
 }
 
 
-int DependentCodes::number_of_codes() {
+int DependentCode::number_of_entries(DependencyGroup group) {
   if (length() == 0) return 0;
-  return Smi::cast(get(kNumberOfCodesIndex))->value();
+  return Smi::cast(get(group))->value();
 }
 
 
-void DependentCodes::set_number_of_codes(int value) {
-  set(kNumberOfCodesIndex, Smi::FromInt(value));
+void DependentCode::set_number_of_entries(DependencyGroup group, int value) {
+  set(group, Smi::FromInt(value));
 }
 
 
-Code* DependentCodes::code_at(int i) {
-  return Code::cast(get(kCodesIndex + i));
+Code* DependentCode::code_at(int i) {
+  return Code::cast(get(kCodesStartIndex + i));
 }
 
 
-void DependentCodes::set_code_at(int i, Code* value) {
-  set(kCodesIndex + i, value);
+void DependentCode::set_code_at(int i, Code* value) {
+  set(kCodesStartIndex + i, value);
 }
 
 
-Object** DependentCodes::code_slot_at(int i) {
+Object** DependentCode::code_slot_at(int i) {
   return HeapObject::RawField(
-      this, FixedArray::OffsetOfElementAt(kCodesIndex + i));
+      this, FixedArray::OffsetOfElementAt(kCodesStartIndex + i));
 }
 
 
-void DependentCodes::clear_code_at(int i) {
-  set_undefined(kCodesIndex + i);
+void DependentCode::clear_code_at(int i) {
+  set_undefined(kCodesStartIndex + i);
 }
 
 
+void DependentCode::ExtendGroup(DependencyGroup group) {
+  GroupStartIndexes starts(this);
+  for (int g = kGroupCount - 1; g > group; g--) {
+    if (starts.at(g) < starts.at(g + 1)) {
+      set_code_at(starts.at(g + 1), code_at(starts.at(g)));
+    }
+  }
+}
+
+
 void Code::set_flags(Code::Flags flags) {
   STATIC_ASSERT(Code::NUMBER_OF_KINDS <= KindField::kMax + 1);
   // Make sure that all call stubs have an arguments count.
   ASSERT((ExtractKindFromFlags(flags) != CALL_IC &&
           ExtractKindFromFlags(flags) != KEYED_CALL_IC) ||
          ExtractArgumentsCountFromFlags(flags) >= 0);
   WRITE_INT_FIELD(this, kFlagsOffset, flags);
 }
 
 
@@ skipping 602 matching lines @@
 
 
 HeapObject* Map::UncheckedPrototypeTransitions() {
   ASSERT(HasTransitionArray());
   ASSERT(unchecked_transition_array()->HasPrototypeTransitions());
   return unchecked_transition_array()->UncheckedPrototypeTransitions();
 }
 
 
 ACCESSORS(Map, code_cache, Object, kCodeCacheOffset)
-ACCESSORS(Map, dependent_codes, DependentCodes, kDependentCodesOffset)
+ACCESSORS(Map, dependent_code, DependentCode, kDependentCodeOffset)
 ACCESSORS(Map, constructor, Object, kConstructorOffset)
 
 ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset)
 ACCESSORS(JSFunction, literals_or_bindings, FixedArray, kLiteralsOffset)
 ACCESSORS(JSFunction, next_function_link, Object, kNextFunctionLinkOffset)
 
 ACCESSORS(GlobalObject, builtins, JSBuiltinsObject, kBuiltinsOffset)
 ACCESSORS(GlobalObject, native_context, Context, kNativeContextOffset)
 ACCESSORS(GlobalObject, global_context, Context, kGlobalContextOffset)
 ACCESSORS(GlobalObject, global_receiver, JSObject, kGlobalReceiverOffset)
@@ skipping 1794 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_