[Interpreter] Add implementations for load immediate bytecodes.

src/interpreter/interpreter.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/interpreter.h"
 
 #include "src/compiler.h"
 #include "src/compiler/interpreter-assembler.h"
 #include "src/factory.h"
 #include "src/interpreter/bytecodes.h"
@@ skipping 49 matching lines @@
     Handle<FixedArray> handler_table) {
   DCHECK(handler_table->length() == static_cast<int>(Bytecode::kLast) + 1);
   return handler_table->get(0) != isolate_->heap()->undefined_value();
 }
 
 
 // LdaZero
 //
 // Load literal '0' into the accumulator.
 void Interpreter::DoLdaZero(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ NumberConstant(0.0));
   __ Dispatch();
 }
 
 
 // LdaSmi8 <imm8>
 //
 // Load an 8-bit integer literal into the accumulator as a Smi.
 void Interpreter::DoLdaSmi8(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement 8-bit integer to SMI promotion.
+  Node* raw_int = __ BytecodeOperandImm8(0);
+  __ SetAccumulator(__ SmiTag(raw_int));
   __ Dispatch();
 }
 
 
 // LdaUndefined
 //
 // Load Undefined into the accumulator.
 void Interpreter::DoLdaUndefined(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ HeapConstant(Unique<HeapObject>::CreateImmovable(
+      isolate_->factory()->undefined_value())));
   __ Dispatch();
 }
 
 
 // LdaNull
 //
 // Load Null into the accumulator.
 void Interpreter::DoLdaNull(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ HeapConstant(
+      Unique<HeapObject>::CreateImmovable(isolate_->factory()->null_value())));
   __ Dispatch();
 }
 
 
 // LdaTheHole
 //
 // Load TheHole into the accumulator.
 void Interpreter::DoLdaTheHole(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ HeapConstant(Unique<HeapObject>::CreateImmovable(
+      isolate_->factory()->the_hole_value())));
   __ Dispatch();
 }
 
 
 // LdaTrue
 //
 // Load True into the accumulator.
 void Interpreter::DoLdaTrue(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ HeapConstant(
+      Unique<HeapObject>::CreateImmovable(isolate_->factory()->true_value())));
   __ Dispatch();
 }
 
 
 // LdaFalse
 //
 // Load False into the accumulator.
 void Interpreter::DoLdaFalse(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ SetAccumulator(__ HeapConstant(
+      Unique<HeapObject>::CreateImmovable(isolate_->factory()->false_value())));
   __ Dispatch();
 }
 
 
 // Ldar <src>
 //
 // Load accumulator with value from register <src>.
 void Interpreter::DoLdar(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  Node* value = __ LoadRegister(__ BytecodeOperandReg(0));
+  __ SetAccumulator(value);
   __ Dispatch();
 }
 
 
 // Star <dst>
 //
 // Store accumulator to register <dst>.
 void Interpreter::DoStar(compiler::InterpreterAssembler* assembler) {
-  // TODO(rmcilroy) Implement.
+  __ StoreRegister(__ GetAccumulator(), __ BytecodeOperandReg(0));

[Michael Starzinger, 2015/08/17 08:22:34]

This pattern looks dangerous, note that C++ does not specify the evaluation
order or the argument, so here either "GetAccumulator" or "BytecodeOperandReg"
could be assembled first into the bytecode stream.

[rmcilroy, 2015/08/18 13:06:22]

Yeah good point. Note, in this case it doesn't matter for correctness which
argument is evaluated first, but agree that this could be confusing and
potentially dangerous later. Fixed to define the order.

   __ Dispatch();
 }
 
 
 // Add <src>
 //
 // Add register <src> to accumulator.
 void Interpreter::DoAdd(compiler::InterpreterAssembler* assembler) {
   // TODO(rmcilroy) Implement.
   __ Dispatch();
@@ skipping 31 matching lines @@
 //
 // Return the value in register 0.
 void Interpreter::DoReturn(compiler::InterpreterAssembler* assembler) {
   __ Return();
 }
 
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8