Fix 24560: assembler does not share constant pool for same constants

[weimingz]

Summary

This patch returns the same label if the CP entry with the same value has been created.

[jmolloy]

Hi,

Please post with full context.

Please add tests that ensure the behaviour is correct when there are multiple references to a constant and one of them is out of range (the constant should be duplicated in this case).

James

[weimingz]

Forgot to include the full context in previous diff.

Regarding the out-of-range test, give a test like:
foo1:
PUSH {r4-r6,lr}
LDR r7, =0x80808080
.space 0x1000
LDR r7, =0x80808080

Existing llvm-mc gives "error: out of range pc-relative fixup value". Similarly, gnu-as gives "Error: invalid literal constant: pool needs to be closer"
Is our case, if the first LDR is valid (within the range), then following LDR to the same constant should be valid as well since we always put CP at the end.

[rengolin]

In D25804#575584, @weimingz wrote:

Regarding the out-of-range test, give a test like:
foo1:
PUSH {r4-r6,lr}
LDR r7, =0x80808080
.space 0x1000
LDR r7, =0x80808080

Existing llvm-mc gives "error: out of range pc-relative fixup value". Similarly, gnu-as gives "Error: invalid literal constant: pool needs to be closer"
Is our case, if the first LDR is valid (within the range), then following LDR to the same constant should be valid as well since we always put CP at the end.

I think this makes sense.

The side effects of the caching are of *removing* constants, not adding them, so if anything, the range of the original load should be shorter, not longer. The number of instructions are also the same, so overall, this should never increase the code/data in any way.

Also, whatever relocation didn't work before (negative, wrong range, wrong relocation), will keep not working, but that's nothing to do with the patch itself.

cheers,
--renato

[weimingz]

@jmolloy HI James, do you have any comments?

[majnemer]

lib/MC/ConstantPools.cpp

40–41 ↗

