Updates and fixes for MIPS support.

src/mips/codegen-mips.cc

 // Copyright 2010 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 74 matching lines @@
 }
 
 
 CodeGenState::~CodeGenState() {
   ASSERT(owner_->state() == this);
   owner_->set_state(previous_);
 }
 
 
 // -----------------------------------------------------------------------------
-// CodeGenerator implementation
+// CodeGenerator implementation.
 
 CodeGenerator::CodeGenerator(MacroAssembler* masm)
     : deferred_(8),
       masm_(masm),
       frame_(NULL),
       allocator_(NULL),
       cc_reg_(cc_always),
       state_(NULL),
       function_return_is_shadowed_(false) {
 }
@@ skipping 37 matching lines @@
     // Allocate space for locals and initialize them.
     frame_->AllocateStackSlots();
 
     // Initialize the function return target.
     function_return_.set_direction(JumpTarget::BIDIRECTIONAL);
     function_return_is_shadowed_ = false;
 
     VirtualFrame::SpilledScope spilled_scope;
     if (scope()->num_heap_slots() > 0) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
     {
       Comment cmnt2(masm_, "[ copy context parameters into .context");
 
       // Note that iteration order is relevant here! If we have the same
       // parameter twice (e.g., function (x, y, x)), and that parameter
       // needs to be copied into the context, it must be the last argument
       // passed to the parameter that needs to be copied. This is a rare
       // case so we don't check for it, instead we rely on the copying
       // order: such a parameter is copied repeatedly into the same
       // context location and thus the last value is what is seen inside
       // the function.
       for (int i = 0; i < scope()->num_parameters(); i++) {
         UNIMPLEMENTED_MIPS();
       }
     }
 
     // Store the arguments object.  This must happen after context
     // initialization because the arguments object may be stored in the
     // context.
     if (scope()->arguments() != NULL) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
     // Generate code to 'execute' declarations and initialize functions
     // (source elements). In case of an illegal redeclaration we need to
     // handle that instead of processing the declarations.
     if (scope()->HasIllegalRedeclaration()) {
       Comment cmnt(masm_, "[ illegal redeclarations");
       scope()->VisitIllegalRedeclaration(this);
     } else {
       Comment cmnt(masm_, "[ declarations");
       ProcessDeclarations(scope()->declarations());
       // Bail out if a stack-overflow exception occurred when processing
       // declarations.
       if (HasStackOverflow()) return;
     }
 
     if (FLAG_trace) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
     // Compile the body of the function in a vanilla state. Don't
     // bother compiling all the code if the scope has an illegal
     // redeclaration.
     if (!scope()->HasIllegalRedeclaration()) {
       Comment cmnt(masm_, "[ function body");
 #ifdef DEBUG
       bool is_builtin = Bootstrapper::IsActive();
       bool should_trace =
           is_builtin ? FLAG_trace_builtin_calls : FLAG_trace_calls;
       if (should_trace) {
         UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
       }
 #endif
       VisitStatementsAndSpill(info->function()->body());
     }
   }
 
   if (has_valid_frame() || function_return_.is_linked()) {
     if (!function_return_.is_linked()) {
       CodeForReturnPosition(info->function());
     }
     // Registers:
     // v0: result
     // sp: stack pointer
     // fp: frame pointer
     // cp: callee's context
 
     __ LoadRoot(v0, Heap::kUndefinedValueRootIndex);
 
     function_return_.Bind();
     if (FLAG_trace) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
-    // Add a label for checking the size of the code used for returning.
-    Label check_exit_codesize;
-    masm_->bind(&check_exit_codesize);
+    // We don't check for the return code size. It may differ if the number of
+    // arguments is too big.
+    __ mov(sp, fp);
+    __ lw(fp, MemOperand(sp, 0));
+    __ lw(ra, MemOperand(sp, 4));
+    __ addiu(sp, sp, 8);
 
-    masm_->mov(sp, fp);
-    masm_->lw(fp, MemOperand(sp, 0));
-    masm_->lw(ra, MemOperand(sp, 4));
-    masm_->addiu(sp, sp, 8);
-
-    // Here we use masm_-> instead of the __ macro to avoid the code coverage
-    // tool from instrumenting as we rely on the code size here.
-    // TODO(MIPS): Should we be able to use more than 0x1ffe parameters?
-    masm_->addiu(sp, sp, (scope()->num_parameters() + 1) * kPointerSize);
-    masm_->Jump(ra);
-    // The Jump automatically generates a nop in the branch delay slot.
-
-    // Check that the size of the code used for returning matches what is
-    // expected by the debugger.
-    ASSERT_EQ(kJSReturnSequenceLength,
-              masm_->InstructionsGeneratedSince(&check_exit_codesize));
+    __ Addu(sp, sp, Operand((scope()->num_parameters() + 1) * kPointerSize));
+    __ Ret();
   }
 
   // Code generation state must be reset.
   ASSERT(!has_cc());
   ASSERT(state_ == NULL);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   DeleteFrame();
 
   // Process any deferred code using the register allocator.
   if (!HasStackOverflow()) {
     ProcessDeferred();
   }
 
   allocator_ = NULL;
 }
 
 
 void CodeGenerator::LoadReference(Reference* ref) {
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ LoadReference");
   Expression* e = ref->expression();
   Property* property = e->AsProperty();
   Variable* var = e->AsVariableProxy()->AsVariable();
 
   if (property != NULL) {
     UNIMPLEMENTED_MIPS();
   } else if (var != NULL) {
     // The expression is a variable proxy that does not rewrite to a
-    // property.  Global variables are treated as named property references.
+    // property. Global variables are treated as named property references.
     if (var->is_global()) {
       LoadGlobal();
       ref->set_type(Reference::NAMED);
     } else {
       ASSERT(var->slot() != NULL);
       ref->set_type(Reference::SLOT);
     }
   } else {
     UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
   }
 }
 
 
 void CodeGenerator::UnloadReference(Reference* ref) {
   VirtualFrame::SpilledScope spilled_scope;
   // Pop a reference from the stack while preserving TOS.
   Comment cmnt(masm_, "[ UnloadReference");
   int size = ref->size();
   if (size > 0) {
@@ skipping 11 matching lines @@
   // (such as the variable referring to a named function expression).
   // We need to implement assignments to read-only variables.
   // Ideally, we should do this during AST generation (by converting
   // such assignments into expression statements); however, in general
   // we may not be able to make the decision until past AST generation,
   // that is when the entire program is known.
   ASSERT(slot != NULL);
   int index = slot->index();
   switch (slot->type()) {
     case Slot::PARAMETER:
-      UNIMPLEMENTED_MIPS();
-      return MemOperand(no_reg, 0);
-
+      return frame_->ParameterAt(index);
     case Slot::LOCAL:
       return frame_->LocalAt(index);
 
     case Slot::CONTEXT: {
       UNIMPLEMENTED_MIPS();
       return MemOperand(no_reg, 0);
     }
 
     default:
       UNREACHABLE();
@@ skipping 48 matching lines @@
 void CodeGenerator::Load(Expression* x) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   JumpTarget true_target;
   JumpTarget false_target;
   LoadCondition(x, &true_target, &false_target, false);
 
   if (has_cc()) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   }
 
   if (true_target.is_linked() || false_target.is_linked()) {
     UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
   }
   ASSERT(has_valid_frame());
   ASSERT(!has_cc());
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::LoadGlobal() {
   VirtualFrame::SpilledScope spilled_scope;
   __ lw(a0, GlobalObject());
   frame_->EmitPush(a0);
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   VirtualFrame::SpilledScope spilled_scope;
   if (slot->type() == Slot::LOOKUP) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   } else {
-    __ lw(a0, SlotOperand(slot, a2));
-    frame_->EmitPush(a0);
+    __ lw(v0, SlotOperand(slot, a2));
+    frame_->EmitPush(v0);
     if (slot->var()->mode() == Variable::CONST) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
   }
 }
 
 
 void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
   ASSERT(slot != NULL);
   if (slot->type() == Slot::LOOKUP) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
   } else {
     ASSERT(!slot->var()->is_dynamic());
 
     JumpTarget exit;
     if (init_state == CONST_INIT) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
     // We must execute the store. Storing a variable must keep the
     // (new) value on the stack. This is necessary for compiling
     // assignment expressions.
     //
     // Note: We will reach here even with slot->var()->mode() ==
     // Variable::CONST because of const declarations which will
     // initialize consts to 'the hole' value and by doing so, end up
     // calling this code. a2 may be loaded with context; used below in
     // RecordWrite.
     frame_->EmitPop(a0);
     __ sw(a0, SlotOperand(slot, a2));
     frame_->EmitPush(a0);
     if (slot->type() == Slot::CONTEXT) {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
     // If we definitely did not jump over the assignment, we do not need
     // to bind the exit label. Doing so can defeat peephole
     // optimization.
     if (init_state == CONST_INIT || slot->type() == Slot::CONTEXT) {
       exit.Bind();
     }
   }
 }
 
 
 void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   VirtualFrame::SpilledScope spilled_scope;
   for (int i = 0; frame_ != NULL && i < statements->length(); i++) {
     VisitAndSpill(statements->at(i));
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
-  UNIMPLEMENTED_MIPS();
+#ifdef DEBUG
+  int original_height = frame_->height();
+#endif
+  VirtualFrame::SpilledScope spilled_scope;
+  Comment cmnt(masm_, "[ Block");
+  CodeForStatementPosition(node);
+  node->break_target()->set_direction(JumpTarget::FORWARD_ONLY);
+  VisitStatementsAndSpill(node->statements());
+  if (node->break_target()->is_linked()) {
+    node->break_target()->Bind();
+  }
+  node->break_target()->Unuse();
+  ASSERT(!has_valid_frame() || frame_->height() == original_height);
 }
 
 
 void CodeGenerator::DeclareGlobals(Handle<FixedArray> pairs) {
   VirtualFrame::SpilledScope spilled_scope;
   frame_->EmitPush(cp);
   __ li(t0, Operand(pairs));
   frame_->EmitPush(t0);
   __ li(t0, Operand(Smi::FromInt(is_eval() ? 1 : 0)));
   frame_->EmitPush(t0);
   frame_->CallRuntime(Runtime::kDeclareGlobals, 3);
   // The result is discarded.
 }
 
 
 void CodeGenerator::VisitDeclaration(Declaration* node) {
-  UNIMPLEMENTED_MIPS();
+#ifdef DEBUG
+  int original_height = frame_->height();
+#endif
+  VirtualFrame::SpilledScope spilled_scope;
+  Comment cmnt(masm_, "[ Declaration");
+  Variable* var = node->proxy()->var();
+  ASSERT(var != NULL);  // Must have been resolved.
+  Slot* slot = var->slot();
+
+  // If it was not possible to allocate the variable at compile time,
+  // we need to "declare" it at runtime to make sure it actually
+  // exists in the local context.
+  if (slot != NULL && slot->type() == Slot::LOOKUP) {
+    UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
+    return;
+  }
+
+  ASSERT(!var->is_global());
+
+  // If we have a function or a constant, we need to initialize the variable.
+  Expression* val = NULL;
+  if (node->mode() == Variable::CONST) {
+    UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
+  } else {
+    val = node->fun();  // NULL if we don't have a function.
+  }
+
+  if (val != NULL) {
+    {
+      // Set initial value.
+      Reference target(this, node->proxy());
+      LoadAndSpill(val);
+      target.SetValue(NOT_CONST_INIT);
+      // The reference is removed from the stack (preserving TOS) when
+      // it goes out of scope.
+    }
+    // Get rid of the assigned value (declarations are statements).
+    frame_->Drop();
+  }
+  ASSERT(frame_->height() == original_height);
 }
 
 
 void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ ExpressionStatement");
   CodeForStatementPosition(node);
   Expression* expression = node->expression();
   expression->MarkAsStatement();
   LoadAndSpill(expression);
   frame_->Drop();
   ASSERT(frame_->height() == original_height);
 }
 
 
 void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitIfStatement(IfStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitContinueStatement(ContinueStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitBreakStatement(BreakStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ ReturnStatement");
 
   CodeForStatementPosition(node);
   LoadAndSpill(node->expression());
   if (function_return_is_shadowed_) {
     frame_->EmitPop(v0);
     function_return_.Jump();
   } else {
     // Pop the result from the frame and prepare the frame for
     // returning thus making it easier to merge.
     frame_->EmitPop(v0);
     frame_->PrepareForReturn();
 
     function_return_.Jump();
   }
 }
 
 
 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitSwitchStatement(SwitchStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitDoWhileStatement(DoWhileStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitWhileStatement(WhileStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitForStatement(ForStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitForInStatement(ForInStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitTryCatchStatement(TryCatchStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitTryFinallyStatement(TryFinallyStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitSharedFunctionInfoLiteral(
     SharedFunctionInfoLiteral* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitConditional(Conditional* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitSlot(Slot* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ Slot");
   LoadFromSlot(node, typeof_state());
@@ skipping 28 matching lines @@
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ Literal");
   __ li(t0, Operand(node->handle()));
   frame_->EmitPush(t0);
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitArrayLiteral(ArrayLiteral* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ Assignment");
 
-  { Reference target(this, node->target());
+  { Reference target(this, node->target(), node->is_compound());
     if (target.is_illegal()) {
       // Fool the virtual frame into thinking that we left the assignment's
       // value on the frame.
       frame_->EmitPush(zero_reg);
       ASSERT(frame_->height() == original_height + 1);
       return;
     }
 
     if (node->op() == Token::ASSIGN ||
         node->op() == Token::INIT_VAR ||
         node->op() == Token::INIT_CONST) {
       LoadAndSpill(node->value());
     } else {
       UNIMPLEMENTED_MIPS();
+      __ break_(__LINE__);
     }
 
     Variable* var = node->target()->AsVariableProxy()->AsVariable();
     if (var != NULL &&
         (var->mode() == Variable::CONST) &&
         node->op() != Token::INIT_VAR && node->op() != Token::INIT_CONST) {
       // Assignment ignored - leave the value on the stack.
     } else {
       CodeForSourcePosition(node->position());
       if (node->op() == Token::INIT_CONST) {
         // Dynamic constant initializations must use the function context
         // and initialize the actual constant declared. Dynamic variable
         // initializations are simply assignments and use SetValue.
         target.SetValue(CONST_INIT);
       } else {
         target.SetValue(NOT_CONST_INIT);
       }
     }
   }
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::VisitThrow(Throw* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitProperty(Property* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitCall(Call* node) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   VirtualFrame::SpilledScope spilled_scope;
   Comment cmnt(masm_, "[ Call");
 
   Expression* function = node->expression();
   ZoneList<Expression*>* args = node->arguments();
 
   // Standard function call.
   // Check if the function is a variable or a property.
   Variable* var = function->AsVariableProxy()->AsVariable();
   Property* property = function->AsProperty();
 
   // ------------------------------------------------------------------------
   // Fast-case: Use inline caching.
   // ---
   // According to ECMA-262, section 11.2.3, page 44, the function to call
   // must be resolved after the arguments have been evaluated. The IC code
   // automatically handles this by loading the arguments before the function
   // is resolved in cache misses (this also holds for megamorphic calls).
   // ------------------------------------------------------------------------
 
   if (var != NULL && var->is_possibly_eval()) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   } else if (var != NULL && !var->is_this() && var->is_global()) {
-    // ----------------------------------
-    // JavaScript example: 'foo(1, 2, 3)'  // foo is global
-    // ----------------------------------
-
-    int arg_count = args->length();
-
-    // We need sp to be 8 bytes aligned when calling the stub.
-    __ SetupAlignedCall(t0, arg_count);
+    // -----------------------------------------------------
+    // JavaScript example: 'foo(1, 2, 3)'  // foo is global.
+    // -----------------------------------------------------
 
     // Pass the global object as the receiver and let the IC stub
     // patch the stack to use the global proxy as 'this' in the
     // invoked function.
     LoadGlobal();
 
     // Load the arguments.
+    int arg_count = args->length();
     for (int i = 0; i < arg_count; i++) {
       LoadAndSpill(args->at(i));
     }
 
     // Setup the receiver register and call the IC initialization code.
     __ li(a2, Operand(var->name()));
     InLoopFlag in_loop = loop_nesting() > 0 ? IN_LOOP : NOT_IN_LOOP;
     Handle<Code> stub = ComputeCallInitialize(arg_count, in_loop);
     CodeForSourcePosition(node->position());
     frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET_CONTEXT,
                            arg_count + 1);
-    __ ReturnFromAlignedCall();
     __ lw(cp, frame_->Context());
     // Remove the function from the stack.
     frame_->EmitPush(v0);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     UNIMPLEMENTED_MIPS();
   } else if (property != NULL) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   } else {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   }
 
   ASSERT(frame_->height() == original_height + 1);
 }
 
 
 void CodeGenerator::VisitCallNew(CallNew* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateClassOf(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateValueOf(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateSetValueOf(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateLog(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsNonNegativeSmi(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateMathCos(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateMathSin(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
-}
-
-
-// This should generate code that performs a charCodeAt() call or returns
-// undefined in order to trigger the slow case, Runtime_StringCharCodeAt.
-// It is not yet implemented on ARM, so it always goes to the slow case.
+  __ break_(__LINE__);
+}
+
+
 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateCharFromCode(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsArray(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsRegExp(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsConstructCall(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateArguments(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateRandomPositiveSmi(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateObjectEquals(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsObject(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsFunction(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateIsUndetectableObject(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateStringAdd(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateSubString(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateStringCompare(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateRegExpExec(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::GenerateNumberToString(ZoneList<Expression*>* args) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitCallRuntime(CallRuntime* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitCountOperation(CountOperation* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitBinaryOperation(BinaryOperation* node) {
   UNIMPLEMENTED_MIPS();
-}
-
+  __ break_(__LINE__);
+}
 
 void CodeGenerator::VisitThisFunction(ThisFunction* node) {
   UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CodeGenerator::VisitCompareOperation(CompareOperation* node) {
   UNIMPLEMENTED_MIPS();
-}
-
-
+  __ break_(__LINE__);
+}
+
+
 #ifdef DEBUG
 bool CodeGenerator::HasValidEntryRegisters() { return true; }
 #endif
 
 
 #undef __
 #define __ ACCESS_MASM(masm)
 
 // -----------------------------------------------------------------------------
-// Reference support
+// Reference support.
 
 Reference::Reference(CodeGenerator* cgen,
                      Expression* expression,
                      bool persist_after_get)
     : cgen_(cgen),
       expression_(expression),
       type_(ILLEGAL),
       persist_after_get_(persist_after_get) {
   cgen->LoadReference(this);
 }
@@ skipping 79 matching lines @@
       UNIMPLEMENTED_MIPS();
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
-// On entry a0 and a1 are the things to be compared. On exit v0 is 0,
-// positive or negative to indicate the result of the comparison.
 void CompareStub::Generate(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x765);
+  __ break_(__LINE__);
 }
 
 
 Handle<Code> GetBinaryOpStub(int key, BinaryOpIC::TypeInfo type_info) {
   UNIMPLEMENTED_MIPS();
   return Handle<Code>::null();
 }
 
 
 void StackCheckStub::Generate(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x790);
+  __ break_(__LINE__);
+}
+
+
+void GenericUnaryOpStub::Generate(MacroAssembler* masm) {
+  UNIMPLEMENTED_MIPS();
+  __ break_(__LINE__);
 }
 
 
 void CEntryStub::GenerateThrowTOS(MacroAssembler* masm) {
-  UNIMPLEMENTED_MIPS();
-  __ break_(0x808);
+  // v0 holds the exception.
+
+  // Adjust this code if not the case.
+  ASSERT(StackHandlerConstants::kSize == 4 * kPointerSize);
+
+  // Drop the sp to the top of the handler.
+  __ li(a3, Operand(ExternalReference(Top::k_handler_address)));
+  __ lw(sp, MemOperand(a3));
+
+  // Restore the next handler and frame pointer, discard handler state.
+  ASSERT(StackHandlerConstants::kNextOffset == 0);
+  __ Pop(a2);
+  __ sw(a2, MemOperand(a3));
+  ASSERT(StackHandlerConstants::kFPOffset == 2 * kPointerSize);
+  __ MultiPop(a3.bit() | fp.bit());
+
+  // Before returning we restore the context from the frame pointer if
+  // not NULL. The frame pointer is NULL in the exception handler of a
+  // JS entry frame.
+  // Set cp to NULL if fp is NULL.
+  Label done;
+  __ Branch(false, &done, eq, fp, Operand(zero_reg));
+  __ mov(cp, zero_reg);   // Use the branch delay slot.
+  __ lw(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
+  __ bind(&done);
+
+#ifdef DEBUG
+  // TODO(MIPS): Implement debug code.
+#endif
+
+  ASSERT(StackHandlerConstants::kPCOffset == 3 * kPointerSize);
+  __ Pop(t9);
+  __ Jump(t9);
 }
 
 
 void CEntryStub::GenerateThrowUncatchable(MacroAssembler* masm,
                                           UncatchableExceptionType type) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x815);
+  __ break_(__LINE__);
 }
 
 void CEntryStub::GenerateCore(MacroAssembler* masm,
                               Label* throw_normal_exception,
                               Label* throw_termination_exception,
                               Label* throw_out_of_memory_exception,
                               bool do_gc,
                               bool always_allocate) {
+  // v0: result parameter for PerformGC, if any
   // s0: number of arguments including receiver (C callee-saved)
   // s1: pointer to the first argument          (C callee-saved)
   // s2: pointer to builtin function            (C callee-saved)
 
   if (do_gc) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   }
 
   ExternalReference scope_depth =
       ExternalReference::heap_always_allocate_scope_depth();
   if (always_allocate) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   }
 
   // Call C built-in.
   // a0 = argc, a1 = argv
   __ mov(a0, s0);
   __ mov(a1, s1);
 
-  __ CallBuiltin(s2);
+  // We are calling compiled C/C++ code. a0 and a1 hold our two arguments. We
+  // also need the argument slots.
+  __ jalr(s2);
+  __ addiu(sp, sp, -StandardFrameConstants::kCArgsSlotsSize);

[Søren Thygesen Gjesse, 2010/05/25 09:00:56]

Please add a comment on the usage of the branch delay slot and on the
instruction where execution continues after return.

+  __ addiu(sp, sp, StandardFrameConstants::kCArgsSlotsSize);
 
   if (always_allocate) {
     UNIMPLEMENTED_MIPS();
+    __ break_(__LINE__);
   }
 
   // Check for failure result.
   Label failure_returned;
   ASSERT(((kFailureTag + 1) & kFailureTagMask) == 0);
   __ addiu(a2, v0, 1);
   __ andi(t0, a2, kFailureTagMask);
-  __ Branch(eq, &failure_returned, t0, Operand(zero_reg));
+  __ Branch(&failure_returned, eq, t0, Operand(zero_reg));
 
   // Exit C frame and return.
   // v0:v1: result
   // sp: stack pointer
   // fp: frame pointer
   __ LeaveExitFrame(mode_);
 
   // Check if we should retry or throw exception.
   Label retry;
   __ bind(&failure_returned);
   ASSERT(Failure::RETRY_AFTER_GC == 0);
   __ andi(t0, v0, ((1 << kFailureTypeTagSize) - 1) << kFailureTagSize);
-  __ Branch(eq, &retry, t0, Operand(zero_reg));
+  __ Branch(&retry, eq, t0, Operand(zero_reg));
 
   // Special handling of out of memory exceptions.
   Failure* out_of_memory = Failure::OutOfMemoryException();
-  __ Branch(eq, throw_out_of_memory_exception,
+  __ Branch(throw_out_of_memory_exception, eq,
             v0, Operand(reinterpret_cast<int32_t>(out_of_memory)));
 
   // Retrieve the pending exception and clear the variable.
   __ LoadExternalReference(t0, ExternalReference::the_hole_value_location());
   __ lw(a3, MemOperand(t0));
   __ LoadExternalReference(t0,
       ExternalReference(Top::k_pending_exception_address));
   __ lw(v0, MemOperand(t0));
   __ sw(a3, MemOperand(t0));
 
   // Special handling of termination exceptions which are uncatchable
   // by javascript code.
-  __ Branch(eq, throw_termination_exception,
+  __ Branch(throw_termination_exception, eq,
             v0, Operand(Factory::termination_exception()));
 
   // Handle normal exception.
-  __ b(throw_normal_exception);
-  __ nop();   // Branch delay slot nop.
+  __ jmp(throw_normal_exception);
 
-  __ bind(&retry);  // pass last failure (r0) as parameter (r0) when retrying
+  __ bind(&retry);
+  // Last failure (v0) will be moved to (a0) for parameter when retrying.
 }
 
 void CEntryStub::Generate(MacroAssembler* masm) {
   // Called from JavaScript; parameters are on stack as if calling JS function
   // a0: number of arguments including receiver
   // a1: pointer to builtin function
   // fp: frame pointer    (restored after C call)
   // sp: stack pointer    (restored as callee's sp after C call)
   // cp: current context  (C callee-saved)
 
@@ skipping 58 matching lines @@
   // a2: reveiver
   // a3: argc
   //
   // Stack:
   // 4 args slots
   // args
 
   // Save callee saved registers on the stack.
   __ MultiPush((kCalleeSaved | ra.bit()) & ~sp.bit());
 
+  // Load argv in s0 register.
+  __ lw(s0, MemOperand(sp, kNumCalleeSaved * kPointerSize +
+                           StandardFrameConstants::kCArgsSlotsSize));
+
   // We build an EntryFrame.
   __ li(t3, Operand(-1));  // Push a bad frame pointer to fail if it is used.
   int marker = is_construct ? StackFrame::ENTRY_CONSTRUCT : StackFrame::ENTRY;
   __ li(t2, Operand(Smi::FromInt(marker)));
   __ li(t1, Operand(Smi::FromInt(marker)));
   __ LoadExternalReference(t0, ExternalReference(Top::k_c_entry_fp_address));
   __ lw(t0, MemOperand(t0));
   __ MultiPush(t0.bit() | t1.bit() | t2.bit() | t3.bit());
 
   // Setup frame pointer for the frame to be pushed.
   __ addiu(fp, sp, -EntryFrameConstants::kCallerFPOffset);
 
-  // Load argv in s0 register.
-  __ lw(s0, MemOperand(sp, (kNumCalleeSaved + 1) * kPointerSize +
-                           StandardFrameConstants::kCArgsSlotsSize));
-
   // Registers:
   // a0: entry_address
   // a1: function
   // a2: reveiver_pointer
   // a3: argc
   // s0: argv
   //
   // Stack:
   // caller fp          |
   // function slot      | entry frame
@@ skipping 51 matching lines @@
   // 4 args slots
   // args
 
   if (is_construct) {
     ExternalReference construct_entry(Builtins::JSConstructEntryTrampoline);
     __ LoadExternalReference(t0, construct_entry);
   } else {
     ExternalReference entry(Builtins::JSEntryTrampoline);
     __ LoadExternalReference(t0, entry);
   }
-  __ lw(t9, MemOperand(t0));  // deref address
+  __ lw(t9, MemOperand(t0));  // Deref address.
 
   // Call JSEntryTrampoline.
   __ addiu(t9, t9, Code::kHeaderSize - kHeapObjectTag);
   __ CallBuiltin(t9);
 
   // Unlink this frame from the handler chain. When reading the
   // address of the next handler, there is no need to use the address
   // displacement since the current stack pointer (sp) points directly
   // to the stack handler.
   __ lw(t1, MemOperand(sp, StackHandlerConstants::kNextOffset));
   __ LoadExternalReference(t0, ExternalReference(Top::k_handler_address));
   __ sw(t1, MemOperand(t0));
 
   // This restores sp to its position before PushTryHandler.
   __ addiu(sp, sp, StackHandlerConstants::kSize);
 
-  __ bind(&exit);  // v0 holds result
+  __ bind(&exit);  // v0 holds result.
   // Restore the top frame descriptors from the stack.
   __ Pop(t1);
   __ LoadExternalReference(t0, ExternalReference(Top::k_c_entry_fp_address));
   __ sw(t1, MemOperand(t0));
 
   // Reset the stack to the callee saved registers.
   __ addiu(sp, sp, -EntryFrameConstants::kCallerFPOffset);
 
   // Restore callee saved registers from the stack.
   __ MultiPop((kCalleeSaved | ra.bit()) & ~sp.bit());
   // Return.
   __ Jump(ra);
 }
 
 
 // This stub performs an instanceof, calling the builtin function if
 // necessary. Uses a1 for the object, a0 for the function that it may
 // be an instance of (these are fetched from the stack).
 void InstanceofStub::Generate(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
   __ break_(0x845);
 }
 
 
 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x851);
+  __ break_(__LINE__);
 }
 
 
 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x857);
+  __ break_(__LINE__);
 }
 
 
 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* masm) {
   UNIMPLEMENTED_MIPS();
-  __ break_(0x863);
+  __ break_(__LINE__);
 }
 
 
 const char* CompareStub::GetName() {
   UNIMPLEMENTED_MIPS();
-  return NULL;  // UNIMPLEMENTED RETURN
+  return NULL;  // UNIMPLEMENTED RETURN.
 }
 
 
 int CompareStub::MinorKey() {
   // Encode the two parameters in a unique 16 bit value.
   ASSERT(static_cast<unsigned>(cc_) >> 28 < (1 << 15));
   return (static_cast<unsigned>(cc_) >> 27) | (strict_ ? 1 : 0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal