Adds far-branches to arm64.

runtime/vm/assembler_arm64.h

 // Copyright (c) 2014, 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_ARM64_H_
 #define VM_ASSEMBLER_ARM64_H_
 
 #ifndef VM_ASSEMBLER_H_
 #error Do not include assembler_arm64.h directly; use assembler.h instead.
 #endif
 
 #include "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/constants_arm64.h"
 #include "vm/hash_map.h"
+#include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/simulator.h"
 
 namespace dart {
 
 // Forward declarations.
 class RuntimeEntry;
 
 // TODO(zra): Label, Address, and FieldAddress are copied from ARM,
 // they must be adapted to ARM64.
@@ skipping 568 matching lines @@
     } else {
       cmp(rn, Operand(rm));
     }
   }
 
   // Conditional branch.
   void b(Label* label, Condition cond = AL) {
     EmitBranch(BCOND, cond, label);
   }
 
-  // TODO(zra): branch and link with imm26 offset.
+  void b(int32_t offset) {
+    EmitUnconditionalBranchOp(B, offset);
+  }
+  void bl(int32_t offset) {
+    EmitUnconditionalBranchOp(BL, offset);
+  }
+
   // TODO(zra): cbz, cbnz.
 
   // Branch, link, return.
   void br(Register rn) {
     EmitUnconditionalBranchRegOp(BR, rn);
   }
   void blr(Register rn) {
     EmitUnconditionalBranchRegOp(BLR, rn);
   }
   void ret(Register rn = R30) {
@@ skipping 179 matching lines @@
   }
 
   // Fixed length branch to label.
   void BranchPatchable(const ExternalLabel* label) {
     // TODO(zra): Use LoadExternalLabelFixed if possible.
     LoadImmediateFixed(TMP, label->address());
     br(TMP);
   }
 
   void BranchLink(const ExternalLabel* label, Register pp) {
-    if (Isolate::Current() == Dart::vm_isolate()) {
+    if ((Isolate::Current() == Dart::vm_isolate()) || (pp == kNoPP)) {

[regis, 2014/05/12 16:05:02]

Can you add a comment explaining this?

[zra, 2014/05/12 18:42:50]

Moved this logic into LoadExternalLabel, and there I used
CanLoadImmediateFromPool. I put a comment there explaining a bit.

       LoadImmediate(TMP, label->address(), kNoPP);
       blr(TMP);
     } else {
       LoadExternalLabel(TMP, label, kNotPatchable, pp);
       blr(TMP);
     }
   }
 
   // BranchLinkPatchable must be a fixed-length sequence so we can patch it
   // with the debugger.
@@ skipping 304 matching lines @@
     const int32_t s = set_flags ? B29 : 0;
     const int32_t encoding =
         op | size | s |
         (static_cast<int32_t>(rd) << kRdShift) |
         (static_cast<int32_t>(rn) << kRnShift) |
         o.encoding();
     Emit(encoding);
   }
 
   int32_t EncodeImm19BranchOffset(int64_t imm, int32_t instr) {
+    if (!CanEncodeImm19BranchOffset(imm)) {
+      ASSERT(!use_far_branches());
+      Isolate::Current()->long_jump_base()->Jump(
+          1, Object::branch_offset_error());
+    }
     const int32_t imm32 = static_cast<int32_t>(imm);
     const int32_t off = (((imm32 >> 2) << kImm19Shift) & kImm19Mask);
     return (instr & ~kImm19Mask) | off;
   }
 
   int64_t DecodeImm19BranchOffset(int32_t instr) {
     const int32_t off = (((instr & kImm19Mask) >> kImm19Shift) << 13) >> 11;
     return static_cast<int64_t>(off);
   }
 