(On Diff #75318)

You could save a lookup by using find/end instead of count/operator[]

[weimingz]

Use find/end as David suggested

[jmolloy]

No more comments from me

[jmolloy]

Explicitly accepting.

[weimingz]

rebase

[strejda]

This commit causes https://bugs.llvm.org//show_bug.cgi?id=32825

In D25804#575584, @weimingz wrote:

Regarding the out-of-range test, give a test like:
foo1:
PUSH {r4-r6,lr}
LDR r7, =0x80808080
.space 0x1000
LDR r7, =0x80808080

Existing llvm-mc gives "error: out of range pc-relative fixup value". Similarly, gnu-as gives "Error: invalid literal constant: pool needs to be closer"
Is our case, if the first LDR is valid (within the range), then following LDR to the same constant should be valid as well since we always put CP at the end.

The above example is invalid, you must use .ltorg to ensure literal pool accessibility.
The corrected(valid) code can be compiled by gnu-as, but not by llvm-mc

foo1:
    PUSH {r4-r6,lr}
    LDR r7, =0x80808080
    .ltorg
    .space 0x1000
    LDR r7, =0x80808080
    .ltorg

Can you, please, fix or revert it? It's a clear regression as the example can be compiled using llvm 3.9 but not by llvm 4.0+..
Thanks.

[jmolloy]

PR32825 seems valid and has been open for some time. Weiming, I have reverted this in r303535.

Cheers,

James

[mstorsjo]

In D25804#760631, @jmolloy wrote:

PR32825 seems valid and has been open for some time. Weiming, I have reverted this in r303535.

Wasn't PR32825 already fixed by rL302416 (D32847)?

[jmolloy]

Re-writing here because phab didn't pick up my email reply.

I have double checked the PR, and yes, it is fixed on ToT. From my perspective what I saw is a commit that I'd LGTM'd with an open PR and no response from the author, which is why I backed it out.

I've recommitted the two backed out diffs and updated PR32825 as resolved.

James

[mstorsjo]

Can you, please, fix or revert it? It's a clear regression as the example can be compiled using llvm 3.9 but not by llvm 4.0+..

WRT to this being a regression in llvm 4.0 - it might be a little late to try to get the fix merged into 4.0.1. Although, the window for opening such a merge request closes today, so if you feel it's urgent, perhaps such a merge request should be opened?

[mstorsjo]

In D25804#760717, @mstorsjo wrote:

Can you, please, fix or revert it? It's a clear regression as the example can be compiled using llvm 3.9 but not by llvm 4.0+..

WRT to this being a regression in llvm 4.0 - it might be a little late to try to get the fix merged into 4.0.1. Although, the window for opening such a merge request closes today, so if you feel it's urgent, perhaps such a merge request should be opened?

I opened a merge request for this fix in https://bugs.llvm.org/show_bug.cgi?id=33122 in any case.

llvm/trunk/include/llvm/MC/ConstantPools.h

 #include "llvm/Support/SMLoc.h"
 
 namespace llvm {
 class MCContext;
 class MCExpr;
 class MCSection;
 class MCStreamer;
 class MCSymbol;
+class MCSymbolRefExpr;
 
 struct ConstantPoolEntry {
   ConstantPoolEntry(MCSymbol *L, const MCExpr *Val, unsigned Sz, SMLoc Loc_)
     : Label(L), Value(Val), Size(Sz), Loc(Loc_) {}
   MCSymbol *Label;
   const MCExpr *Value;
   unsigned Size;
   SMLoc Loc;
 };
 
 // A class to keep track of assembler-generated constant pools that are use to
 // implement the ldr-pseudo.
 class ConstantPool {
   typedef SmallVector<ConstantPoolEntry, 4> EntryVecTy;
   EntryVecTy Entries;
+  DenseMap<int64_t, const MCSymbolRefExpr *> CachedEntries;
 
 public:
   // Initialize a new empty constant pool
   ConstantPool() {}
 
   // Add a new entry to the constant pool in the next slot.
   // \param Value is the new entry to put in the constant pool.
   // \param Size is the size in bytes of the entry

llvm/trunk/lib/MC/ConstantPools.cpp

for (const ConstantPoolEntry &Entry : Entries) {
     Streamer.EmitValue(Entry.Value, Entry.Size, Entry.Loc);
   }
   Streamer.EmitDataRegion(MCDR_DataRegionEnd);
   Entries.clear();
 }
 
 const MCExpr *ConstantPool::addEntry(const MCExpr *Value, MCContext &Context,
                                      unsigned Size, SMLoc Loc) {
+  const MCConstantExpr *C = dyn_cast<MCConstantExpr>(Value);
+
+  // Check if there is existing entry for the same constant. If so, reuse it.
+  auto Itr = C ? CachedEntries.find(C->getValue()) : CachedEntries.end();
+  if (Itr != CachedEntries.end())
+    return Itr->second;
+
   MCSymbol *CPEntryLabel = Context.createTempSymbol();
 
   Entries.push_back(ConstantPoolEntry(CPEntryLabel, Value, Size, Loc));
-  return MCSymbolRefExpr::create(CPEntryLabel, Context);
+  const auto SymRef = MCSymbolRefExpr::create(CPEntryLabel, Context);
+  if (C)
+    CachedEntries[C->getValue()] = SymRef;
+  return SymRef;
 }
 
 bool ConstantPool::empty() { return Entries.empty(); }
 
 //
 // AssemblerConstantPools implementation
 //
 ConstantPool *AssemblerConstantPools::getConstantPool(MCSection *Section) {

llvm/trunk/test/MC/AArch64/ldr-pseudo.s

// CHECK: ldr w0, .Ltmp[[TMP3:[0-9]+]]
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   ldr w0, =0x10004
-// CHECK: ldr w0, .Ltmp[[TMP4:[0-9]+]]
+// CHECK: ldr w0, .Ltmp[[TMP3:[0-9]+]]
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
   adds x0, x0, #1
 
 // a section defined in multiple pieces should be merged and use a single constant pool

 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP2]]
 // CHECK: .word 65539
 
 // CHECK: .section d,"ax",@progbits
 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP3]]
 // CHECK: .word 65540
-// CHECK: .p2align 2
-// CHECK: .Ltmp[[TMP4]]
-// CHECK: .word 65540
 
 // CHECK: .section e,"ax",@progbits
 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP5]]
 // CHECK: .word 65542
 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP6]]
 // CHECK: .word 65543

 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP24]]
 // CHECK: .word -1
 
 // CHECK: .section o,"ax",@progbits
 // CHECK: .p2align 2
 // CHECK: .Ltmp[[TMP25]]
 // CHECK: .word 3276900
