[Interpreter] Fix a register allocation bug and add a DCHECK.

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/compiler.h"
 #include "src/interpreter/control-flow-builders.h"
 #include "src/objects.h"
 #include "src/parser.h"
@@ skipping 175 matching lines @@
   }
 
  protected:
   void set_result_identified() {
     DCHECK(!result_identified());
     result_identified_ = true;
   }
 
   bool result_identified() const { return result_identified_; }
 
+  const TemporaryRegisterScope* allocator() const { return &allocator_; }
+
  private:
   BytecodeGenerator* generator_;
   Expression::Context kind_;
   ExpressionResultScope* outer_;
   TemporaryRegisterScope allocator_;
   bool result_identified_;
 
   DISALLOW_COPY_AND_ASSIGN(ExpressionResultScope);
 };
 
@@ skipping 39 matching lines @@
       : ExpressionResultScope(generator, Expression::kValue) {}
 
   virtual void SetResultInAccumulator() {
     result_register_ = outer()->NewRegister();
     builder()->StoreAccumulatorInRegister(result_register_);
     set_result_identified();
   }
 
   virtual void SetResultInRegister(Register reg) {
     DCHECK(builder()->RegisterIsParameterOrLocal(reg) ||
-           builder()->RegisterIsTemporary(reg));
+           (builder()->RegisterIsTemporary(reg) &&
+            !allocator()->RegisterIsAllocatedInThisScope(reg)));
     result_register_ = reg;
     set_result_identified();
   }
 
   Register ResultRegister() const { return result_register_; }
 
  private:
   Register result_register_;
 };
 
@@ skipping 202 matching lines @@
   builder()->LoadLiteral(Smi::FromInt(encoded_flags));
   builder()->StoreAccumulatorInRegister(flags);
   DCHECK(flags.index() == pairs.index() + 1);
 
   builder()->CallRuntime(Runtime::kDeclareGlobals, pairs, 2);
   globals()->clear();
 }
 
 
 void BytecodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
+  // TODO(rmcilroy): Replace this with a StatementResultScope when it exists.
+  EffectResultScope effect_scope(this);
   VisitForEffect(stmt->expression());
 }
 
 
 void BytecodeGenerator::VisitEmptyStatement(EmptyStatement* stmt) {
 }
 
 
 void BytecodeGenerator::VisitIfStatement(IfStatement* stmt) {
   // TODO(oth): Spot easy cases where there code would not need to
@@ skipping 27 matching lines @@
   execution_control()->Continue(stmt->target());
 }
 
 
 void BytecodeGenerator::VisitBreakStatement(BreakStatement* stmt) {
   execution_control()->Break(stmt->target());
 }
 
 
 void BytecodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
+  EffectResultScope effect_scope(this);
   VisitForAccumulatorValue(stmt->expression());
   builder()->Return();
 }
 
 
 void BytecodeGenerator::VisitWithStatement(WithStatement* stmt) {
   UNIMPLEMENTED();
 }
 
 
@@ skipping 942 matching lines @@
       UNIMPLEMENTED();
   }
 
   // Convert old value into a number.
   if (!is_strong(language_mode())) {
     builder()->CastAccumulatorToNumber();
   }
 
   // Save result for postfix expressions.
   if (is_postfix) {
-    old_value = execution_result()->NewRegister();
+    old_value = execution_result()->outer()->NewRegister();
     builder()->StoreAccumulatorInRegister(old_value);
   }
 
   // Perform +1/-1 operation.
   builder()->CountOperation(expr->binary_op(), language_mode_strength());
 
   // Store the value.
   FeedbackVectorSlot feedback_slot = expr->CountSlot();
   switch (assign_type) {
     case VARIABLE: {
@@ skipping 382 matching lines @@
 }
 
 
 int BytecodeGenerator::feedback_index(FeedbackVectorSlot slot) const {
   return info()->feedback_vector()->GetIndex(slot);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8