+  Condition DecodeImm19BranchCondition(int32_t instr) {
+    return static_cast<Condition>((instr & kCondMask) >> kCondShift);
+  }
+
+  int32_t EncodeImm19BranchCondition(Condition cond, int32_t instr) {
+    const int32_t c_imm = static_cast<int32_t>(cond);
+    return (instr & ~kCondMask) | (c_imm << kCondShift);
+  }
+
+  int32_t EncodeImm26BranchOffset(int64_t imm, int32_t instr) {
+    const int32_t imm32 = static_cast<int32_t>(imm);
+    const int32_t off = (((imm32 >> 2) << kImm26Shift) & kImm26Mask);
+    return (instr & ~kImm26Mask) | off;
+  }
+
+  int64_t DecodeImm26BranchOffset(int32_t instr) {
+    const int32_t off = (((instr & kImm26Mask) >> kImm26Shift) << 6) >> 4;
+    return static_cast<int64_t>(off);
+  }
+
   void EmitCompareAndBranch(CompareAndBranchOp op, Register rt, int64_t imm,
                             OperandSize sz) {
     ASSERT((sz == kDoubleWord) || (sz == kWord) || (sz == kUnsignedWord));
     ASSERT(Utils::IsInt(21, imm) && ((imm & 0x3) == 0));
     ASSERT((rt != SP) && (rt != R31));
     const Register crt = ConcreteRegister(rt);
     const int32_t size = (sz == kDoubleWord) ? B31 : 0;
     const int32_t encoded_offset = EncodeImm19BranchOffset(imm, 0);
     const int32_t encoding =
         op | size |
         (static_cast<int32_t>(crt) << kRtShift) |
         encoded_offset;
     Emit(encoding);
   }
 
   void EmitConditionalBranch(ConditionalBranchOp op, Condition cond,
                              int64_t imm) {
     ASSERT(Utils::IsInt(21, imm) && ((imm & 0x3) == 0));
     const int32_t encoding =
         op |
         (static_cast<int32_t>(cond) << kCondShift) |
         (((imm >> 2) << kImm19Shift) & kImm19Mask);
     Emit(encoding);
   }
 
+  void EmitFarConditionalBranch(ConditionalBranchOp op,
+                                Condition cond,
+                                int64_t offset) {
+    EmitConditionalBranch(op, InvertCondition(cond), 2 * Instr::kInstrSize);
+    b(offset);
+  }
+
   bool CanEncodeImm19BranchOffset(int64_t offset) {
     ASSERT(Utils::IsAligned(offset, 4));
     return Utils::IsInt(21, offset);
   }
 
-  // TODO(zra): Implement far branches. Requires loading large immediates.
   void EmitBranch(ConditionalBranchOp op, Condition cond, Label* label) {
     if (label->IsBound()) {
       const int64_t dest = label->Position() - buffer_.Size();
-      ASSERT(CanEncodeImm19BranchOffset(dest));
-      EmitConditionalBranch(op, cond, dest);
+      if (use_far_branches() && !CanEncodeImm19BranchOffset(dest)) {
+        EmitFarConditionalBranch(op, cond, dest);
+      } else {
+        EmitConditionalBranch(op, cond, dest);
+      }
     } else {
       const int64_t position = buffer_.Size();
-      ASSERT(CanEncodeImm19BranchOffset(position));
-      EmitConditionalBranch(op, cond, label->position_);
+      if (use_far_branches()) {
+        EmitFarConditionalBranch(op, cond, label->position_);
+      } else {
+        EmitConditionalBranch(op, cond, label->position_);
+      }
       label->LinkTo(position);
     }
   }
 
+  bool CanEncodeImm26BranchOffset(int64_t offset) {
+    ASSERT(Utils::IsAligned(offset, 4));
+    return Utils::IsInt(26, offset);
+  }
+
+  void EmitUnconditionalBranchOp(UnconditionalBranchOp op, int64_t offset) {
+    ASSERT(CanEncodeImm26BranchOffset(offset));
+    const int32_t off = (offset >> 2) << kImm26Shift;
+    const int32_t encoding = op | off;
+    Emit(encoding);
+  }
+
   void EmitUnconditionalBranchRegOp(UnconditionalBranchRegOp op, Register rn) {
     ASSERT((rn != SP) && (rn != R31));
     const Register crn = ConcreteRegister(rn);
     const int32_t encoding =
         op | (static_cast<int32_t>(crn) << kRnShift);
     Emit(encoding);
   }
 
   void EmitExceptionGenOp(ExceptionGenOp op, uint16_t imm) {
     const int32_t encoding =
@@ skipping 153 matching lines @@
                                   Register value,
                                   Label* no_update);
 
   DISALLOW_ALLOCATION();
   DISALLOW_COPY_AND_ASSIGN(Assembler);
 };
 
 }  // namespace dart
 
 #endif  // VM_ASSEMBLER_ARM64_H_