-// CHECK: .p2align 3
-// CHECK: .Ltmp[[TMP26]]
-// CHECK: .xword 3276900

llvm/trunk/test/MC/ARM/ldr-pseudo-darwin.s

@ CHECK: ldr r0, Ltmp3
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   ldr r0, =0x10005
-@ CHECK: ldr r0, Ltmp4
+@ CHECK: ldr r0, Ltmp3
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
 
 @ a section defined in multiple pieces should be merged and use a single constant pool
 .section __TEXT,e,regular,pure_instructions
 @ CHECK-LABEL: f6:
 f6:
   ldr r0, =0x10006
-@ CHECK: ldr r0, Ltmp5
+@ CHECK: ldr r0, Ltmp4
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
 
 .section __TEXT,f,regular,pure_instructions
 @ CHECK-LABEL: f7:
 f7:
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
 
 .section __TEXT,e,regular,pure_instructions
 @ CHECK-LABEL: f8:
 f8:
   adds r0, r0, #1
   ldr r0, =0x10007
-@ CHECK: ldr r0, Ltmp6
+@ CHECK: ldr r0, Ltmp5
   adds r0, r0, #1
   adds r0, r0, #1
 
 @
 @ Check that symbols can be loaded using ldr pseudo
 @
 
 @ load an undefined symbol
 .section __TEXT,g,regular,pure_instructions
 @ CHECK-LABEL: f9:
 f9:
   ldr r0, =foo
-@ CHECK: ldr r0, Ltmp7
+@ CHECK: ldr r0, Ltmp6
 
 @ load a symbol from another section
 .section __TEXT,h,regular,pure_instructions
 @ CHECK-LABEL: f10:
 f10:
   ldr r0, =f5
-@ CHECK: ldr r0, Ltmp8
+@ CHECK: ldr r0, Ltmp7
 
 @ load a symbol from the same section
 .section __TEXT,i,regular,pure_instructions
 @ CHECK-LABEL: f11:
 f11:
   ldr r0, =f12
-@ CHECK: ldr r0, Ltmp9
+@ CHECK: ldr r0, Ltmp8
 
 @ CHECK-LABEL: f12:
 f12:
   adds r0, r0, #1
   adds r0, r0, #1
 
 .section __TEXT,j,regular,pure_instructions
 @ mix of symbols and constants
 @ CHECK-LABEL: f13:
 f13:
   adds r0, r0, #1
   adds r0, r0, #1
   ldr r0, =0x10008
-@ CHECK: ldr r0, Ltmp10
+@ CHECK: ldr r0, Ltmp9
   adds r0, r0, #1
   adds r0, r0, #1
   ldr r0, =bar
-@ CHECK: ldr r0, Ltmp11
+@ CHECK: ldr r0, Ltmp10
   adds r0, r0, #1
   adds r0, r0, #1
 @
 @ Check for correct usage in other contexts
 @
 
 @ usage in macro
 .macro useit_in_a_macro
   ldr r0, =0x10009
   ldr r0, =baz
 .endm
 .section __TEXT,k,regular,pure_instructions
 @ CHECK-LABEL: f14:
 f14:
   useit_in_a_macro
+@ CHECK: ldr r0, Ltmp11
 @ CHECK: ldr r0, Ltmp12
-@ CHECK: ldr r0, Ltmp13
 
 @ usage with expressions
 .section __TEXT,l,regular,pure_instructions
 @ CHECK-LABEL: f15:
 f15:
   ldr r0, =0x10001+9
-@ CHECK: ldr r0, Ltmp14
+@ CHECK: ldr r0, Ltmp13
   adds r0, r0, #1
   ldr r0, =bar+4
-@ CHECK: ldr r0, Ltmp15
+@ CHECK: ldr r0, Ltmp14
   adds r0, r0, #1
 
 @ transformation to mov
 .section __TEXT,m,regular,pure_instructions
 @ CHECK-LABEL: f16:
 f16:
 
 @ Representable in ARM, and Thumb with support mov.w or movw
   ldr r1, =0x1
 @ CHECK-ARM: mov r1, #1
 @ CHECK-ARMV5: mov r1, #1
