[MC][ARM] Add range checking for Thumb2 resolved fixups

[peter.smith]

Summary

When the branch target of a Thumb2 unconditional or conditonal branch is resolved at assembly time, no range checking is performed on the result leading to incorrect immediates when the maximum range is exceeded. This change adds a range check: +- 16 Megabytes for unconditional branches, +- 1 Megabyte for the conditional branch.

The ranges for the branch instructions can be found in https://developer.arm.com/docs/ddi0406/c/arm-architecture-reference-manual-armv7-a-and-armv7-r-edition
For version C (latest) the higher range can be found in A4.3 Branch instructions. The conditional branch range can be found in A8.8.18 B encoding T3.

[fhahn]

LGTM

test/MC/ARM/thumb2-branch-ranges.s

27 ↗

(On Diff #144691)

I think using CHECK-LABEL to separate the checks might it slightly easier to track down failures in the future.

llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMAsmBackend.cpp

case ARM::fixup_arm_blx:
     // Offset by 8 just as above.
     if (const MCSymbolRefExpr *SRE =
             dyn_cast<MCSymbolRefExpr>(Fixup.getValue()))
       if (SRE->getKind() == MCSymbolRefExpr::VK_TLSCALL)
         return 0;
     return 0xffffff & ((Value - 8) >> 2);
   case ARM::fixup_t2_uncondbranch: {
     Value = Value - 4;
+    if (!isInt<25>(Value)) {
+      Ctx.reportError(Fixup.getLoc(), "Relocation out of range");
+      return 0;
+    }
+
     Value >>= 1; // Low bit is not encoded.
 
     uint32_t out = 0;
     bool I = Value & 0x800000;
     bool J1 = Value & 0x400000;
     bool J2 = Value & 0x200000;
     J1 ^= I;
     J2 ^= I;
 
     out |= I << 26;                 // S bit
     out |= !J1 << 13;               // J1 bit
     out |= !J2 << 11;               // J2 bit
     out |= (Value & 0x1FF800) << 5; // imm6 field
     out |= (Value & 0x0007FF);      // imm11 field
 
     return swapHalfWords(out, Endian == support::little);
   }
   case ARM::fixup_t2_condbranch: {
     Value = Value - 4;
+    if (!isInt<21>(Value)) {
+      Ctx.reportError(Fixup.getLoc(), "Relocation out of range");
+      return 0;
+    }
+
     Value >>= 1; // Low bit is not encoded.
 
     uint64_t out = 0;
     out |= (Value & 0x80000) << 7; // S bit
     out |= (Value & 0x40000) >> 7; // J2 bit
     out |= (Value & 0x20000) >> 4; // J1 bit
     out |= (Value & 0x1F800) << 5; // imm6 field
     out |= (Value & 0x007FF);      // imm11 field

llvm/trunk/test/MC/ARM/thumb2-branch-ranges.s

+@ RUN: not llvm-mc %s -triple thumbv7-linux-gnueabi -filetype=obj -o /dev/null 2>&1 | FileCheck %s
+
+// Thumb2 unconditional branch has a range of +- 16 Megabytes. The
+// conditional branch has a range of +- 1 Megabyte. We should give
+// an error message if we evaluate the expression at assembly
+// time and it is out of range.
+
+        .syntax unified
+        .thumb
+        b.w end
+        .space 0xfffffe
+end:
+        b.w end2
+        .space 0xfffffe
+        .global end2
+end2:
+
+// branch to arm function uses relocation
+        b.w end3
+        .space 0x1000000
+        .global end3
+        .type end3, %function
+        .arm
+end3:   bx lr
+        .thumb
+
+// branch to thumb function is resolved at assembly time
+// CHECK-NOT: error
+// CHECK: [[@LINE+2]]:{{[0-9]}}: error: Relocation out of range
+// CHECK-LABEL: b.w end4
+        b.w end4
+        .space 0x1000000
+        .thumb_func
+end4:
+
+        beq.w end5
+        .space 0xffffc
+end5:
+
+// conditional branch to arm function uses relocation
+        beq.w end6
+        .arm
+        .type end6, %function
+        .space 0x100000
+end6:   bx lr
+        .thumb
+
+// conditional branch to thumb function resolved at assembly time
+// CHECK-NOT: error
+// CHECK: [[@LINE+2]]:{{[0-9]}}: error: Relocation out of range
+// CHECK-LABEL: beq.w end7
+        beq.w end7
+        .space 0x100000
+end7:
+
+start:
+        .space 0xfffffc
+        b.w start
+
+        .arm
+        .global start2
+        .type start2, %function
+start2:
+        .space 0x1000000
+        .thumb
+// branch to arm function uses relocation
+        b.w start2
+
+start3:
+        .space 0x1000000
+// branch to thumb function resolved at assembly time
+// CHECK-NOT: error
+// CHECK: [[@LINE+2]]:{{[0-9]}}: error: Relocation out of range
+// CHECK-LABEL: b.w start3
+        b.w start3
+
+start4:
+        .space 0xffffc
+        b.w start4
+
+        .arm
+        .global start5
+        .type start5, %function
+start5:
+        .space 0x100000
+        .thumb
+// conditional branch to arm function uses relocation
+        beq.w start5
+
+start6:
+        .space 0x100000
+// branch to thumb function resolved at assembly time
+// CHECK-NOT: error
+// CHECK: [[@LINE+2]]:{{[0-9]}}: error: Relocation out of range
+// CHECK-LABEL: beq.w start6
+        beq.w start6