[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 296 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;
+  // Produces the same result whether |deref_mode| is kAllowed or kDisallowed,
+  // although may be faster with kAllowed.
+  bool IsPropertyName(
+      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) 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 868 matching lines @@
         statement_(statement),
         scope_(scope) {}
 
   Statement* statement_;
   Scope* const scope_;
 };
 
 
 class Literal final : public Expression {
  public:
-  bool IsPropertyName() const { return value_->IsPropertyName(); }
+  // Returns true if literal represents a property name (i.e. cannot be parsed
+  // as array indices). Produces the same result whether |deref_mode| is
+  // kAllowed or kDisallowed, although may be faster with kAllowed.
+  bool IsPropertyName(HandleDereferenceMode deref_mode =
+                          HandleDereferenceMode::kAllowed) const {
+    return value_->IsPropertyName(deref_mode);
+  }
 
   Handle<String> AsPropertyName() {
-    DCHECK(IsPropertyName());
+    DCHECK(IsPropertyName(HandleDereferenceMode::kDisallowed));
     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 134 matching lines @@
 
 // An object literal has a boilerplate object that is used
 // for minimizing the work when constructing it at runtime.
 class ObjectLiteral final : public MaterializedLiteral {
  public:
   typedef ObjectLiteralProperty Property;
 
   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) {
+  // Returns the properties assign type. Produces the same result whether
+  // |deref_mode| is kAllowed or kDisallowed, although may be faster with
+  // kAllowed.
+  static LhsKind GetAssignType(
+      Property* property,
+      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) {
     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);
   }
 
  private:
   friend class AstNodeFactory;
 
   Property(Zone* zone, Expression* obj, Expression* key, int pos)
       : Expression(zone, pos, kProperty),
         bit_field_(IsForCallField::encode(false) |
@@ 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;
+  // If called with |deref_mode| of kDisallowed, then the AST nodes must have
+  // been internalized within a CanonicalHandleScope.
+  CallType GetCallType(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) const;
+  bool IsUsingCallFeedbackSlot(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) const;
+  bool IsUsingCallFeedbackICSlot(
+      Isolate* isolate,
+      HandleDereferenceMode deref_mode = HandleDereferenceMode::kAllowed) const;
 
 #ifdef DEBUG
   // Used to assert that the FullCodeGenerator records the return site.
   bool return_is_recorded_;
 #endif
 
  private:
   friend class AstNodeFactory;
 
   Call(Zone* zone, Expression* expression, ZoneList<Expression*>* arguments,
@@ skipping 1607 matching lines @@
                                     : NULL;                                   \
   }
 AST_NODE_LIST(DECLARE_NODE_FUNCTIONS)
 #undef DECLARE_NODE_FUNCTIONS
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_AST_H_