-@ CHECK-THUMB: ldr r1, Ltmp16
+@ CHECK-THUMB: ldr r1, Ltmp15
 @ CHECK-THUMB2: mov.w r1, #1
 @ CHECK-BASELINE: movw r1, #1
 
 @ Immediate is representable in A1 and T2 modified immediate only not movw
   ldr r2, =0x120000
 @ CHECK-ARM: mov r2, #1179648
 @ CHECK-ARMV5: mov r2, #1179648
-@ CHECK-THUMB: ldr r2, Ltmp17
+@ CHECK-THUMB: ldr r2, Ltmp16
 @ CHECK-THUMB2: mov.w r2, #1179648
-@ CHECK-BASELINE: ldr r2, Ltmp16
+@ CHECK-BASELINE: ldr r2, Ltmp15
 
 @ Immediate can be represented only with movw instruction
   ldr r3, =0x1234
 @ CHECK-ARM: movw r3, #4660
-@ CHECK-ARMV5: ldr r3, Ltmp16
-@ CHECK-THUMB: ldr r3, Ltmp18
+@ CHECK-ARMV5: ldr r3, Ltmp15
+@ CHECK-THUMB: ldr r3, Ltmp17
 @ CHECK-THUMB2: movw r3, #4660
 @ CHECK-BASELINE: movw r3, #4660
 
 @ Immediate can be represented only with T2 modified immediate
   ldr r4, =0xabababab
-@ CHECK-ARM: ldr r4, Ltmp16
-@ CHECK-ARMV5: ldr r4, Ltmp17
-@ CHECK-THUMB: ldr r4, Ltmp19
+@ CHECK-ARM: ldr r4, Ltmp15
+@ CHECK-ARMV5: ldr r4, Ltmp16
+@ CHECK-THUMB: ldr r4, Ltmp18
 @ CHECK-THUMB2: mov.w r4, #2880154539
-@ CHECK-BASELINE: ldr r4, Ltmp17
+@ CHECK-BASELINE: ldr r4, Ltmp16
 
 @ Immediate can be represented only with A1 modified immediate
   ldr r5, =0x1000000b
 @ CHECK-ARM: mov r5, #268435467
 @ CHECK-ARMV5: mov r5, #268435467
-@ CHECK-THUMB: ldr r5, Ltmp20
-@ CHECK-THUMB2: ldr r5, Ltmp16
-@ CHECK-BASELINE: ldr r5, Ltmp18
+@ CHECK-THUMB: ldr r5, Ltmp19
+@ CHECK-THUMB2: ldr r5, Ltmp15
+@ CHECK-BASELINE: ldr r5, Ltmp17
 
 @ Negative numbers can be used with MVN or in Thumb2 with modified immediate
   ldr r6, =-1
 @ CHECK-ARM: mvn r6, #0
 @ CHECK-ARMV5: mvn r6, #0
-@ CHECK-THUMB: ldr r6, Ltmp21
+@ CHECK-THUMB: ldr r6, Ltmp20
 @ CHECK-THUMB2: mov.w r6, #-1
-@ CHECK-BASELINE: ldr r6, Ltmp19
+@ CHECK-BASELINE: ldr r6, Ltmp18
   ldr r7, =-0x100
 @ CHECK-ARM: mvn r7, #255
 @ CHECK-ARMV5: mvn r7, #255
-@ CHECK-THUMB: ldr r7, Ltmp22
+@ CHECK-THUMB: ldr r7, Ltmp21
 @ CHECK-THUMB2: mvn r7, #255
-@ CHECK-BASELINE: ldr r7, Ltmp20
+@ CHECK-BASELINE: ldr r7, Ltmp19
 
 @ Constant expressions can be used
   .equ expr, 0x10 + 0x10
   ldr r0, = expr
 @ CHECK-ARM: mov r0, #32
 @ CHECK-ARMV5: mov r0, #32
-@ CHECK-THUMB: ldr r0, Ltmp23
+@ CHECK-THUMB: ldr r0, Ltmp22
 @ CHECK-THUMB2: mov.w r0, #32
 @ CHECK-BASELINE: movw r0, #32
   ldr r1, = expr - 0x10
 @ CHECK-ARM: mov r1, #16
 @ CHECK-ARMV5: mov r1, #16
