[Interpreter] Enable allocation site mementos in CreateArrayLiterals.

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
@@ skipping 1864 matching lines @@
         break;
     }
   }
 
   execution_result()->SetResultInRegister(literal);
 }
 
 void BytecodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   // Deep-copy the literal boilerplate.
   builder()->CreateArrayLiteral(expr->constant_elements(),
-                                expr->literal_index(),
-                                expr->ComputeFlags(true));

[mythria, 2016/09/02 15:06:53]

Ross, I think this is the only change that is required for enabling mementos. We
call in to the runtime which already handles it. Was there any reason we
disabled it earlier? When Klass finishes porting the FastCloneShallowObjectStub
I think it should still work.

[rmcilroy, 2016/09/05 09:28:33]

AST Graph Builder doesn't create mementos (presumably because we don't need to
collect any more feedback once we are in optimized code). Maybe we need to
explicitly prevent mementos in BytecodeGraphBuilder to be consistent with
ASTGraphBuilder. 

Michi, what do you think?

[Michael Starzinger, 2016/09/05 12:23:04]

Yes, correct. The reasoning was that only the unoptimized code would collect
feedback and once we optimize the decision was "settled". We decided to go with
this approach until we'd see data to the contrary. Being consistent for now and
preventing creation of mementos in the BytecodeGraphBuilder sounds reasonable to
me (with a comment, explaining exactly this). I also CCed Michael Stanton about
this.

+                                expr->literal_index(), expr->ComputeFlags());
   Register index, literal;
 
   // Evaluate all the non-constant subexpressions and store them into the
   // newly cloned array.
   bool literal_in_accumulator = true;
   for (int array_index = 0; array_index < expr->values()->length();
        array_index++) {
     Expression* subexpr = expr->values()->at(array_index);
     if (CompileTimeValue::IsCompileTimeValue(subexpr)) continue;
     DCHECK(!subexpr->IsSpread());
@@ skipping 1507 matching lines @@
   return execution_context()->scope()->language_mode();
 }
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return TypeFeedbackVector::GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8