Implements optional parameter handling in MIPS vm.

runtime/vm/assembler_mips.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_ASSEMBLER_MIPS_H_
 #define VM_ASSEMBLER_MIPS_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_mips.h directly; use assembler.h instead.
 #endif
@@ skipping 474 matching lines @@
   }
 
   void srl(Register rd, Register rt, int sa) {
     EmitRType(SPECIAL, R0, rt, rd, sa, SRL);
   }
 
   void srlv(Register rd, Register rt, Register rs) {
     EmitRType(SPECIAL, rs, rt, rd, 0, SRLV);
   }
 
-  void sub(Register rd, Register rs, Register rt) {
-    EmitRType(SPECIAL, rs, rt, rd, 0, SUB);
-  }
-
   void subu(Register rd, Register rs, Register rt) {
     EmitRType(SPECIAL, rs, rt, rd, 0, SUBU);
   }
 
   void sw(Register rt, const Address& addr) {
     EmitLoadStore(SW, rt, addr);
   }
 
   void xor_(Register rd, Register rs, Register rt) {
     EmitRType(SPECIAL, rs, rt, rd, 0, XOR);
   }
 
   // Macros in alphabetical order.
 
   void Branch(const ExternalLabel* label) {
     LoadImmediate(TMP, label->address());
     jr(TMP);
   }
 
   void BranchPatchable(const ExternalLabel* label) {
     const uint16_t low = Utils::Low16Bits(label->address());
     const uint16_t high = Utils::High16Bits(label->address());
     lui(TMP, Immediate(high));
     ori(TMP, TMP, Immediate(low));
     jr(TMP);
-    delay_slot()->nop();
+    delay_slot_available_ = false;  // CodePatcher expects a nop.
   }
 
   void BranchLink(const ExternalLabel* label) {
     LoadImmediate(TMP, label->address());
     jalr(TMP);
   }
 
   void BranchLinkPatchable(const ExternalLabel* label) {
     const int32_t offset =
         Array::data_offset() + 4*AddExternalLabel(label) - kHeapObjectTag;
     LoadWordFromPoolOffset(TMP, offset);
     jalr(TMP);
-    delay_slot()->nop();
+    delay_slot_available_ = false;  // CodePatcher expects a nop.
   }
 
   // If the signed value in rs is less than value, rd is 1, and 0 otherwise.
   void LessThanSImmediate(Register rd, Register rs, int32_t value) {
     LoadImmediate(TMP, value);
     slt(rd, rs, TMP);
   }
 
   // If the unsigned value in rs is less than value, rd is 1, and 0 otherwise.
   void LessThanUImmediate(Register rd, Register rs, uint32_t value) {
@@ skipping 117 matching lines @@
   void EmitRegImmType(Opcode opcode,
                       Register rs,
                       RtRegImm code,
                       uint16_t imm) {
     Emit(opcode << kOpcodeShift |
          rs << kRsShift |
          code << kRtShift |
          imm);
   }
 
-  void EmitJType(Opcode opcode, Label* label) {
+  void EmitJType(Opcode opcode, uint32_t destination) {
     UNIMPLEMENTED();
   }
 
   void EmitRType(Opcode opcode,
                  Register rs,
                  Register rt,
                  Register rd,
                  int sa,
                  SpecialFunction func) {
     ASSERT(Utils::IsUint(5, sa));
     Emit(opcode << kOpcodeShift |
          rs << kRsShift |
          rt << kRtShift |
          rd << kRdShift |
          sa << kSaShift |
          func << kFunctionShift);
   }
 
   void EmitBranch(Opcode b, Register rs, Register rt, Label* label) {
     if (label->IsBound()) {
       // Relative destination from an instruction after the branch.
       const int32_t dest =
           label->Position() - (buffer_.Size() + Instr::kInstrSize);
       const uint16_t dest_off = EncodeBranchOffset(dest, 0);
       EmitIType(b, rs, rt, dest_off);
     } else {
       const int position = buffer_.Size();
-      EmitIType(b, rs, rt, label->position_);
+      const uint16_t dest_off = EncodeBranchOffset(label->position_, 0);
+      EmitIType(b, rs, rt, dest_off);
       label->LinkTo(position);
     }
   }
 
   void EmitRegImmBranch(RtRegImm b, Register rs, Label* label) {
     if (label->IsBound()) {
       // Relative destination from an instruction after the branch.
       const int32_t dest =
           label->Position() - (buffer_.Size() + Instr::kInstrSize);
       const uint16_t dest_off = EncodeBranchOffset(dest, 0);
       EmitRegImmType(REGIMM, rs, b, dest_off);
     } else {
       const int position = buffer_.Size();
-      EmitRegImmType(REGIMM, rs, b, label->position_);
+      const uint16_t dest_off = EncodeBranchOffset(label->position_, 0);
+      EmitRegImmType(REGIMM, rs, b, dest_off);
       label->LinkTo(position);
     }
   }
 
   static int32_t EncodeBranchOffset(int32_t offset, int32_t instr);
   static int DecodeBranchOffset(int32_t instr);
 
   void EmitBranchDelayNop() {
     Emit(Instr::kNopInstruction);  // Branch delay NOP.
     delay_slot_available_ = true;
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_MIPS_H_