-@ CHECK-THUMB: ldr r1, Ltmp24
+@ CHECK-THUMB: ldr r1, Ltmp23
 @ CHECK-THUMB2: mov.w r1, #16
 @ CHECK-BASELINE: movw r1, #16
 
 @ usage of translation in macro
 .macro usemov_in_a_macro
   ldr r2, =0x3
   ldr r3, =expr
 .endm
 @ CHECK-LABEL: f17:
 f17:
   usemov_in_a_macro
 @ CHECK-ARM: mov r2, #3
 @ CHECK-ARM: mov r3, #32
 @ CHECK-ARMV5: mov r2, #3
 @ CHECK-ARMV5: mov r3, #32
-@ CHECK-THUMB: ldr r2, Ltmp25
-@ CHECK-THUMB: ldr r3, Ltmp26
+@ CHECK-THUMB: ldr r2, Ltmp24
+@ CHECK-THUMB: ldr r3, Ltmp22
 @ CHECK-THUMB2: mov.w r2, #3
 @ CHECK-THUMB2: mov.w r3, #32
 @ CHECK-BASELINE: movw r2, #3
 @ CHECK-BASELINE: movw r3, #32
 @
 @ Constant Pools
 @
 @ CHECK: .section __TEXT,b,regular,pure_instructions

 @ CHECK: .long 65540
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,d,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
 @ CHECK-LABEL: Ltmp3:
 @ CHECK: .long 65541
-@ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp4:
-@ CHECK: .long 65541
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,e,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp5:
+@ CHECK-LABEL: Ltmp4:
 @ CHECK: .long 65542
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp6:
+@ CHECK-LABEL: Ltmp5:
 @ CHECK: .long 65543
 @ CHECK: .end_data_region
 
 @ Should not switch to section because it has no constant pool
 @ CHECK-NOT: .section __TEXT,f,regular,pure_instructions
 
 @ CHECK: .section __TEXT,g,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp7:
+@ CHECK-LABEL: Ltmp6:
 @ CHECK: .long foo
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,h,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp8:
+@ CHECK-LABEL: Ltmp7:
 @ CHECK: .long f5
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,i,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp9:
+@ CHECK-LABEL: Ltmp8:
 @ CHECK: .long f12
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,j,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp10:
+@ CHECK-LABEL: Ltmp9:
 @ CHECK: .long 65544
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp11:
+@ CHECK-LABEL: Ltmp10:
 @ CHECK: .long bar
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,k,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp12:
+@ CHECK-LABEL: Ltmp11:
 @ CHECK: .long 65545
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp13:
+@ CHECK-LABEL: Ltmp12:
 @ CHECK: .long baz
 @ CHECK: .end_data_region
 
 @ CHECK: .section __TEXT,l,regular,pure_instructions
 @ CHECK: .data_region
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp14:
+@ CHECK-LABEL: Ltmp13:
 @ CHECK: .long 65546
 @ CHECK: .p2align 2
-@ CHECK-LABEL: Ltmp15:
+@ CHECK-LABEL: Ltmp14:
 @ CHECK: .long bar+4
 @ CHECK: .end_data_region

llvm/trunk/test/MC/ARM/ldr-pseudo-wide.s

 f1:
   ldr r0, =0x10002
 @ CHECK-ARM: ldr r0, .Ltmp[[TMP0:[0-9]+]]
 @ CHECK-DARWIN-ARM: ldr r0, Ltmp0
 @ CHECK-THUMB2: ldr r0, .Ltmp[[TMP0:[0-9]+]]
 @ CHECK-DARWIN-THUMB2: ldr r0, Ltmp0
 
   ldr.w r0, =0x10002
-@ CHECK-ARM: ldr r0, .Ltmp[[TMP1:[0-9]+]]
-@ CHECK-DARWIN-ARM: ldr r0, Ltmp1
-@ CHECK-THUMB2: ldr.w r0, .Ltmp[[TMP1:[0-9]+]]
-@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp1
+@ CHECK-ARM: ldr r0, .Ltmp[[TMP0]]
+@ CHECK-DARWIN-ARM: ldr r0, Ltmp0
+@ CHECK-THUMB2: ldr.w r0, .Ltmp[[TMP0:[0-9]+]]
+@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp0
 @ CHECK-THUMB: error: instruction requires: thumb2
 @ CHECK-THUMB-NEXT:  ldr.w r0, =0x10002
 
 @ CHECK-LABEL: f2:
 f2:
   ldr r0, =foo
