From: Brian Cain <bcain@quicinc.com>
Date: Mon, 18 Jun 2018 17:25:40 +0000 (-0500)
Subject: [Hexagon] Save results from partial compound
X-Git-Tag: upstream/15.0.7~21367
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ddf1fb1f133a0f98d604551e3381b2328bed877f;p=platform%2Fupstream%2Fllvm.git

[Hexagon] Save results from partial compound

Previously compounding was all-or-nothing.  Now, the
compounding attempts will iterate and yield the most
compounds that still result in a valid packet.
---

diff --git a/lld/test/ELF/hexagon.s b/lld/test/ELF/hexagon.s
index 394e6f0..fee7ccd 100644
--- a/lld/test/ELF/hexagon.s
+++ b/lld/test/ELF/hexagon.s
@@ -4,153 +4,153 @@
 # RUN: ld.lld %t.o %t1.o -o %t
 # RUN: llvm-objdump -d %t | FileCheck %s
 
-# Note: 131648 == 0x20240
+# Note: 131584 == 0x20200
 # R_HEX_32_6_X
 # R_HEX_12_X
 if (p0) r0 = ##_start
-# CHECK: immext(#131648)
-# CHECK: if (p0) r0 = ##131648
+# CHECK: immext(#131584)
+# CHECK: if (p0) r0 = ##131644
 
 # R_HEX_B15_PCREL
 if (p0) jump:nt #_start
-# CHECK: if (p0) jump:nt 0x20240
+# CHECK: if (p0) jump:nt 0x2023c
 
 # R_HEX_B32_PCREL_X
 # R_HEX_B15_PCREL_X
 if (p0) jump:nt ##_start
-# CHECK: if (p0) jump:nt 0x20240
+# CHECK: if (p0) jump:nt 0x2023c
 
 # R_HEX_B22_PCREL
 call #_start
-# CHECK: call 0x20240
+# CHECK: call 0x2023c
 
 # R_HEX_B32_PCREL_X
 # R_HEX_B22_PCREL_X
 call ##_start
 # CHECK: immext(#320)
