[Interpreter] Avoid dereferencing handles on BytecodeGenerator for AST operations.

src/ast/ast.h

 // Copyright 2012 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.
 
 #ifndef V8_AST_AST_H_
 #define V8_AST_AST_H_
 
 #include "src/ast/ast-value-factory.h"
 #include "src/ast/modules.h"
 #include "src/ast/variables.h"
@@ skipping 300 matching lines @@
   // True iff the expression is a valid reference expression.
   bool IsValidReferenceExpression() const;
 
   // Helpers for ToBoolean conversion.
   bool ToBooleanIsTrue() const;
   bool ToBooleanIsFalse() const;
 
   // Symbols that cannot be parsed as array indices are considered property
   // names.  We do not treat symbols that can be array indexes as property
   // names because [] for string objects is handled only by keyed ICs.
-  bool IsPropertyName() const;
+  bool IsPropertyName(

[marja, 2016/08/08 08:20:13]

For all calls, the guarantee you want to give is that the call w/ kAllowed
yields the same result as the call w/ kDisallowed + CanonicalHandleScope, right?
Can this be documented somewhere?

[rmcilroy, 2016/08/08 13:05:56]

For GetCallType yes this is the case. For IsPropertyName both should actually
give the same result (even without CanonicalHandleScope), it's just that
kDisallowed might be slower since it uses StringToArrayIndex() instead of
String::ToArrayIndex().

Added comments as such.

+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) const;
 
   // True iff the expression is a class or function expression without
   // a syntactic name.
   bool IsAnonymousFunctionDefinition() const;
 
   // True iff the expression is a literal represented as a smi.
   bool IsSmiLiteral() const;
 
   // True iff the expression is a string literal.
   bool IsStringLiteral() const;
@@ skipping 902 matching lines @@
 
   Statement* statement_;
   Scope* const scope_;
 };
 
 
 class Literal final : public Expression {
  public:
   DECLARE_NODE_TYPE(Literal)
 
-  bool IsPropertyName() const { return value_->IsPropertyName(); }
+  bool IsPropertyName(
+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) const {
+    return value_->IsPropertyName(deref_mode);
+  }
 
   Handle<String> AsPropertyName() {
-    DCHECK(IsPropertyName());
+    DCHECK(IsPropertyName(HandleDereferenceMode::kHandleDereferenceDisallowed));
     return Handle<String>::cast(value());
   }
 
   const AstRawString* AsRawPropertyName() {
     DCHECK(IsPropertyName());
     return value_->AsString();
   }
 
-  bool ToBooleanIsTrue() const { return value()->BooleanValue(); }
-  bool ToBooleanIsFalse() const { return !value()->BooleanValue(); }
+  bool ToBooleanIsTrue() const { return raw_value()->BooleanValue(); }
+  bool ToBooleanIsFalse() const { return !raw_value()->BooleanValue(); }
 
   Handle<Object> value() const { return value_->value(); }
   const AstValue* raw_value() const { return value_; }
 
   // Support for using Literal as a HashMap key. NOTE: Currently, this works
   // only for string and number literals!
   uint32_t Hash();
   static bool Match(void* literal1, void* literal2);
 
   static int num_ids() { return parent_num_ids() + 1; }
@@ skipping 136 matching lines @@
 // for minimizing the work when constructing it at runtime.
 class ObjectLiteral final : public MaterializedLiteral {
  public:
   typedef ObjectLiteralProperty Property;
 
   DECLARE_NODE_TYPE(ObjectLiteral)
 
   Handle<FixedArray> constant_properties() const {
     return constant_properties_;
   }
-  int properties_count() const { return constant_properties_->length() / 2; }
+  int properties_count() const { return boilerplate_properties_; }
   ZoneList<Property*>* properties() const { return properties_; }
   bool fast_elements() const { return fast_elements_; }
   bool may_store_doubles() const { return may_store_doubles_; }
   bool has_elements() const { return has_elements_; }
   bool has_shallow_properties() const {
     return depth() == 1 && !has_elements() && !may_store_doubles();
   }
 
   // Decide if a property should be in the object boilerplate.
   static bool IsBoilerplateProperty(Property* property);
@@ skipping 354 matching lines @@
     FeedbackVectorSlotKind kind = key()->IsPropertyName()
                                       ? FeedbackVectorSlotKind::LOAD_IC
                                       : FeedbackVectorSlotKind::KEYED_LOAD_IC;
     property_feedback_slot_ = spec->AddSlot(kind);
   }
 
   FeedbackVectorSlot PropertyFeedbackSlot() const {
     return property_feedback_slot_;
   }
 
-  static LhsKind GetAssignType(Property* property) {
+  static LhsKind GetAssignType(
+      Property* property,
+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) {
     if (property == NULL) return VARIABLE;
     bool super_access = property->IsSuperAccess();
-    return (property->key()->IsPropertyName())
+    return (property->key()->IsPropertyName(deref_mode))
                ? (super_access ? NAMED_SUPER_PROPERTY : NAMED_PROPERTY)
                : (super_access ? KEYED_SUPER_PROPERTY : KEYED_PROPERTY);
   }
 
  protected:
   Property(Zone* zone, Expression* obj, Expression* key, int pos)
       : Expression(zone, pos, kProperty),
         bit_field_(IsForCallField::encode(false) |
                    IsStringAccessField::encode(false) |
                    InlineCacheStateField::encode(UNINITIALIZED)),
@@ skipping 94 matching lines @@
     LOOKUP_SLOT_CALL,
     NAMED_PROPERTY_CALL,
     KEYED_PROPERTY_CALL,
     NAMED_SUPER_PROPERTY_CALL,
     KEYED_SUPER_PROPERTY_CALL,
     SUPER_CALL,
     OTHER_CALL
   };
 
   // Helpers to determine how to handle the call.
-  CallType GetCallType(Isolate* isolate) const;
-  bool IsUsingCallFeedbackSlot(Isolate* isolate) const;
-  bool IsUsingCallFeedbackICSlot(Isolate* isolate) const;
+  CallType GetCallType(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) const;
+  bool IsUsingCallFeedbackSlot(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) const;
+  bool IsUsingCallFeedbackICSlot(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode =
+          HandleDereferenceMode::kHandleDereferenceAllowed) const;
 
 #ifdef DEBUG
   // Used to assert that the FullCodeGenerator records the return site.
   bool return_is_recorded_;
 #endif
 
  protected:
   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
        int pos)
       : Expression(zone, pos, kCall),
@@ skipping 1628 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_