-@ CHECK-ARM: ldr r0, .Ltmp[[TMP2:[0-9]+]]
-@ CHECK-DARWIN-ARM: ldr r0, Ltmp2
-@ CHECK-THUMB2: ldr r0, .Ltmp[[TMP2:[0-9]+]]
-@ CHECK-DARWIN-THUMB2: ldr r0, Ltmp2
+@ CHECK-ARM: ldr r0, .Ltmp[[TMP1:[0-9]+]]
+@ CHECK-DARWIN-ARM: ldr r0, Ltmp1
+@ CHECK-THUMB2: ldr r0, .Ltmp[[TMP1:[0-9]+]]
+@ CHECK-DARWIN-THUMB2: ldr r0, Ltmp1
 
   ldr.w r0, =foo
-@ CHECK-ARM: ldr r0, .Ltmp[[TMP3:[0-9]+]]
-@ CHECK-DARWIN-ARM: ldr r0, Ltmp3
-@ CHECK-THUMB2: ldr.w r0, .Ltmp[[TMP3:[0-9]+]]
-@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp3
+@ CHECK-ARM: ldr r0, .Ltmp[[TMP2:[0-9]+]]
+@ CHECK-DARWIN-ARM: ldr r0, Ltmp2
+@ CHECK-THUMB2: ldr.w r0, .Ltmp[[TMP2:[0-9]+]]
+@ CHECK-DARWIN-THUMB2: ldr.w r0, Ltmp2
 @ CHECK-THUMB: error: instruction requires: thumb2
 @ CHECK-THUMB-NEXT:  ldr.w r0, =foo
 
 @ CHECK-LABEL: f3:
 f3:
   ldr.w r1, =0x1
 @ CHECK-ARM: mov r1, #1
 @ CHECK-DARWIN-ARM: mov r1, #1
 @ CHECK-THUMB2: mov.w r1, #1
 @ CHECK-DARWIN-THUMB2: mov.w r1, #1
 @ CHECK-THUMB: error: instruction requires: thumb2
 @ CHECK-THUMB-NEXT:  ldr.w r1, =0x1
 
 @ CHECK: .Ltmp0:
 @ CHECK-NEXT: .long   65538
 @ CHECK: .Ltmp1:
-@ CHECK-NEXT: .long   65538
-@ CHECK: .Ltmp2:
 @ CHECK-NEXT: .long   foo
-@ CHECK: .Ltmp3:
+@ CHECK: .Ltmp2:
 @ CHECK-NEXT: .long   foo
 
 @ CHECK-DARWIN: Ltmp0:
 @ CHECK-DARWIN-NEXT: .long   65538
 @ CHECK-DARWIN: Ltmp1:
-@ CHECK-DARWIN-NEXT: .long   65538
-@ CHECK-DARWIN: Ltmp2:
 @ CHECK-DARWIN-NEXT: .long   foo
-@ CHECK-DARWIN: Ltmp3:
+@ CHECK-DARWIN: Ltmp2:
 @ CHECK-DARWIN-NEXT: .long   foo

llvm/trunk/test/MC/ARM/ldr-pseudo.s

@ CHECK: ldr r0, .Ltmp[[TMP3:[0-9]+]]
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   ldr r0, =0x10005
-@ CHECK: ldr r0, .Ltmp[[TMP4:[0-9]+]]
+@ CHECK: ldr r0, .Ltmp[[TMP3:[0-9]+]]
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
   adds r0, r0, #1
 
 @ a section defined in multiple pieces should be merged and use a single constant pool

 @ CHECK: .long 65539
 @ CHECK: .Ltmp[[TMP2]]
 @ CHECK: .long 65540
 
 @ CHECK: .section d,"ax",%progbits
 @ CHECK: .p2align 2
 @ CHECK: .Ltmp[[TMP3]]
 @ CHECK: .long 65541
-@ CHECK: .Ltmp[[TMP4]]
-@ CHECK: .long 65541
 
 @ CHECK: .section e,"ax",%progbits
 @ CHECK: .p2align 2
 @ CHECK: .Ltmp[[TMP5]]
 @ CHECK: .long 65542
 @ CHECK: .Ltmp[[TMP6]]
 @ CHECK: .long 65543