Adds support for ARMv6.

runtime/vm/assembler_arm.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_ARM_H_
 #define VM_ASSEMBLER_ARM_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm.h directly; use assembler.h instead.
 #endif
@@ skipping 45 matching lines @@
   void LinkTo(intptr_t position) {
     ASSERT(!IsBound());
     position_ = position + kWordSize;
     ASSERT(IsLinked());
   }
 
   friend class Assembler;
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
+
 // Encodes Addressing Mode 1 - Data-processing operands.
 class ShifterOperand : public ValueObject {
  public:
   // Data-processing operands - Uninitialized.
   ShifterOperand() : type_(-1), encoding_(-1) { }
 
   // Data-processing operands - Copy constructor.
   ShifterOperand(const ShifterOperand& other)
       : ValueObject(), type_(other.type_), encoding_(other.encoding_) { }
 
@@ skipping 507 matching lines @@
 
 
   // Signed integer division of left by right. Checks to see if integer
   // division is supported. If not, uses the FPU for division with
   // temporary registers tmpl and tmpr. tmpl and tmpr must be different
   // registers.
   void IntegerDivide(Register result, Register left, Register right,
                      DRegister tmpl, DRegister tmpr);
 
   // Load and Store. May clobber IP.
+  void LoadLargeImmediate(Register rd, int32_t value, Condition cond = AL);

[regis, 2014/03/06 17:32:11]

The function LoadImmediate below is also able to load a large immediate value.
The key here is not that you load a large immediate, but that you can decode the
emitted instructions, or that you can patch the immediate value.
Instead of adding LoadLargeImmediate, I would add 2 functions for clarity:
LoadDecodableImmediate and LoadPatchableImmediate.
On ARMv6, LoadDecodableImmediate would forward to LoadPatchableImmediate (same
code as in your LoadLargeImmediate).
On ARMv7, LoadDecodableImmediate would emit movw and optionally movt, whereas
LoadPatchableImmediate would always emit both movw and movt.

[zra, 2014/03/07 19:00:17]

Done.

   void LoadImmediate(Register rd, int32_t value, Condition cond = AL);
   void LoadSImmediate(SRegister sd, float value, Condition cond = AL);
   void LoadDImmediate(DRegister dd, double value,
                       Register scratch, Condition cond = AL);
 
   void MarkExceptionHandler(Label* label);
 
   void Drop(intptr_t stack_elements);
 
   void LoadPoolPointer();
@@ skipping 145 matching lines @@
  private:
   AssemblerBuffer buffer_;  // Contains position independent code.
   GrowableObjectArray& object_pool_;  // Objects and patchable jump targets.
   int32_t prologue_offset_;
 
   bool use_far_branches_;
 
   int32_t AddObject(const Object& obj);
   int32_t AddExternalLabel(const ExternalLabel* label);
 
+  void BindARMv6(Label* label);
+  void BindARMv7(Label* 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 112 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM_H_