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

src/ast/ast-value-factory.cc

 // Copyright 2014 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 75 matching lines @@
 void AstRawString::Internalize(Isolate* isolate) {
   if (!string_.is_null()) return;
   if (literal_bytes_.length() == 0) {
     string_ = isolate->factory()->empty_string();
   } else {
     AstRawStringInternalizationKey key(this);
     string_ = StringTable::LookupKey(isolate, &key);
   }
 }
 
-
-bool AstRawString::AsArrayIndex(uint32_t* index) const {
-  if (!string_.is_null())
+bool AstRawString::AsArrayIndex(uint32_t* index,
+                                HandleDereferenceMode deref_mode) const {
+  if (deref_mode == HandleDereferenceMode::kHandleDereferenceAllowed &&
+      !string_.is_null())
     return string_->AsArrayIndex(index);
   if (!is_one_byte_ || literal_bytes_.length() == 0 ||
       literal_bytes_.length() > String::kMaxArrayIndexSize)
     return false;
   OneByteStringStream stream(literal_bytes_);
   return StringToArrayIndex(&stream, index);
 }
 
 
 bool AstRawString::IsOneByteEqualTo(const char* data) const {
   int length = static_cast<int>(strlen(data));
   if (is_one_byte_ && literal_bytes_.length() == length) {
     const char* token = reinterpret_cast<const char*>(literal_bytes_.start());
     return !strncmp(token, data, length);
   }
   return false;
 }
 
 
 void AstConsString::Internalize(Isolate* isolate) {
   // AstRawStrings are internalized before AstConsStrings so left and right are
   // already internalized.
   string_ = isolate->factory()
                 ->NewConsString(left_->string(), right_->string())
                 .ToHandleChecked();
 }
 
-
-bool AstValue::IsPropertyName() const {
+bool AstValue::IsPropertyName(HandleDereferenceMode deref_mode) const {
   if (type_ == STRING) {
     uint32_t index;
-    return !string_->AsArrayIndex(&index);
+    return !string_->AsArrayIndex(&index, deref_mode);
   }
   return false;
 }
 
 
 bool AstValue::BooleanValue() const {
   switch (type_) {
     case STRING:
       DCHECK(string_ != NULL);
       return !string_->IsEmpty();
@@ skipping 115 matching lines @@
   }
   return new_string;
 }
 
 
 void AstValueFactory::Internalize(Isolate* isolate) {
   if (isolate_) {
     // Everything is already internalized.
     return;
   }
+
+  // Create a canonical handle scope if compiling ignition bytecode. This is
+  // required by the constant array builder to de-duplicate common objects
+  // without dereferencing handles.
+  std::unique_ptr<CanonicalHandleScope> canonical;
+  if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(isolate));
+

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

This code snippet seems to be on a wrong abstraction level; AstValueFactory
shouldn't know anything about Ignition. Can this be done somewhere on the
caller's side a couple of layers up?

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

Moved up to api.cc and compiler-dispatcher-job.cc.

   // Strings need to be internalized before values, because values refer to
   // strings.
   for (int i = 0; i < strings_.length(); ++i) {
     strings_[i]->Internalize(isolate);
   }
   for (int i = 0; i < values_.length(); ++i) {
     values_[i]->Internalize(isolate);
   }
   isolate_ = isolate;
 }
@@ skipping 130 matching lines @@
                                   length) == 0;
     } else {
       return CompareCharsUnsigned(reinterpret_cast<const uint16_t*>(l),
                                   reinterpret_cast<const uint16_t*>(r),
                                   length) == 0;
     }
   }
 }
 }  // namespace internal
 }  // namespace v8