-# CHECK: call 0x20240
+# CHECK: call 0x2023c
 
 # R_HEX_6_X tests:
 # One test for each mask in the lookup table.
 
 #0x38000000
 if (!P0) memw(r0+#8)=##_start
-# CHECK: 38c0c100   	if (!p0) memw(r0+#8) = ##131648 }
+# CHECK: 38c0e11c   	if (!p0) memw(r0+#8) = ##131644 }
 
 #0x39000000
 { p0 = p1
   if (!P0.new) memw(r0+#0)=##_start }
-# CHECK: 39c0c000   	if (!p0.new) memw(r0+#0) = ##131648 }
+# CHECK: 39c0e01c   	if (!p0.new) memw(r0+#0) = ##131644 }
 
 #0x3e000000
 memw(r0+##_start)+=r1
-# CHECK: 3e40c001   	memw(r0+##131648) += r1 }
+# CHECK: 3e40de01   	memw(r0+##131644) += r1 }
 
 #0x3f000000
 memw(r0+##_start)+=#4
-# CHECK: 3f40c004   	memw(r0+##131648) += #4 }
+# CHECK: 3f40de04   	memw(r0+##131644) += #4 }
 
 #0x40000000
 { r0 = r1
   if (p0) memb(r0+##_start)=r0.new }
-# CHECK: 40a0c200   	if (p0) memb(r0+##131648) = r0.new }
+# CHECK: 40a0e2e0   	if (p0) memb(r0+##131644) = r0.new }
 
 #0x41000000
 if (p0) r0=memb(r1+##_start)
-# CHECK: 4101c000   	if (p0) r0 = memb(r1+##131648) }
+# CHECK: 4101c780   	if (p0) r0 = memb(r1+##131644) }
 
 #0x42000000
 { r0 = r1
   p0 = p1
   if (p0.new) memb(r0+##_start)=r0.new }
-# CHECK: 42a0c200   	if (p0.new) memb(r0+##131648) = r0.new }
+# CHECK: 42a0e2e0   	if (p0.new) memb(r0+##131644) = r0.new }
 
 #0x43000000
 { p0 = p1
  if (P0.new) r0=memb(r0+##_start) }
-# CHECK: 4300c000   	if (p0.new) r0 = memb(r0+##131648) }
+# CHECK: 4300c780   	if (p0.new) r0 = memb(r0+##131644) }
 
 #0x44000000
 if (!p0) memb(r0+##_start)=r1
-# CHECK: 4400c100   	if (!p0) memb(r0+##131648) = r1 }
+# CHECK: 4400e1e0   	if (!p0) memb(r0+##131644) = r1 }
 
 #0x45000000
 if (!p0) r0=memb(r1+##_start)
-# CHECK: 4501c000   	if (!p0) r0 = memb(r1+##131648) }
+# CHECK: 4501c780   	if (!p0) r0 = memb(r1+##131644) }
 
 #0x46000000
 { p0 = p1
   if (!p0.new) memb(r0+##_start)=r1 }
-# CHECK: 4600c100   	if (!p0.new) memb(r0+##131648) = r1 }
+# CHECK: 4600e1e0   	if (!p0.new) memb(r0+##131644) = r1 }
 
 #0x47000000
 { p0 = p1
   if (!p0.new) r0=memb(r1+##_start) }
-# CHECK: 4701c000   	if (!p0.new) r0 = memb(r1+##131648) }
+# CHECK: 4701c780   	if (!p0.new) r0 = memb(r1+##131644) }
 
 #0x6a000000 -- Note 4294967132 == -0xa4 the distance between
 #              here and _start, so this will change if
 #              tests are added between here and _start
 r0=add(pc,##_start@pcrel)
-# CHECK: 6a49d800  	r0 = add(pc,##240) }
+# CHECK: 6a49d600  	r0 = add(pc,##236) }
 
 #0x7c000000
 r1:0=combine(#8,##_start)
-# CHECK: 7c80c100   	r1:0 = combine(#8,##131648) }
+# CHECK: 7c9ec100   	r1:0 = combine(#8,##131644) }
 
 #0x9a000000
 r1:0=memb_fifo(r2=##_start)
-# CHECK: 9a82d000   	r1:0 = memb_fifo(r2=##131648) }
+# CHECK: 9a82df00   	r1:0 = memb_fifo(r2=##131644) }
 
 #0x9b000000
 r0=memb(r1=##_start)
-# CHECK: 9b01d000   	r0 = memb(r1=##131648) }
+# CHECK: 9b01df00   	r0 = memb(r1=##131644) }
 
 #0x9c000000
 r1:0=memb_fifo(r2<<#2+##_start)
-# CHECK: 9c82f000   	r1:0 = memb_fifo(r2<<#2+##131648) }
+# CHECK: 9c82ff00   	r1:0 = memb_fifo(r2<<#2+##131644) }
 
 #0x9d000000
 r0=memb(r1<<#2+##_start)
-# CHECK: 9d01f000   	r0 = memb(r1<<#2+##131648) }
+# CHECK: 9d01ff00   	r0 = memb(r1<<#2+##131644) }
 
 #0x9f000000
 if (!p0) r0=memb(##_start)
-# CHECK: 9f00e880   	if (!p0) r0 = memb(##131648) }
+# CHECK: 9f1ee880   	if (!p0) r0 = memb(##131644) }
 
 #0xab000000
 memb(r0=##_start)=r1
-# CHECK: ab00c180   	memb(r0=##131648) = r1 }
+# CHECK: ab00c1bc   	memb(r0=##131644) = r1 }
 
 #0xad000000
 memb(r0<<#2+##_start)=r1
-# CHECK: ad00e180   	memb(r0<<#2+##131648) = r1 }
+# CHECK: ad00e1bc   	memb(r0<<#2+##131644) = r1 }
 
 #0xaf000000
 if (!p0) memb(##_start)=r1
-# CHECK: af00c184   	if (!p0) memb(##131648) = r1 }
+# CHECK: af03c1e4   	if (!p0) memb(##131644) = r1 }
 
 #0xd7000000
 r0=add(##_start,mpyi(r1,r2))
-# CHECK: d701c200   	r0 = add(##131648,mpyi(r1,r2)) }
+# CHECK: d761e280   	r0 = add(##131644,mpyi(r1,r2)) }
 
 #0xd8000000
 R0=add(##_start,mpyi(r0,#2))
-# CHECK: d800c002   	r0 = add(##131648,mpyi(r0,#2)) }
+# CHECK: d860e082   	r0 = add(##131644,mpyi(r0,#2)) }
 
 #0xdb000000
 r0=add(r1,add(r2,##_start))
-# CHECK: db01c002   	r0 = add(r1,add(r2,##131648)) }
+# CHECK: db61e082   	r0 = add(r1,add(r2,##131644)) }
 
 #0xdf000000
 r0=add(r1,mpyi(r2,##_start))
-# CHECK: df82c001   	r0 = add(r1,mpyi(r2,##131648)) }
+# CHECK: dfe2e081   	r0 = add(r1,mpyi(r2,##131644)) }
 
 # Duplex form of R_HEX_6_X
 # R_HEX_32_6_X
 # R_HEX_6_X
 { r0 = ##_start; r2 = r16 }
-# CHECK: 28003082   	r0 = ##131648; 	r2 = r16 }
+# CHECK: 2bc03082   	r0 = ##131644; 	r2 = r16 }
 
 # R_HEX_HI16
 r0.h = #HI(_start)
@@ -158,66 +158,66 @@ r0.h = #HI(_start)
 
 # R_HEX_LO16
 r0.l = #LO(_start)
-# CHECK: r0.l = #576
+# CHECK: r0.l = #572
 
 # R_HEX_8_X has 3 relocation mask variations
 #0xde000000
 r0=sub(##_start, asl(r0, #1))
-# CHECK: de40c106      r0 = sub(##131648,asl(r0,#1)) }
+# CHECK: de20e1c6      r0 = sub(##131644,asl(r0,#1)) }
 
 #0x3c000000
 memw(r0+#0) = ##_start
-# CHECK: 3c40c040   	memw(r0+#0) = ##131648 }
+# CHECK: 3c40c03c   	memw(r0+#0) = ##131644 }
 
 # The rest:
 r1:0=combine(r2,##_start);
-# CHECK: 7302e800   	r1:0 = combine(r2,##131648) }
+# CHECK: 7302e780   	r1:0 = combine(r2,##131644) }
 
 # R_HEX_32:
 r_hex_32:
 .word _start
-# CHECK: 00020240
+# CHECK: 0002023c
 
 # R_HEX_16_X has 4 relocation mask variations
 # 0x48000000
 memw(##_start) = r0
-# CHECK: 4880c000   memw(##131648) = r0 }
+# CHECK: 4880c03c   memw(##131644) = r0 }
 
 # 0x49000000
 r0 = memw(##_start)
-# CHECK: 4980c000   r0 = memw(##131648)
+# CHECK: 4980c780   r0 = memw(##131644)
 
 # 0x78000000
 r0 = ##_start
-# CHECK: 7800c000   r0 = ##131648 }
+# CHECK: 7800c780   r0 = ##131644 }
 
 # 0xb0000000
 r0 = add(r1, ##_start)
-# CHECK: b001c000   r0 = add(r1,##131648) }
+# CHECK: b001c780   r0 = add(r1,##131644) }
 
 # R_HEX_B9_PCREL:
 {r0=#1 ; jump #_start}
-# CHECK: jump 0x20240
+# CHECK: jump 0x2023c
 
 # R_HEX_B9_PCREL_X:
 {r0=#1 ; jump ##_start}
-# CHECK: jump 0x20240
+# CHECK: jump 0x2023c
 
 # R_HEX_B13_PCREL
 if (r0 == #0) jump:t #_start
-# CHECK: if (r0==#0) jump:t 0x20240
+# CHECK: if (r0==#0) jump:t 0x2023c
 
 # R_HEX_9_X
 p0 = !cmp.gtu(r0, ##_start)
-# CHECK: p0 = !cmp.gtu(r0,##131648)
+# CHECK: p0 = !cmp.gtu(r0,##131644)
 
 # R_HEX_10_X
 p0 = !cmp.gt(r0, ##_start)
-# CHECK: p0 = !cmp.gt(r0,##131648)
+# CHECK: p0 = !cmp.gt(r0,##131644)
 
 # R_HEX_11_X
 r0 = memw(r1+##_start)
-# CHECK: r0 = memw(r1+##131648)
+# CHECK: r0 = memw(r1+##131644)
 
 memw(r0+##_start) = r1
-# CHECK: memw(r0+##131648) = r1
+# CHECK: memw(r0+##131644) = r1
diff --git a/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp b/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp
index e7ade783..4bb078f 100644
--- a/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp
+++ b/llvm/lib/Target/Hexagon/MCTargetDesc/HexagonMCCompound.cpp
@@ -405,24 +405,27 @@ void HexagonMCInstrInfo::tryCompound(MCInstrInfo const &MCII, MCSubtargetInfo co
   if (MCI.size() < 2)
     return;
 
-  bool StartedValid = llvm::HexagonMCShuffle(Context, false, MCII, STI, MCI);
-
   // Create a vector, needed to keep the order of jump instructions.
   MCInst CheckList(MCI);
 
+  // Keep the last known good bundle around in case the shuffle fails.
+  MCInst LastValidBundle(MCI);
+
+  bool PreviouslyValid = llvm::HexagonMCShuffle(Context, false, MCII, STI, MCI);
+
   // Look for compounds until none are found, only update the bundle when
   // a compound is found.
   while (lookForCompound(MCII, Context, CheckList)) {
-    // Keep the original bundle around in case the shuffle fails.
-    MCInst OriginalBundle(MCI);
-
     // Need to update the bundle.
     MCI = CheckList;
 
-    if (StartedValid &&
-        !llvm::HexagonMCShuffle(Context, false, MCII, STI, MCI)) {
+    const bool IsValid = llvm::HexagonMCShuffle(Context, false, MCII, STI, MCI);
+    if (PreviouslyValid && !IsValid) {
       LLVM_DEBUG(dbgs() << "Found ERROR\n");
-      MCI = OriginalBundle;
+      MCI = LastValidBundle;
+    } else if (IsValid) {
+      LastValidBundle = MCI;
+      PreviouslyValid = true;
     }
   }
 }
diff --git a/llvm/test/MC/Hexagon/bug_28748.s b/llvm/test/MC/Hexagon/bug_28748.s
new file mode 100644
index 0000000..05522f0
--- /dev/null
+++ b/llvm/test/MC/Hexagon/bug_28748.s
@@ -0,0 +1,19 @@
+# RUN: llvm-mc -arch=hexagon -mcpu=hexagonv65 -filetype=obj %s | llvm-objdump --mcpu=hexagonv65 -d - | FileCheck --implicit-check-not='{' %s
+
+# This case requires compounding only some of the instructions which are
+# possible compounds.  Compounding all possible opcodes is ideal for code size
+# but does not always result in a packet with a valid shuffle, whereas the
+# non-compounded instructions may be a valid shuffle.
+
+foo:
+{ r0=c0
+  p0=cmp.eq(r0,#0); if (p0.new) jump:nt foo
+  jump foo
+  r1=r0 }
+
+# CHECK-LABEL:  <foo>:
+# CHECK-NEXT:  { r0 = sa0
+# CHECK-NEXT:    p0 = cmp.eq(r0,#0); if (p0.new) jump:nt 0x0
+# CHECK-NEXT:    jump 0x0
+# CHECK-NEXT:    r1 = r0 }
+