Adds Stop to MIPS. Starts on MIPS call patcher.

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 40 matching lines @@
     offset_ = other.offset_;
     return *this;
   }
 
   uint32_t encoding() const {
     ASSERT(Utils::IsInt(16, offset_));
     uint16_t imm_value = static_cast<uint16_t>(offset_);
     return (base_ << kRsShift) | imm_value;
   }
 
+  static bool CanHoldOffset(int32_t offset) {
+    return Utils::IsInt(16, offset);
+  }
+
  private:
   Register base_;
   int32_t offset_;
 };
 
 
 class FieldAddress : public Address {
  public:
   FieldAddress(Register base, int32_t disp)
       : Address(base, disp - kHeapObjectTag) { }
@@ skipping 65 matching lines @@
  public:
   Assembler()
       : buffer_(),
         object_pool_(GrowableObjectArray::Handle()),
         prologue_offset_(-1),
         delay_slot_available_(false),
         in_delay_slot_(false),
         comments_() { }
   ~Assembler() { }
 
-  void PopRegister(Register r) {
-    UNIMPLEMENTED();
-  }
+  void PopRegister(Register r) { Pop(r); }
 
   void Bind(Label* label);
 
   // Misc. functionality
   int CodeSize() const { return buffer_.Size(); }
   int prologue_offset() const { return -1; }
   const ZoneGrowableArray<int>& GetPointerOffsets() const {
     return buffer_.pointer_offsets();
   }
   const GrowableObjectArray& object_pool() const { return object_pool_; }
@@ skipping 24 matching lines @@
   // Allocated instance is returned in 'instance_reg'.
   // Only the tags field of the object is initialized.
   void TryAllocate(const Class& cls,
                    Label* failure,
                    bool near_jump,
                    Register instance_reg) {
     UNIMPLEMENTED();
   }
 
   // Debugging and bringup support.
-  void Stop(const char* message) { UNIMPLEMENTED(); }
   void Unimplemented(const char* message);
   void Untested(const char* message);
   void Unreachable(const char* message);
 
   static void InitializeMemoryWithBreakpoints(uword data, int length);
 
   void Comment(const char* format, ...) PRINTF_ATTRIBUTE(2, 3);
 
   const Code::Comments& GetCodeComments() const;
 
@@ skipping 292 matching lines @@
 
   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) {
+    // Doesn't need to be patchable, so use the delay slot.
+    if (Utils::IsInt(16, label->address())) {
+      jr(TMP);
+      delay_slot()->addiu(TMP, ZR, Immediate(label->address()));
+    } else {
+      lui(TMP, Immediate((label->address() >> 16) & 0xffff));

[regis, 2013/03/25 23:03:40]

It would be a bit more readable to use Utils::Low16Bits and Utils::High16Bits
here and below, as we do on ARM.

[zra, 2013/03/25 23:39:17]

Okay. So you've got to cast the result of High16Bits to (u)int16_t or you get
unwanted sign-extension because it returns an int32_t. Maybe {High,Low}16Bits
should just return a uint16_t?

+      jr(TMP);
+      delay_slot()->ori(TMP, TMP, Immediate(label->address() & 0xffff));
+    }
+  }
+
+  void BranchLink(const ExternalLabel* label) {
+    // Doesn't need to be patchable, so use the delay slot.
+    if (Utils::IsInt(16, label->address())) {
+      jalr(TMP);
+      delay_slot()->addiu(TMP, ZR, Immediate(label->address()));
+    } else {
+      lui(TMP, Immediate((label->address() >> 16) & 0xffff));
+      jalr(TMP);
+      delay_slot()->ori(TMP, TMP, Immediate(label->address() & 0xffff));
+    }
+  }
+
+  void BranchLinkPatchable(const ExternalLabel* label) {
+    const int32_t offset =
+        Array::data_offset() + 4*AddExternalLabel(label) - kHeapObjectTag;
+    LoadWordFromPoolOffset(TMP, offset);
+    jalr(TMP);
+  }
+
+  void BranchPatchable(const ExternalLabel* label) {
+    LoadImmediate(TMP, label->address());
+    jr(TMP);
+  }
+
+  void Drop(intptr_t stack_elements) {
+    ASSERT(stack_elements >= 0);
+    if (stack_elements > 0) {
+      addiu(SP, SP, Immediate(stack_elements * kWordSize));
+    }
+  }
+
   void LoadImmediate(Register rd, int32_t value) {
     if (Utils::IsInt(16, value)) {
       addiu(rd, ZR, Immediate(value));
     } else {
       lui(rd, Immediate((value >> 16) & 0xffff));
       ori(rd, rd, Immediate(value & 0xffff));
     }
   }
 
+  void Push(Register rt) {
+    addiu(SP, SP, Immediate(-kWordSize));
+    sw(rt, Address(SP));
+  }
+
+  void Pop(Register rt) {
+    lw(rt, Address(SP));
+    addiu(SP, SP, Immediate(kWordSize));
+  }
+
+  void Ret() {
+    jr(RA);
+  }
+
+  void Stop(const char* message) {

[regis, 2013/03/25 23:03:40]

I would not implement this in the header.

[zra, 2013/03/25 23:39:17]

Done.

+    Label stop;

[regis, 2013/03/25 23:03:40]

You are missing support for FLAG_print_stop_message.
You should change the default for the flag to false, with a TODO, and add an
UNIMPLEMENTED here if the flag is true.
Otherwise, you are going to forget to support this flag.

[zra, 2013/03/25 23:39:17]

Done.

+    b(&stop);
+    Emit(reinterpret_cast<int32_t>(message));
+    Bind(&stop);
+    break_(Instr::kStopMessageCode);
+  }
+
+  void LoadWordFromPoolOffset(Register rd, int32_t offset);
+  void LoadObject(Register rd, const Object& object);
+  void PushObject(const Object& object);
+
+  // Subtracts rn from location of object and places result in rd.
+  void CompareObject(Register rd, Register rn, const Object& object);
+
  private:
   AssemblerBuffer buffer_;
   GrowableObjectArray& object_pool_;  // Objects and patchable jump targets.
   int prologue_offset_;
 
   bool delay_slot_available_;
   bool in_delay_slot_;
 
+  int32_t AddObject(const Object& obj);
+  int32_t AddExternalLabel(const ExternalLabel* label);
+
   class CodeComment : public ZoneAllocated {
    public:
     CodeComment(intptr_t pc_offset, const String& comment)
         : pc_offset_(pc_offset), comment_(comment) { }
 
     intptr_t pc_offset() const { return pc_offset_; }
     const String& comment() const { return comment_; }
 
    private:
     intptr_t pc_offset_;
@@ skipping 94 matching lines @@
     delay_slot_available_ = true;
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_MIPS_H_