ELF: Add support for short thunks on ARM.

[pcc]

Summary

A short thunk uses a direct branch (b or b.w) instruction, and is used
when the target has the same thumbness as the thunk and is within
direct branch range (32MB for ARM, 16MB for Thumb-2). Reduces the
size of Chromium for Android's .text section by around 160KB.

Depends on D44962

[ruiu]

Generally looking good.

lld/ELF/Thunks.cpp

67 ↗

(On Diff #140015)

It would be nice to explain as a comment about why we have more than one thunk for ARM.

73–76 ↗

(On Diff #140015)

Could you add comments for these new member functions?

234 ↗

(On Diff #140015)

I'd add a comment saying that this function returns true if the target is not Thumb and is within 2^26.

[peter.smith]

Thanks for putting in the effort to doing this, especially updating the tests! This can also apply to AArch64 as well. The only concern that I have right now are whether it is possible to construct an example that oscillates between short and long thunks and would infinite loop if it were not for the iteration count. In general transitioning from a short thunk to a large thunk will increase the distance between sections, however there is one case where adding a thunk, or increasing the distance can shorten a distance.

OS1 : { *(some sections) }
OS2 0x2000000 : { *(some more sections) }

If in OS1 the ThunkSection size increases then the gap between the InputSections following it and OS2 will narrow, this might mean that Thunks in OS2 that target OS1 can now be written as short range, which then shrinks the distance between OS1 and the InputSections after the OS2 ThunkSection. I haven't got a test case that provokes this behaviour, neither have I convinced myself that it is impossible. I think that this case could be avoided by never transitioning a thunk from long to short, but I think it will only be worth doing if it is possible to make a failing test case.

[pcc]

In D44963#1050495, @peter.smith wrote:

Thanks for putting in the effort to doing this, especially updating the tests! This can also apply to AArch64 as well. The only concern that I have right now are whether it is possible to construct an example that oscillates between short and long thunks and would infinite loop if it were not for the iteration count. In general transitioning from a short thunk to a large thunk will increase the distance between sections, however there is one case where adding a thunk, or increasing the distance can shorten a distance.

OS1 : { *(some sections) }
OS2 0x2000000 : { *(some more sections) }

If in OS1 the ThunkSection size increases then the gap between the InputSections following it and OS2 will narrow, this might mean that Thunks in OS2 that target OS1 can now be written as short range, which then shrinks the distance between OS1 and the InputSections after the OS2 ThunkSection. I haven't got a test case that provokes this behaviour, neither have I convinced myself that it is impossible. I think that this case could be avoided by never transitioning a thunk from long to short, but I think it will only be worth doing if it is possible to make a failing test case.

It seems to be possible. I was able to come up with this failing test case:

$ cat test.lds
SECTIONS {
  .foo : { *(.foo) }
  .bar 0x3000000 : { *(.bar) }
}
$ cat test.s
.section .foo,"ax",%progbits,unique,1
.zero 0x1000000

.section .foo,"ax",%progbits,unique,2
foo:
bl bar

.section .bar,"ax",%progbits,unique,1
bar:
bl foo
.zero 0x1000000
$ ../ra/bin/llvm-mc -triple armv7-unknown-gnu -filetype=obj -o test.o test.s; ../ra/bin/ld.lld test.o test.lds;objdump -d
../ra/bin/ld.lld: warning: lld uses blx instruction, no object with architecture supporting feature detected.
../ra/bin/ld.lld: warning: lld uses extended branch encoding, no object with architecture supporting feature detected.
../ra/bin/ld.lld: warning: lld may use movt/movw, no object with architecture supporting feature detected.
../ra/bin/ld.lld: error: thunk creation not converged

I also think this can be fixed by making sure that we cannot transition from long to short. I will implement that.

[pcc]

• Address review comments

[peter.smith]

Thanks for the update, I'm happy with the changes and the new test case.

[ruiu]

LGTM

Thank you for writing the comment. That improved the code quality a lot.

lld/ELF/Thunks.cpp

85 ↗

(On Diff #140152)

Should this be private to make it clear that only mayUseShortThunk() is a public interface?

272 ↗

(On Diff #140152)

Could you write assignment and return in separate lines?

lld/trunk/ELF/Thunks.cpp

 class AArch64ADRPThunk final : public Thunk {
 public:
   AArch64ADRPThunk(Symbol &Dest) : Thunk(Dest) {}
   uint32_t size() override { return 12; }
   void writeTo(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
 };
 
-// Specific ARM Thunk implementations. The naming convention is:
-// Source State, TargetState, Target Requirement, ABS or PI, Range
-class ARMV7ABSLongThunk final : public Thunk {
+// Base class for ARM thunks.
+//
+// An ARM thunk may be either short or long. A short thunk is simply a branch
+// (B) instruction, and it may be used to call ARM functions when the distance
+// from the thunk to the target is less than 32MB. Long thunks can branch to any
+// virtual address and can switch between ARM and Thumb, and they are
+// implemented in the derived classes. This class tries to create a short thunk
+// if the target is in range, otherwise it creates a long thunk.
+class ARMThunk : public Thunk {
 public:
-  ARMV7ABSLongThunk(Symbol &Dest) : Thunk(Dest) {}
+  ARMThunk(Symbol &Dest) : Thunk(Dest) {}
 
-  uint32_t size() override { return 12; }
+  bool mayUseShortThunk();
+  uint32_t size() override { return mayUseShortThunk() ? 4 : sizeLong(); }
   void writeTo(uint8_t *Buf) override;
-  void addSymbols(ThunkSection &IS) override;
   bool isCompatibleWith(RelType Type) const override;
+
+  // Returns the size of a long thunk.
+  virtual uint32_t sizeLong() = 0;
+
+  // Writes a long thunk to Buf.
+  virtual void writeLong(uint8_t *Buf) = 0;
+
+private:
+  // This field tracks whether all previously considered layouts would allow
+  // this thunk to be short. If we have ever needed a long thunk, we always
+  // create a long thunk, even if the thunk may be short given the current
+  // distance to the target. We do this because transitioning from long to short
+  // can create layout oscillations in certain corner cases which would prevent
+  // the layout from converging.
+  bool MayUseShortThunk = true;
 };
 
-class ARMV7PILongThunk final : public Thunk {
+// Base class for Thumb-2 thunks.
+//
+// This class is similar to ARMThunk, but it uses the Thumb-2 B.W instruction
+// which has a range of 16MB.
+class ThumbThunk : public Thunk {
 public:
-  ARMV7PILongThunk(Symbol &Dest) : Thunk(Dest) {}
+  ThumbThunk(Symbol &Dest) : Thunk(Dest) { Alignment = 2; }
 
-  uint32_t size() override { return 16; }
+  bool mayUseShortThunk();
+  uint32_t size() override { return mayUseShortThunk() ? 4 : sizeLong(); }
   void writeTo(uint8_t *Buf) override;
-  void addSymbols(ThunkSection &IS) override;
   bool isCompatibleWith(RelType Type) const override;
+
+  // Returns the size of a long thunk.
+  virtual uint32_t sizeLong() = 0;
+
+  // Writes a long thunk to Buf.
+  virtual void writeLong(uint8_t *Buf) = 0;
+
+private:
+  // See comment in ARMThunk above.
+  bool MayUseShortThunk = true;
 };
 
-class ThumbV7ABSLongThunk final : public Thunk {
+// Specific ARM Thunk implementations. The naming convention is:
+// Source State, TargetState, Target Requirement, ABS or PI, Range
+class ARMV7ABSLongThunk final : public ARMThunk {
 public:
-  ThumbV7ABSLongThunk(Symbol &Dest) : Thunk(Dest) { Alignment = 2; }
+  ARMV7ABSLongThunk(Symbol &Dest) : ARMThunk(Dest) {}
 
-  uint32_t size() override { return 10; }
-  void writeTo(uint8_t *Buf) override;
+  uint32_t sizeLong() override { return 12; }
+  void writeLong(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
-  bool isCompatibleWith(RelType Type) const override;
 };
 
-class ThumbV7PILongThunk final : public Thunk {
+class ARMV7PILongThunk final : public ARMThunk {
 public:
-  ThumbV7PILongThunk(Symbol &Dest) : Thunk(Dest) { Alignment = 2; }
+  ARMV7PILongThunk(Symbol &Dest) : ARMThunk(Dest) {}
 
-  uint32_t size() override { return 12; }
-  void writeTo(uint8_t *Buf) override;
+  uint32_t sizeLong() override { return 16; }
+  void writeLong(uint8_t *Buf) override;
+  void addSymbols(ThunkSection &IS) override;
+};
+
+class ThumbV7ABSLongThunk final : public ThumbThunk {
+public:
+  ThumbV7ABSLongThunk(Symbol &Dest) : ThumbThunk(Dest) {}
+
+  uint32_t sizeLong() override { return 10; }
+  void writeLong(uint8_t *Buf) override;
+  void addSymbols(ThunkSection &IS) override;
+};
+
+class ThumbV7PILongThunk final : public ThumbThunk {
+public:
+  ThumbV7PILongThunk(Symbol &Dest) : ThumbThunk(Dest) {}
+
+  uint32_t sizeLong() override { return 12; }
+  void writeLong(uint8_t *Buf) override;
   void addSymbols(ThunkSection &IS) override;
-  bool isCompatibleWith(RelType Type) const override;
 };
 
 // MIPS LA25 thunk
 class MipsThunk final : public Thunk {
 public:
   MipsThunk(Symbol &Dest) : Thunk(Dest) {}
 
   uint32_t size() override { return 16; }

 }
 
 // ARM Target Thunks
 static uint64_t getARMThunkDestVA(const Symbol &S) {
   uint64_t V = S.isInPlt() ? S.getPltVA() : S.getVA();
   return SignExtend64<32>(V);
 }
 
-void ARMV7ABSLongThunk::writeTo(uint8_t *Buf) {
+// This function returns true if the target is not Thumb and is within 2^26, and
+// it has not previously returned false (see comment for MayUseShortThunk).
+bool ARMThunk::mayUseShortThunk() {
+  if (!MayUseShortThunk)
+    return false;
+  uint64_t S = getARMThunkDestVA(Destination);
+  if (S & 1) {
+    MayUseShortThunk = false;
+    return false;
+  }
+  uint64_t P = getThunkTargetSym()->getVA();
+  int64_t Offset = S - P - 8;
+  MayUseShortThunk = llvm::isInt<26>(Offset);
+  return MayUseShortThunk;
+}
+
+void ARMThunk::writeTo(uint8_t *Buf) {
+  if (!mayUseShortThunk()) {
+    writeLong(Buf);
+    return;
+  }
+
+  uint64_t S = getARMThunkDestVA(Destination);
+  uint64_t P = getThunkTargetSym()->getVA();
+  int64_t Offset = S - P - 8;
+  const uint8_t Data[] = {
+    0x00, 0x00, 0x00, 0xea, // b S
+  };
+  memcpy(Buf, Data, sizeof(Data));
+  Target->relocateOne(Buf, R_ARM_JUMP24, Offset);
+}
+
+bool ARMThunk::isCompatibleWith(RelType Type) const {
+  // Thumb branch relocations can't use BLX
+  return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
+}
+
+// This function returns true if the target is Thumb and is within 2^25, and
+// it has not previously returned false (see comment for MayUseShortThunk).
+bool ThumbThunk::mayUseShortThunk() {
+  if (!MayUseShortThunk)
+    return false;
+  uint64_t S = getARMThunkDestVA(Destination);
+  if ((S & 1) == 0) {
+    MayUseShortThunk = false;
+    return false;
+  }
+  uint64_t P = getThunkTargetSym()->getVA() & ~1;
+  int64_t Offset = S - P - 4;
+  MayUseShortThunk = llvm::isInt<25>(Offset);
+  return MayUseShortThunk;
+}
+
+void ThumbThunk::writeTo(uint8_t *Buf) {
+  if (!mayUseShortThunk()) {
+    writeLong(Buf);
+    return;
+  }
+
+  uint64_t S = getARMThunkDestVA(Destination);
+  uint64_t P = getThunkTargetSym()->getVA();
+  int64_t Offset = S - P - 4;
+  const uint8_t Data[] = {
+      0x00, 0xf0, 0x00, 0xb0, // b.w S
+  };
+  memcpy(Buf, Data, sizeof(Data));
+  Target->relocateOne(Buf, R_ARM_THM_JUMP24, Offset);
+}
+
+bool ThumbThunk::isCompatibleWith(RelType Type) const {
+  // ARM branch relocations can't use BLX
+  return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
+}
+
+void ARMV7ABSLongThunk::writeLong(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x00, 0xc0, 0x00, 0xe3, // movw         ip,:lower16:S
       0x00, 0xc0, 0x40, 0xe3, // movt         ip,:upper16:S
       0x1c, 0xff, 0x2f, 0xe1, // bx   ip
   };
   uint64_t S = getARMThunkDestVA(Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_ABS, S);
 }
 
 void ARMV7ABSLongThunk::addSymbols(ThunkSection &IS) {
   addSymbol(Saver.save("__ARMv7ABSLongThunk_" + Destination.getName()),
             STT_FUNC, 0, IS);
   addSymbol("$a", STT_NOTYPE, 0, IS);
 }
 
-bool ARMV7ABSLongThunk::isCompatibleWith(RelType Type) const {
-  // Thumb branch relocations can't use BLX
-  return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
-}
-
-void ThumbV7ABSLongThunk::writeTo(uint8_t *Buf) {
+void ThumbV7ABSLongThunk::writeLong(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x40, 0xf2, 0x00, 0x0c, // movw         ip, :lower16:S
       0xc0, 0xf2, 0x00, 0x0c, // movt         ip, :upper16:S
       0x60, 0x47,             // bx   ip
   };
   uint64_t S = getARMThunkDestVA(Destination);
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_ABS_NC, S);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_ABS, S);
 }
 
 void ThumbV7ABSLongThunk::addSymbols(ThunkSection &IS) {
   addSymbol(Saver.save("__Thumbv7ABSLongThunk_" + Destination.getName()),
             STT_FUNC, 1, IS);
   addSymbol("$t", STT_NOTYPE, 0, IS);
 }
 
-bool ThumbV7ABSLongThunk::isCompatibleWith(RelType Type) const {
-  // ARM branch relocations can't use BLX
-  return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
-}
-
-void ARMV7PILongThunk::writeTo(uint8_t *Buf) {
+void ARMV7PILongThunk::writeLong(uint8_t *Buf) {
   const uint8_t Data[] = {
       0xf0, 0xcf, 0x0f, 0xe3, // P:  movw ip,:lower16:S - (P + (L1-P) + 8)
       0x00, 0xc0, 0x40, 0xe3, //     movt ip,:upper16:S - (P + (L1-P) + 8)
       0x0f, 0xc0, 0x8c, 0xe0, // L1: add ip, ip, pc
       0x1c, 0xff, 0x2f, 0xe1, //     bx r12
   };
   uint64_t S = getARMThunkDestVA(Destination);
   uint64_t P = getThunkTargetSym()->getVA();
   uint64_t Offset = S - P - 16;
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_MOVW_PREL_NC, Offset);
   Target->relocateOne(Buf + 4, R_ARM_MOVT_PREL, Offset);
 }
 
 void ARMV7PILongThunk::addSymbols(ThunkSection &IS) {
   addSymbol(Saver.save("__ARMV7PILongThunk_" + Destination.getName()), STT_FUNC,
             0, IS);
   addSymbol("$a", STT_NOTYPE, 0, IS);
 }
 
-bool ARMV7PILongThunk::isCompatibleWith(RelType Type) const {
-  // Thumb branch relocations can't use BLX
-  return Type != R_ARM_THM_JUMP19 && Type != R_ARM_THM_JUMP24;
-}
-
-void ThumbV7PILongThunk::writeTo(uint8_t *Buf) {
+void ThumbV7PILongThunk::writeLong(uint8_t *Buf) {
   const uint8_t Data[] = {
       0x4f, 0xf6, 0xf4, 0x7c, // P:  movw ip,:lower16:S - (P + (L1-P) + 4)
       0xc0, 0xf2, 0x00, 0x0c, //     movt ip,:upper16:S - (P + (L1-P) + 4)
       0xfc, 0x44,             // L1: add  r12, pc
       0x60, 0x47,             //     bx   r12
   };
   uint64_t S = getARMThunkDestVA(Destination);
   uint64_t P = getThunkTargetSym()->getVA() & ~0x1;
   uint64_t Offset = S - P - 12;
   memcpy(Buf, Data, sizeof(Data));
   Target->relocateOne(Buf, R_ARM_THM_MOVW_PREL_NC, Offset);
   Target->relocateOne(Buf + 4, R_ARM_THM_MOVT_PREL, Offset);
 }
 
 void ThumbV7PILongThunk::addSymbols(ThunkSection &IS) {
   addSymbol(Saver.save("__ThumbV7PILongThunk_" + Destination.getName()),
             STT_FUNC, 1, IS);
   addSymbol("$t", STT_NOTYPE, 0, IS);
 }
 
-bool ThumbV7PILongThunk::isCompatibleWith(RelType Type) const {
-  // ARM branch relocations can't use BLX
-  return Type != R_ARM_JUMP24 && Type != R_ARM_PC24 && Type != R_ARM_PLT32;
-}
-
 // Write MIPS LA25 thunk code to call PIC function from the non-PIC one.
 void MipsThunk::writeTo(uint8_t *Buf) {
   uint64_t S = Destination.getVA();
   write32(Buf, 0x3c190000); // lui   $25, %hi(func)
   write32(Buf + 4, 0x08000000 | (S >> 2)); // j     func
   write32(Buf + 8, 0x27390000); // addiu $25, $25, %lo(func)
   write32(Buf + 12, 0x00000000); // nop
   Target->relocateOne(Buf, R_MIPS_HI16, S);

lld/trunk/test/ELF/Inputs/arm-long-thunk-converge.lds

+SECTIONS {
+  .foo : { *(.foo) }
+  .bar 0x2000000 : { *(.bar) }
+}

lld/trunk/test/ELF/Inputs/far-long-arm-abs.s

+.global far
+.type far,%function
+far = 0x201001c
+
+.global too_far1
+.type too_far1,%function
+too_far1 = 0x2020014
+.global too_far2
+.type too_far2,%function
+too_far2 = 0x2020020
+.global too_far3
+.type too_far3,%function
+too_far3 = 0x202002c

lld/trunk/test/ELF/arm-branch-rangethunk.s

 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/far-arm-abs.s -o %tfar
 // RUN: ld.lld  %t %tfar -o %t2 2>&1
-// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck %s
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t2 | FileCheck --check-prefix=SHORT %s
+// RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %S/Inputs/far-long-arm-abs.s -o %tfarlong
+// RUN: ld.lld  %t %tfarlong -o %t3 2>&1
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t3 | FileCheck --check-prefix=LONG %s
 // REQUIRES: arm
  .syntax unified
  .section .text, "ax",%progbits
  .globl _start
  .balign 0x10000
  .type _start,%function
 _start:
  // address of too_far symbols are just out of range of ARM branch with
  // 26-bit immediate field and an addend of -8
  bl  too_far1
  b   too_far2
  beq too_far3
 
-// CHECK: Disassembly of section .text:
-// CHECK-NEXT: _start:
-// CHECK-NEXT:    20000:       01 00 00 eb     bl      #4 <__ARMv7ABSLongThunk_too_far1>
-// CHECK-NEXT:    20004:       03 00 00 ea     b       #12 <__ARMv7ABSLongThunk_too_far2>
-// CHECK-NEXT:    20008:       05 00 00 0a     beq     #20 <__ARMv7ABSLongThunk_too_far3>
-// CHECK: __ARMv7ABSLongThunk_too_far1:
-// CHECK-NEXT:    2000c:       08 c0 00 e3     movw    r12, #8
-// CHECK-NEXT:    20010:       02 c2 40 e3     movt    r12, #514
-// CHECK-NEXT:    20014:       1c ff 2f e1     bx      r12
-// CHECK: __ARMv7ABSLongThunk_too_far2:
-// CHECK-NEXT:    20018:       0c c0 00 e3     movw    r12, #12
-// CHECK-NEXT:    2001c:       02 c2 40 e3     movt    r12, #514
-// CHECK-NEXT:    20020:       1c ff 2f e1     bx      r12
-// CHECK: __ARMv7ABSLongThunk_too_far3:
-// CHECK-NEXT:    20024:       10 c0 00 e3     movw    r12, #16
-// CHECK-NEXT:    20028:       02 c2 40 e3     movt    r12, #514
-// CHECK-NEXT:    2002c:       1c ff 2f e1     bx      r12
+// SHORT: Disassembly of section .text:
+// SHORT-NEXT: _start:
+// SHORT-NEXT:    20000:       01 00 00 eb     bl      #4 <__ARMv7ABSLongThunk_too_far1>
+// SHORT-NEXT:    20004:       01 00 00 ea     b       #4 <__ARMv7ABSLongThunk_too_far2>
+// SHORT-NEXT:    20008:       01 00 00 0a     beq     #4 <__ARMv7ABSLongThunk_too_far3>
+// SHORT: __ARMv7ABSLongThunk_too_far1:
+// SHORT-NEXT:    2000c:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffff4>
+// SHORT: __ARMv7ABSLongThunk_too_far2:
+// SHORT-NEXT:    20010:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffff8>
+// SHORT: __ARMv7ABSLongThunk_too_far3:
+// SHORT-NEXT:    20014:       fd ff 7f ea     b       #33554420 <__ARMv7ABSLongThunk_too_far3+0x1fffffc>
+
+// LONG: Disassembly of section .text:
+// LONG-NEXT: _start:
+// LONG-NEXT:    20000:       01 00 00 eb     bl      #4 <__ARMv7ABSLongThunk_too_far1>
+// LONG-NEXT:    20004:       03 00 00 ea     b       #12 <__ARMv7ABSLongThunk_too_far2>
+// LONG-NEXT:    20008:       05 00 00 0a     beq     #20 <__ARMv7ABSLongThunk_too_far3>
+// LONG: __ARMv7ABSLongThunk_too_far1:
+// LONG-NEXT:    2000c:       14 c0 00 e3     movw    r12, #20
+// LONG-NEXT:    20010:       02 c2 40 e3     movt    r12, #514
+// LONG-NEXT:    20014:       1c ff 2f e1     bx      r12
+// LONG: __ARMv7ABSLongThunk_too_far2:
+// LONG-NEXT:    20018:       20 c0 00 e3     movw    r12, #32
+// LONG-NEXT:    2001c:       02 c2 40 e3     movt    r12, #514
+// LONG-NEXT:    20020:       1c ff 2f e1     bx      r12
+// LONG: __ARMv7ABSLongThunk_too_far3:
+// LONG-NEXT:    20024:       2c c0 00 e3     movw    r12, #44
+// LONG-NEXT:    20028:       02 c2 40 e3     movt    r12, #514
+// LONG-NEXT:    2002c:       1c ff 2f e1     bx      r12

lld/trunk/test/ELF/arm-long-thunk-converge.s

+// RUN: llvm-mc -triple armv7-unknown-gnu -filetype=obj -o %t %s
+// RUN: ld.lld %t %S/Inputs/arm-long-thunk-converge.lds -o %t2
+// RUN: llvm-objdump -d -start-address=0x00000000 -stop-address=0x00000010 -triple=armv7a-linux-gnueabihf %t2 | FileCheck --check-prefix=CHECK1 %s
+// RUN: llvm-objdump -d -start-address=0x02000000 -stop-address=0x02000010 -triple=armv7a-linux-gnueabihf %t2 | FileCheck --check-prefix=CHECK2 %s
+// RUN: rm -f %t2
+
+// CHECK1: __ARMv7ABSLongThunk_bar:
+// CHECK1-NEXT:        0:       0c c0 00 e3     movw    r12, #12
+// CHECK1-NEXT:        4:       00 c2 40 e3     movt    r12, #512
+// CHECK1-NEXT:        8:       1c ff 2f e1     bx      r12
+// CHECK1: foo:
+// CHECK1-NEXT:        c:       fb ff ff eb     bl      #-20
+
+.section .foo,"ax",%progbits,unique,1
+foo:
+bl bar
+
+// CHECK2: __ARMv7ABSLongThunk_foo:
+// CHECK2-NEXT:  2000000:       0c c0 00 e3     movw    r12, #12
+// CHECK2-NEXT:  2000004:       00 c0 40 e3     movt    r12, #0
+// CHECK2-NEXT:  2000008:       1c ff 2f e1     bx      r12
+// CHECK2: bar:
+// CHECK2-NEXT:  200000c:       fb ff ff eb     bl      #-20 <__ARMv7ABSLongThunk_foo>
+
+.section .bar,"ax",%progbits,unique,1
+bar:
+bl foo
+.zero 0x1000000

lld/trunk/test/ELF/arm-thumb-condbranch-thunk.s

 // Long Range Thunk needed for 16Mb range branch, can reach pre-created Thunk
 // Section
  bl tfunc33
 // CHECK1: Disassembly of section .text:
 // CHECK1-NEXT: tfunc00:
 // CHECK1-NEXT:    80000:       70 47   bx      lr
 // CHECK1-NEXT:    80002:       7f f3 ff d7     bl      #16252926
 // CHECK1: __Thumbv7ABSLongThunk_tfunc05:
-// CHECK1-NEXT:    80008:       40 f2 01 0c     movw    r12, #1
-// CHECK1-NEXT:    8000c:       c0 f2 30 0c     movt    r12, #48
-// CHECK1-NEXT:    80010:       60 47   bx      r12
+// CHECK1-NEXT:    80008:       7f f2 fa bf     b.w     #2621428 <tfunc05>
 // CHECK1: __Thumbv7ABSLongThunk_tfunc00:
-// CHECK1-NEXT:    80012:       40 f2 01 0c     movw    r12, #1
-// CHECK1-NEXT:    80016:       c0 f2 08 0c     movt    r12, #8
-// CHECK1-NEXT:    8001a:       60 47   bx      r12
+// CHECK1-NEXT:    8000c:       ff f7 f8 bf     b.w     #-16 <tfunc00>
  FUNCTION 01
 // tfunc02 is within range of tfunc02
  beq.w tfunc02
 // tfunc05 is out of range, and we can't reach the pre-created Thunk Section
 // create a new one.
  bne.w tfunc05
 // CHECK2:  tfunc01:
 // CHECK2-NEXT:   100000:       70 47   bx      lr
 // CHECK2-NEXT:   100002:       3f f0 fd a7     beq.w   #524282 <tfunc02>
 // CHECK2-NEXT:   100006:       7f f4 ff a7     bne.w   #-524290 <__Thumbv7ABSLongThunk_tfunc05>
  FUNCTION 02
 // We can reach the Thunk Section created for bne.w tfunc05
  bne.w tfunc05
  beq.w tfunc00
 // CHECK3:   180000:       70 47   bx      lr
 // CHECK3-NEXT:   180002:       40 f4 01 80     bne.w   #-1048574 <__Thumbv7ABSLongThunk_tfunc05>
-// CHECK3-NEXT:   180006:       00 f4 04 80     beq.w   #-1048568 <__Thumbv7ABSLongThunk_tfunc00>
+// CHECK3-NEXT:   180006:       00 f4 01 80     beq.w   #-1048574 <__Thumbv7ABSLongThunk_tfunc00>
  FUNCTION 03
  FUNCTION 04
  FUNCTION 05
  FUNCTION 06
  FUNCTION 07
  FUNCTION 08
  FUNCTION 09
 // CHECK4:  __Thumbv7ABSLongThunk_tfunc03:
-// CHECK4-NEXT:   500004:       40 f2 01 0c     movw    r12, #1
-// CHECK4-NEXT:   500008:       c0 f2 20 0c     movt    r12, #32
-// CHECK4-NEXT:   50000c:       60 47   bx      r12
+// CHECK4-NEXT:   500004:       ff f4 fc bf     b.w     #-3145736 <tfunc03>
  FUNCTION 10
 // We can't reach any Thunk Section, create a new one
  beq.w tfunc03
 // CHECK5: tfunc10:
 // CHECK5-NEXT:   580000:       70 47   bx      lr
 // CHECK5-NEXT:   580002:       3f f4 ff a7     beq.w   #-524290 <__Thumbv7ABSLongThunk_tfunc03>
  FUNCTION 11
  FUNCTION 12

  FUNCTION 25
  FUNCTION 26
  FUNCTION 27
  FUNCTION 28
  FUNCTION 29
  FUNCTION 30
  FUNCTION 31
 // CHECK6:  __Thumbv7ABSLongThunk_tfunc33:
-// CHECK6-NEXT:  1000004:       40 f2 01 0c     movw    r12, #1
-// CHECK6-NEXT:  1000008:       c0 f2 10 1c     movt    r12, #272
-// CHECK6-NEXT:  100000c:       60 47   bx      r12
+// CHECK6-NEXT:  1000004:       ff f0 fc bf     b.w     #1048568 <tfunc33>
 // CHECK6: __Thumbv7ABSLongThunk_tfunc00:
-// CHECK6-NEXT:  100000e:       40 f2 01 0c     movw    r12, #1
-// CHECK6-NEXT:  1000012:       c0 f2 08 0c     movt    r12, #8
-// CHECK6-NEXT:  1000016:       60 47   bx      r12
+// CHECK6-NEXT:  1000008:       7f f4 fa 97     b.w     #-16252940 <tfunc00>
  FUNCTION 32
  FUNCTION 33
  // We should be able to reach an existing ThunkSection.
  b.w tfunc00
 // CHECK7: tfunc33:
 // CHECK7-NEXT:  1100000:       70 47   bx      lr
-// CHECK7-NEXT:  1100002:       00 f7 04 b8     b.w     #-1048568 <__Thumbv7ABSLongThunk_tfunc00>
+// CHECK7-NEXT:  1100002:       00 f7 01 b8     b.w     #-1048574 <__Thumbv7ABSLongThunk_tfunc00>

lld/trunk/test/ELF/arm-thumb-range-thunk-os.s

 // CHECK3: tfunc01:
 // CHECK3-NEXT:   300000:       70 47   bx      lr
  FUNCTION 02
 // tfunc28 is > 16Mb away, expect a Range Thunk to be generated, to go into
 // the first of the pre-created ThunkSections.
         b.w tfunc28
 // CHECK4: tfunc02:
 // CHECK4-NEXT:   400000:       70 47   bx      lr
-// CHECK4-NEXT:   400002:       00 f0 04 90     b.w     #12582920 <__Thumbv7ABSLongThunk_tfunc28>
+// CHECK4-NEXT:   400002:       00 f0 01 90     b.w     #12582914 <__Thumbv7ABSLongThunk_tfunc28>
  FUNCTION 03
  FUNCTION 04
  FUNCTION 05
  FUNCTION 06
  FUNCTION 07
  FUNCTION 08
  FUNCTION 09
  FUNCTION 10
  FUNCTION 11
  FUNCTION 12
  FUNCTION 13
  FUNCTION 14
 // Expect precreated ThunkSection here
 // CHECK5: __Thumbv7ABSLongThunk_tfunc16:
-// CHECK5-NEXT:  1000004:       40 f2 01 0c     movw    r12, #1
-// CHECK5-NEXT:  1000008:       c0 f2 20 1c     movt    r12, #288
-// CHECK5-NEXT:  100000c:       60 47   bx      r12
+// CHECK5-NEXT:  1000004:       ff f1 fc bf     b.w     #2097144 <tfunc16>
 // CHECK5: __Thumbv7ABSLongThunk_tfunc28:
-// CHECK5-NEXT:  100000e:       40 f2 01 0c     movw    r12, #1
-// CHECK5-NEXT:  1000012:       c0 f2 e0 1c     movt    r12, #480
-// CHECK5-NEXT:  1000016:       60 47   bx      r12
+// CHECK5-NEXT:  1000008:       ff f1 fa 97     b.w     #14680052 <tfunc28>
 // CHECK5: __Thumbv7ABSLongThunk_tfunc32:
-// CHECK5-NEXT:  1000018:       40 f2 01 0c     movw    r12, #1
-// CHECK5-NEXT:  100001c:       c0 f2 20 2c     movt    r12, #544
-// CHECK5-NEXT:  1000020:       60 47   bx      r12
+// CHECK5-NEXT:  100000c:       40 f2 01 0c     movw    r12, #1
+// CHECK5-NEXT:  1000010:       c0 f2 20 2c     movt    r12, #544
+// CHECK5-NEXT:  1000014:       60 47   bx      r12
 // CHECK5: __Thumbv7ABSLongThunk_tfunc33:
-// CHECK5-NEXT:  1000022:       40 f2 01 0c     movw    r12, #1
-// CHECK5-NEXT:  1000026:       c0 f2 30 2c     movt    r12, #560
-// CHECK5-NEXT:  100002a:       60 47   bx      r12
+// CHECK5-NEXT:  1000016:       40 f2 01 0c     movw    r12, #1
+// CHECK5-NEXT:  100001a:       c0 f2 30 2c     movt    r12, #560
+// CHECK5-NEXT:  100001e:       60 47   bx      r12
 // CHECK5: __Thumbv7ABSLongThunk_tfunc02:
-// CHECK5-NEXT:  100002c:       40 f2 01 0c     movw    r12, #1
-// CHECK5-NEXT:  1000030:       c0 f2 40 0c     movt    r12, #64
-// CHECK5-NEXT:  1000034:       60 47   bx      r12
+// CHECK5-NEXT:  1000020:       ff f7 ee 97     b.w     #-12582948 <tfunc02>
  FUNCTION 15
 // tfunc00 and tfunc01 are < 16Mb away, expect no range extension thunks
  bl tfunc00
  bl tfunc01
 // tfunc32 and tfunc33 are > 16Mb away, expect range extension thunks in the
 // precreated thunk section
  bl tfunc32
  bl tfunc33
 // CHECK6:  tfunc15:
 // CHECK6-NEXT:  1100000:       70 47   bx      lr
 // CHECK6-NEXT:  1100002:       ff f4 fd d7     bl      #-15728646
 // CHECK6-NEXT:  1100006:       ff f5 fb d7     bl      #-14680074
-// CHECK6-NEXT:  110000a:       00 f7 05 f8     bl      #-1048566
-// CHECK6-NEXT:  110000e:       00 f7 08 f8     bl      #-1048560
+// CHECK6-NEXT:  110000a:       ff f6 ff ff     bl      #-1048578
+// CHECK6-NEXT:  110000e:       00 f7 02 f8     bl      #-1048572
  FUNCTION 16
  FUNCTION 17
  FUNCTION 18
  FUNCTION 19
  FUNCTION 20
  FUNCTION 21
  FUNCTION 22
  FUNCTION 23
  FUNCTION 24
  FUNCTION 25
  FUNCTION 26
  FUNCTION 27
  FUNCTION 28
 // tfunc02 is > 16Mb away, expect range extension thunks in precreated thunk
 // section
 // CHECK7:  tfunc28:
 // CHECK7-NEXT:  1e00000:       70 47   bx      lr
-// CHECK7-NEXT:  1e00002:       00 f6 13 90     b.w     #-14680026 <__Thumbv7ABSLongThunk_tfunc02>
+// CHECK7-NEXT:  1e00002:       00 f6 0d 90     b.w     #-14680038 <__Thumbv7ABSLongThunk_tfunc02>
 
  b.w tfunc02
  FUNCTION 29
 // Expect another precreated thunk section here
 // CHECK8: __Thumbv7ABSLongThunk_tfunc15:
-// CHECK8-NEXT:  1f00004:       40 f2 01 0c     movw    r12, #1
-// CHECK8-NEXT:  1f00008:       c0 f2 10 1c     movt    r12, #272
-// CHECK8-NEXT:  1f0000c:       60 47   bx      r12
+// CHECK8-NEXT:  1f00004:       ff f5 fc 97     b.w     #-14680072 <tfunc15>
 // CHECK8: __Thumbv7ABSLongThunk_tfunc16:
-// CHECK8-NEXT:  1f0000e:       40 f2 01 0c     movw    r12, #1
-// CHECK8-NEXT:  1f00012:       c0 f2 20 1c     movt    r12, #288
-// CHECK8-NEXT:  1f00016:       60 47   bx      r12
+// CHECK8-NEXT:  1f00008:       ff f6 fa 97     b.w     #-13631500 <tfunc16>
  FUNCTION 30
  FUNCTION 31
  FUNCTION 32
  // tfunc15 and tfunc16 are > 16 Mb away expect Thunks in the nearest
  // precreated thunk section.
  bl tfunc15
  bl tfunc16
 // CHECK9: tfunc32:
 // CHECK9:  2200000:    70 47   bx      lr
 // CHECK9-NEXT:  2200002:       ff f4 ff ff     bl      #-3145730
-// CHECK9-NEXT:  2200006:       00 f5 02 f8     bl      #-3145724
+// CHECK9-NEXT:  2200006:       ff f4 ff ff     bl      #-3145730
 
  FUNCTION 33
  bl tfunc15
  bl tfunc16
 // CHECK10: tfunc33:
 // CHECK10:  2300000:   70 47   bx      lr
 // CHECK10-NEXT:  2300002:      ff f7 ff f7     bl      #-4194306
-// CHECK10-NEXT:  2300006:      00 f4 02 f8     bl      #-4194300
+// CHECK10-NEXT:  2300006:      ff f7 ff f7     bl      #-4194306

lld/trunk/test/ELF/arm-thumb-thunk-empty-pass.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=thumbv7a-none-linux-gnueabi %s -o %t
 // RUN: ld.lld %t -o %t2 2>&1
 // RUN: llvm-objdump -d %t2 -start-address=69632 -stop-address=69646 -triple=thumbv7a-linux-gnueabihf | FileCheck -check-prefix=CHECK1 %s
-// RUN: llvm-objdump -d %t2 -start-address=16846860 -stop-address=16846874 -triple=thumbv7a-linux-gnueabihf | FileCheck -check-prefix=CHECK2 %s
+// RUN: llvm-objdump -d %t2 -start-address=16846856 -stop-address=16846874 -triple=thumbv7a-linux-gnueabihf | FileCheck -check-prefix=CHECK2 %s
  .syntax unified
  .global _start, foo
  .type _start, %function
  .section .text.start,"ax",%progbits
 _start:
  bl _start
  .section .text.dummy1,"ax",%progbits
  .space 0xfffffe
  .section .text.foo,"ax",%progbits
   .type foo, %function
 foo:
  bl _start
 
 // CHECK1: Disassembly of section .text:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:    11000:       ff f7 fe ff     bl      #-4
 // CHECK1: __Thumbv7ABSLongThunk__start:
-// CHECK1-NEXT:    11004:       41 f2 01 0c     movw    r12, #4097
-// CHECK1-NEXT:    11008:       c0 f2 01 0c     movt    r12, #1
-// CHECK1-NEXT:    1100c:       60 47   bx      r12
+// CHECK1-NEXT:    11004:       ff f7 fc bf     b.w     #-8 <_start>
 
 // CHECK2: __Thumbv7ABSLongThunk__start:
-// CHECK2:       101100c:       41 f2 01 0c     movw    r12, #4097
-// CHECK2-NEXT:  1011010:       c0 f2 01 0c     movt    r12, #1
-// CHECK2-NEXT:  1011014:       60 47   bx      r12
+// CHECK2:       1011008:       41 f2 01 0c     movw    r12, #4097
+// CHECK2-NEXT:  101100c:       c0 f2 01 0c     movt    r12, #1
+// CHECK2-NEXT:  1011010:       60 47   bx      r12
 // CHECK2: foo:
-// CHECK2-NEXT:  1011016:       ff f7 f9 ff     bl      #-14
+// CHECK2-NEXT:  1011012:       ff f7 f9 ff     bl      #-14

lld/trunk/test/ELF/arm-thunk-largesection.s

 // RUN: llvm-mc -filetype=obj -triple=thumbv7a-none-linux-gnueabi %s -o %t
 // RUN: ld.lld %t -o %t2 2>&1
 // RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=69632 -stop-address=69636 %t2 | FileCheck -check-prefix=CHECK1 %s
 // RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=73732 -stop-address=73742 %t2 | FileCheck -check-prefix=CHECK2 %s
-// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=16850944 -stop-address=16850948 %t2 | FileCheck -check-prefix=CHECK3 %s
-// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=33628160 -stop-address=33628164 %t2 | FileCheck -check-prefix=CHECK4 %s
-// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=50405364 -stop-address=50405376 %t2 | FileCheck -check-prefix=CHECK5 %s
+// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=16850936 -stop-address=16850940 %t2 | FileCheck -check-prefix=CHECK3 %s
+// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=33628152 -stop-address=33628156 %t2 | FileCheck -check-prefix=CHECK4 %s
+// RUN: llvm-objdump -d -triple=thumbv7a-none-linux-gnueabi -start-address=50405356 -stop-address=50405376 %t2 | FileCheck -check-prefix=CHECK5 %s
 // REQUIRES: arm
  .syntax unified
  .balign 0x1000
  .thumb
  .text
  .globl _start
  .type _start, %function
 _start:
  bx lr
  .space 0x1000
 // CHECK1: Disassembly of section .text:
 // CHECK1-NEXT: _start:
 // CHECK1-NEXT:    11000:       70 47   bx      lr
 // CHECK1-NEXT:    11002:       00 00   movs    r0, r0
 
 // CHECK2: __Thumbv7ABSLongThunk__start:
-// CHECK2-NEXT:    12004:       41 f2 01 0c     movw    r12, #4097
-// CHECK2-NEXT:    12008:       c0 f2 01 0c     movt    r12, #1
-// CHECK2-NEXT:    1200c:       60 47   bx      r12
+// CHECK2-NEXT:    12004:       fe f7 fc bf     b.w     #-4104 <_start>
 
 // Gigantic section where we need a ThunkSection either side of it
  .section .text.large1, "ax", %progbits
  .balign 4
  .space (16 * 1024 * 1024) - 16
  bl _start
  .space (16 * 1024 * 1024) - 4
  bl _start
  .space (16 * 1024 * 1024) - 16
-// CHECK3: 1012000:     00 f4 00 d0     bl      #-16777216
-// CHECK4: 2012000:     ff f3 f8 d7     bl      #16777200
+// CHECK3: 1011ff8:     00 f4 04 d0     bl      #-16777208
+// CHECK4: 2011ff8:     ff f3 f8 d7     bl      #16777200
 
 // CHECK5: __Thumbv7ABSLongThunk__start:
-// CHECK5-NEXT:  3011ff4:       41 f2 01 0c     movw    r12, #4097
-// CHECK5-NEXT:  3011ff8:       c0 f2 01 0c     movt    r12, #1
-// CHECK5-NEXT:  3011ffc:       60 47   bx      r12
+// CHECK5-NEXT:  3011fec:       41 f2 01 0c     movw    r12, #4097
+// CHECK5-NEXT:  3011ff0:       c0 f2 01 0c     movt    r12, #1
+// CHECK5-NEXT:  3011ff4:       60 47   bx      r12

lld/trunk/test/ELF/arm-thunk-linkerscript-large.s

  FUNCTIONL 03
  FUNCTIONL 04
  FUNCTIONL 05
  FUNCTIONL 06
  FUNCTIONL 07
  FUNCTIONL 08
  FUNCTIONL 09
 // CHECK3: __Thumbv7ABSLongThunk_tfuncl24:
-// CHECK3-NEXT:   b00004: 40 f2 01 0c   movw  r12, #1
-// CHECK3-NEXT:   b00008: c0 f2 a0 1c   movt  r12, #416
-// CHECK3-NEXT:   b0000c: 60 47   bx  r12
+// CHECK3-NEXT:   b00004:      ff f2 fc 97     b.w     #15728632 <tfuncl24>
  FUNCTIONL 10
  FUNCTIONL 11
  FUNCTIONL 12
  FUNCTIONL 13
  FUNCTIONL 14
  FUNCTIONL 15
  FUNCTIONL 16
  FUNCTIONL 17

lld/trunk/test/ELF/arm-thunk-linkerscript-sort.s

  FUNCTION 21
  FUNCTION 20
  FUNCTION 19
  FUNCTION 18
  FUNCTION 17
  FUNCTION 16
  FUNCTION 15
 // CHECK2: __Thumbv7ABSLongThunk_tfunc31:
-// CHECK2-NEXT:  1000004:       40 f2 01 0c     movw    r12, #1
-// CHECK2-NEXT:  1000008:       c0 f2 00 2c     movt    r12, #512
-// CHECK2-NEXT:  100000c:       60 47   bx      r12
+// CHECK2-NEXT:  1000004:       ff f3 fc 97     b.w     #16777208 <tfunc31>
  FUNCTION 14
  FUNCTION 13
  FUNCTION 12
  FUNCTION 11
  FUNCTION 10
  FUNCTION 09
  FUNCTION 08
  FUNCTION 07

lld/trunk/test/ELF/arm-thunk-multipass.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t
 // RUN: ld.lld %t -o %t2 2>&1
 // The output file is large, most of it zeroes. We dissassemble only the
 // parts we need to speed up the test and avoid a large output file
 // RUN: llvm-objdump -d %t2 -start-address=1048578 -stop-address=1048586 -triple=thumbv7a-linux-gnueabihf  | FileCheck -check-prefix=CHECK1 %s
 // RUN: llvm-objdump -d %t2 -start-address=16777224 -stop-address=16777254 -triple=thumbv7a-linux-gnueabihf  | FileCheck -check-prefix=CHECK2 %s
-// RUN: llvm-objdump -d %t2 -start-address=17825818 -stop-address=17825828 -triple=thumbv7a-linux-gnueabihf  | FileCheck -check-prefix=CHECK3 %s
+// RUN: llvm-objdump -d %t2 -start-address=17825812 -stop-address=17825826 -triple=thumbv7a-linux-gnueabihf  | FileCheck -check-prefix=CHECK3 %s
 // In this test case a branch that is in range and does not need its range
 // extended can be pushed out of range by another Thunk, necessitating another
 // pass
 
  .macro FUNCTION suff
  .section .text.\suff\(), "ax", %progbits
  .thumb
  .balign 0x100000

  .type arm_target, %function
 arm_target:
  bx lr
 // CHECK2: __Thumbv7ABSLongThunk_arm_target:
 // CHECK2-NEXT:  1000008:       40 f2 02 0c     movw    r12, #2
 // CHECK2-NEXT:  100000c:       c0 f2 00 1c     movt    r12, #256
 // CHECK2-NEXT:  1000010:       60 47   bx      r12
 // CHECK2: __Thumbv7ABSLongThunk_target:
-// CHECK2-NEXT:  1000012:       40 f2 1b 0c     movw    r12, #27
-// CHECK2-NEXT:  1000016:       c0 f2 10 1c     movt    r12, #272
-// CHECK2-NEXT:  100001a:       60 47   bx      r12
+// CHECK2-NEXT:  1000012:       ff f0 ff bf     b.w     #1048574 <target>
 // CHECK2: __Thumbv7ABSLongThunk_target2:
-// CHECK2-NEXT:  100001c:       40 f2 13 0c     movw    r12, #19
-// CHECK2-NEXT:  1000020:       c0 f2 10 0c     movt    r12, #16
-// CHECK2-NEXT:  1000024:       60 47   bx      r12
+// CHECK2-NEXT:  1000016:       ff f4 fc 97     b.w     #-15728648 <target2>
 
  .section .text.17, "ax", %progbits
 // Just enough space so that bl target is in range if no extension thunks are
 // generated.
 
- .space 0x100000 - 12
+ .space 0x100000 - 6
 
  .section .text.18, "ax", %progbits
  .thumb
  .globl target
  .type target, %function
 // target is at maximum ARM branch range away from caller.
 target:
 // Similar case in the backwards direction
  bl target2
  nop
  nop
  bx lr
 // CHECK3: target:
-// CHECK3-NEXT:  110001a:       ff f6 ff ff     bl      #-1048578
-// CHECK3-NEXT:  110001e:       00 bf   nop
-// CHECK3-NEXT:  1100020:       00 bf   nop
-// CHECK3-NEXT:  1100022:       70 47   bx      lr
+// CHECK3-NEXT:  1100014:       ff f6 ff ff     bl      #-1048578
+// CHECK3-NEXT:  1100018:       00 bf   nop
+// CHECK3-NEXT:  110001a:       00 bf   nop
+// CHECK3-NEXT:  110001c:       70 47   bx      lr