Inline loading of immutable properties

src/hydrogen.cc

 // Copyright 2013 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 5582 matching lines @@
 
 
 HInstruction* HOptimizedGraphBuilder::BuildMonomorphicAccess(
     PropertyAccessInfo* info,
     HValue* object,
     HValue* checked_object,
     HValue* value,
     BailoutId ast_id,
     BailoutId return_id,
     bool can_inline_accessor) {
+  // See if this is a load for an immutable property
+  if (info->IsLoad() && info->lookup()->IsFound() &&
+      info->lookup()->IsCacheable() && info->lookup()->IsReadOnly() &&
+      info->lookup()->IsDontDelete() && !info->map()->is_observed()) {
+    Handle<Object> value(isolate()->heap()->the_hole_value(), isolate());
+
+    if (!info->has_holder()) {
+      if (object->IsConstant() &&
+          HConstant::cast(object)->handle(isolate())->IsJSObject()) {
+        Handle<JSObject> js_object = HConstant::cast(object)->handle(isolate());
+        LookupResult lookup(isolate());
+        js_object->Lookup(*info->name(), &lookup);
+        value = handle(lookup.GetLazyValue(), isolate());
+      }
+    } else {
+      value = handle(info->lookup()->GetLazyValue(), isolate());
+    }
+
+    if (!value->IsTheHole()) {
+      AddCheckMapsUntilHolder(info->holder(), info->map(), checked_object);
+      return New<HConstant>(value);
+    }
+  }
 
   HObjectAccess access = HObjectAccess::ForMap();  // bogus default
   if (info->GetJSObjectFieldAccess(&access)) {
     ASSERT(info->IsLoad());
     return New<HLoadNamedField>(object, checked_object, access);
   }
 
   HValue* checked_holder = checked_object;
   if (info->has_holder()) {
     Handle<JSObject> prototype(JSObject::cast(info->map()->prototype()));
@@ skipping 1171 matching lines @@
     BuildConstantMapCheck(prototype, top_info());
     prototype = handle(JSObject::cast(prototype->GetPrototype()));
   }
 
   HInstruction* checked_object = BuildConstantMapCheck(prototype, top_info());
   if (!checked_object->IsLinked()) AddInstruction(checked_object);
   return checked_object;
 }
 
 
+void HOptimizedGraphBuilder::AddCheckMapsUntilHolder(Handle<JSObject> holder,
+                                                     Handle<Map> receiver_map,
+                                                     HValue* checked_object) {
+  if (holder.is_null()) {
+    HInstruction::cast(checked_object)->DeleteAndReplaceWith(NULL);
+  } else {
+    Handle<JSObject> prototype(JSObject::cast(receiver_map->prototype()));
+    do {
+      if (prototype.is_identical_to(holder)) return;
+      BuildConstantMapCheck(prototype, top_info());
+      prototype = handle(JSObject::cast(prototype->GetPrototype()));
+    } while (true);
+  }
+}
+
+
 void HOptimizedGraphBuilder::AddCheckPrototypeMaps(Handle<JSObject> holder,
                                                    Handle<Map> receiver_map) {
   if (!holder.is_null()) {
     Handle<JSObject> prototype(JSObject::cast(receiver_map->prototype()));
     BuildCheckPrototypeMaps(prototype, holder);
   }
 }
 
 
 HInstruction* HOptimizedGraphBuilder::NewPlainFunctionCall(
@@ skipping 4697 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal