Supports FrameLookup vm test on MIPS

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 151 matching lines @@
   const ZoneGrowableArray<int>& GetPointerOffsets() const {
     return buffer_.pointer_offsets();
   }
   const GrowableObjectArray& object_pool() const { return object_pool_; }
   void FinalizeInstructions(const MemoryRegion& region) {
     buffer_.FinalizeInstructions(region);
   }
 
   // Set up a stub frame so that the stack traversal code can easily identify
   // a stub frame.
-  void EnterStubFrame();
-  void LeaveStubFrame();
+  void EnterStubFrame(bool uses_pp = false);
+  void LeaveStubFrame(bool uses_pp = false);
 
   // Instruction pattern from entrypoint is used in dart frame prologs
   // to set up the frame and save a PC which can be used to figure out the
   // RawInstruction object corresponding to the code running in the frame.
   // See EnterDartFrame. There are 6 instructions before we know the PC.
   static const intptr_t kOffsetOfSavedPCfromEntrypoint = 6 * Instr::kInstrSize;
 
   // Inlined allocation of an instance of class 'cls', code has no runtime
   // calls. Jump to 'failure' if the instance cannot be allocated here.
   // Allocated instance is returned in 'instance_reg'.
@@ skipping 374 matching lines @@
     if (Utils::IsInt(kImmBits, value)) {
       addiu(rd, ZR, Immediate(value));
     } else {
       const uint16_t low = Utils::Low16Bits(value);
       const uint16_t high = Utils::High16Bits(value);
       lui(rd, Immediate(high));
       ori(rd, rd, Immediate(low));
     }
   }
 
+  void AddImmediate(Register rd, int32_t value) {
+    if (Utils::IsInt(kImmBits, value)) {
+      addiu(rd, rd, Immediate(value));
+    } else {
+      LoadImmediate(TMP1, value);
+      addu(rd, rd, TMP1);
+    }

[regis, 2013/04/10 20:53:00]

You could forward to AddImmediate(rd, rd, value).

[zra, 2013/04/10 21:59:05]

Done.

+  }
+
+  void AddImmediate(Register rd, Register rs, int32_t value) {
+    if (Utils::IsInt(kImmBits, value)) {
+      addiu(rd, rs, Immediate(value));
+    } else {
+      LoadImmediate(TMP1, value);
+      addu(rd, rs, TMP1);
+    }
+  }
+
   void BranchEqual(Register rd, int32_t value, Label* l) {
     LoadImmediate(TMP1, value);
     beq(rd, TMP1, l);
   }
 
   void BranchEqual(Register rd, const Object& object, Label* l) {
     LoadObject(TMP1, object);
     beq(rd, TMP1, l);
   }
 
@@ skipping 92 matching lines @@
   void SmiUntag(Register reg) {
     sra(reg, reg, kSmiTagSize);
   }
 
   void ReserveAlignedFrameSpace(intptr_t frame_space);
 
   void LoadWordFromPoolOffset(Register rd, int32_t offset);
   void LoadObject(Register rd, const Object& object);
   void PushObject(const Object& object);
 
+  // Branch if a comparison with a result already in rd satisfies the
+  // Condition c.
+  void BranchOnCondition(Register rd, Label* l, Condition c);

[regis, 2013/04/10 20:53:00]

It would be more natural to have the condition as first parameter, as on Intel
(or maybe second?). It is last on ARM, because each instruction is conditional
and we want the condition to default to 'always', without passing it explicitly.
You could also use the shorter name 'Branch'. Up to you.
But more importantly, why do you need this? It seems that it will map to one
instruction anyway. I would prefer to see the real code being generated, rather
than making it look closer to the ARM version.
If the purpose is to emulate the branch on condition of the flow graph, maybe T8
should be implicit?
You already have BranchEqual, etc... this is getting confusing. Let's chat.

+
   // Sets register rd to zero if the object is equal to register rn,
-  // set to non-zero otherwise.
+  // sets it to non-zero otherwise.
   void CompareObject(Register rd, Register rn, const Object& object);
 
   void LoadClassId(Register result, Register object);
   void LoadClassById(Register result, Register class_id);
   void LoadClass(Register result, Register object);
 
   void CallRuntime(const RuntimeEntry& entry);
 
   // Set up a Dart frame on entry with a frame pointer and PC information to
   // enable easy access to the RawInstruction object of code corresponding
@@ skipping 123 matching lines @@
     delay_slot_available_ = true;
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_MIPS_H_