Optimize GetPrototype

src/hydrogen.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 12372 matching lines @@
 void HOptimizedGraphBuilder::GenerateDebugIsActive(CallRuntime* call) {
   DCHECK(call->arguments()->length() == 0);
   HValue* ref =
       Add<HConstant>(ExternalReference::debug_is_active_address(isolate()));
   HValue* value = Add<HLoadNamedField>(
       ref, static_cast<HValue*>(NULL), HObjectAccess::ForExternalUInteger8());
   return ast_context()->ReturnValue(value);
 }
 
 
+void HOptimizedGraphBuilder::GenerateGetPrototype(CallRuntime* call) {
+  DCHECK(call->arguments()->length() == 1);
+  CHECK_ALIVE(VisitForValue(call->arguments()->at(0)));
+  HValue* object = Pop();
+
+  NoObservableSideEffectsScope no_effects(this);
+
+  HValue* map = Add<HLoadNamedField>(object, static_cast<HValue*>(NULL),
+                                     HObjectAccess::ForMap());
+  HValue* bit_field = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
+                                           HObjectAccess::ForMapBitField());
+  HValue* is_access_check_needed_mask =
+      Add<HConstant>(1 << Map::kIsAccessCheckNeeded);
+  HValue* is_access_check_needed_test = AddUncasted<HBitwise>(
+      Token::BIT_AND, bit_field, is_access_check_needed_mask);
+
+  HValue* proto = Add<HLoadNamedField>(map, static_cast<HValue*>(NULL),
+                                       HObjectAccess::ForPrototype());
+  HValue* proto_map = Add<HLoadNamedField>(proto, static_cast<HValue*>(NULL),
+                                           HObjectAccess::ForMap());
+  HValue* proto_bit_field = Add<HLoadNamedField>(
+      proto_map, static_cast<HValue*>(NULL), HObjectAccess::ForMapBitField());
+  HValue* is_hidden_prototype_mask =
+      Add<HConstant>(1 << Map::kIsHiddenPrototype);
+  HValue* is_hidden_prototype_test = AddUncasted<HBitwise>(
+      Token::BIT_AND, proto_bit_field, is_hidden_prototype_mask);
+
+  {
+    IfBuilder needs_runtime(this);
+    needs_runtime.If<HCompareNumericAndBranch>(
+        is_access_check_needed_test, graph()->GetConstant0(), Token::NE);
+    needs_runtime.OrIf<HCompareNumericAndBranch>(
+        is_hidden_prototype_test, graph()->GetConstant0(), Token::NE);
+
+    needs_runtime.Then();
+    {
+      Add<HPushArguments>(object);
+      HValue* result = Add<HCallRuntime>(
+          call->name(), Runtime::FunctionForId(Runtime::kGetPrototype), 1);
+      ast_context()->ReturnValue(result);

[arv (Not doing code reviews), 2014/12/05 15:30:05]

Other places usually do a push/pop in this case but it seems cleaner to skip
these extra instructions.

[Dmitry Lomov (no reviews), 2014/12/05 15:39:20]

Nit: could you keep the push/pop code pattern? This makes it very clear that
only one value is ever returned from this Visit method. (Push/Pop has no effect
on resulting codegen)

+    }
+
+    needs_runtime.Else();
+    ast_context()->ReturnValue(proto);
+  }
+}
+
+
 #undef CHECK_BAILOUT
 #undef CHECK_ALIVE
 
 
 HEnvironment::HEnvironment(HEnvironment* outer,
                            Scope* scope,
                            Handle<JSFunction> closure,
                            Zone* zone)
     : closure_(closure),
       values_(0, zone),
@@ skipping 617 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal