Updates and fixes for MIPS support.

src/mips/virtual-frame-mips.h

 // 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 194 matching lines @@
   }
 
   void PushElementAt(int index) {
     PushFrameSlotAt(element_count() - index - 1);
   }
 
   // A frame-allocated local as an assembly operand.
   MemOperand LocalAt(int index) {
     ASSERT(0 <= index);
     ASSERT(index < local_count());
-    return MemOperand(s8_fp, kLocal0Offset - index * kPointerSize);
+    return MemOperand(fp, kLocal0Offset - index * kPointerSize);
   }
 
   // Push a copy of the value of a local frame slot on top of the frame.
   void PushLocalAt(int index) {
     PushFrameSlotAt(local0_index() + index);
   }
 
   // Push the value of a local frame slot on top of the frame and invalidate
   // the local slot. The slot should be written to before trying to read
   // from it again.
   void TakeLocalAt(int index) {
     TakeFrameSlotAt(local0_index() + index);
   }
 
   // Store the top value on the virtual frame into a local frame slot. The
   // value is left in place on top of the frame.
   void StoreToLocalAt(int index) {
     StoreToFrameSlotAt(local0_index() + index);
   }
 
   // Push the address of the receiver slot on the frame.
   void PushReceiverSlotAddress();
 
   // The function frame slot.
-  MemOperand Function() { return MemOperand(s8_fp, kFunctionOffset); }
+  MemOperand Function() { return MemOperand(fp, kFunctionOffset); }
 
   // Push the function on top of the frame.
   void PushFunction() { PushFrameSlotAt(function_index()); }
 
   // The context frame slot.
-  MemOperand Context() { return MemOperand(s8_fp, kContextOffset); }
+  MemOperand Context() { return MemOperand(fp, kContextOffset); }
 
   // Save the value of the cp register to the context frame slot.
   void SaveContextRegister();
 
   // Restore the cp register from the value of the context frame
   // slot.
   void RestoreContextRegister();
 
   // A parameter as an assembly operand.
   MemOperand ParameterAt(int index) {
     // Index -1 corresponds to the receiver.
     ASSERT(-1 <= index);  // -1 is the receiver.
     ASSERT(index <= parameter_count());
-    uint16_t a = 0;   // Number of argument slots.
-    return MemOperand(s8_fp, (1 + parameter_count() + a - index) *kPointerSize);
+    return MemOperand(fp, (1 + parameter_count() - index) * kPointerSize);
   }
 
   // Push a copy of the value of a parameter frame slot on top of the frame.
   void PushParameterAt(int index) {
     PushFrameSlotAt(param0_index() + index);
   }
 
   // Push the value of a paramter frame slot on top of the frame and
   // invalidate the parameter slot. The slot should be written to before
   // trying to read from it again.
@@ skipping 30 matching lines @@
   void CallRuntime(Runtime::FunctionId id, int arg_count);
 
   // Call runtime with sp aligned to 8 bytes.
   void CallAlignedRuntime(Runtime::Function* f, int arg_count);
   void CallAlignedRuntime(Runtime::FunctionId id, int arg_count);
 
   // Invoke builtin given the number of arguments it expects on (and
   // removes from) the stack.
   void InvokeBuiltin(Builtins::JavaScript id,
                      InvokeJSFlags flag,
-                     Result* arg_count_register,
                      int arg_count);
 
   // Call into an IC stub given the number of arguments it removes
   // from the stack. Register arguments are passed as results and
   // consumed by the call.
   void CallCodeObject(Handle<Code> ic,
                       RelocInfo::Mode rmode,
                       int dropped_args);
-  void CallCodeObject(Handle<Code> ic,
-                      RelocInfo::Mode rmode,
-                      Result* arg,
-                      int dropped_args);
-  void CallCodeObject(Handle<Code> ic,
-                      RelocInfo::Mode rmode,
-                      Result* arg0,
-                      Result* arg1,
-                      int dropped_args,
-                      bool set_auto_args_slots = false);
 
   // Drop a number of elements from the top of the expression stack. May
   // emit code to affect the physical frame. Does not clobber any registers
   // excepting possibly the stack pointer.
   void Drop(int count);
   // Similar to VirtualFrame::Drop but we don't modify the actual stack.
   // This is because we need to manually restore sp to the correct position.
   void DropFromVFrameOnly(int count);
 
   // Drop one element.
@@ skipping 198 matching lines @@
   // Classes that need raw access to the elements_ array.
   friend class DeferredCode;
   friend class JumpTarget;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_MIPS_VIRTUAL_FRAME_MIPS_H_