[llvm] [PowerPC] Enable custom lowering for bswap64 builtin on Power8 64 bits with improved parallelism (PR #187259)
via llvm-commits
llvm-commits at lists.llvm.org
Thu May 14 21:24:00 PDT 2026
https://github.com/Himadhith updated https://github.com/llvm/llvm-project/pull/187259
>From ca96915c2120054fce5b2db2251903c669735532 Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Wed, 18 Mar 2026 08:32:00 -0400
Subject: [PATCH 1/6] [PowerPC] Enable custom lowering for bswap64 builtin on
Power8 64 bits with improved parallelism
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 61 ++++++++++++++++++++-
llvm/test/CodeGen/PowerPC/bswap64.ll | 26 ++++-----
2 files changed, 69 insertions(+), 18 deletions(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index 61f1663966dee..b180292f1d017 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -489,8 +489,11 @@ PPCTargetLowering::PPCTargetLowering(const PPCTargetMachine &TM,
setOperationAction(ISD::BSWAP, MVT::i64, Legal);
} else {
setOperationAction(ISD::BSWAP, MVT::i32, Expand);
- setOperationAction(ISD::BSWAP, MVT::i64,
- (Subtarget.hasP9Vector() && isPPC64) ? Custom : Expand);
+ setOperationAction(
+ ISD::BSWAP, MVT::i64,
+ ((Subtarget.hasP9Vector() || Subtarget.hasP8Vector()) && isPPC64)
+ ? Custom
+ : Expand);
}
// CTPOP or CTTZ were introduced in P8/P9 respectively
@@ -11616,6 +11619,60 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
SDLoc dl(Op);
if (!Subtarget.isPPC64())
return Op;
+
+ // Apply the optimization to Power8 and 64-bits which allows parallelism for
+ // rotate instructions which should make the bswap64 builtin faster.
+ if (Subtarget.hasP8Vector() && !Subtarget.hasP9Vector()) {
+ SDValue Input = Op.getOperand(0);
+
+ // Extract high and low 32 bits
+ SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
+ DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
+ DAG.getConstant(32, dl, MVT::i64)));
+ SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
+
+ // Swap high 32 bits using: rotl + 2x rlwimi
+ SDValue HiRot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Hi32,
+ DAG.getConstant(8, dl, MVT::i32));
+ SDValue HiSwap =
+ SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
+ {HiRot, Hi32,
+ DAG.getTargetConstant(24, dl, MVT::i32),
+ DAG.getTargetConstant(0, dl, MVT::i32),
+ DAG.getTargetConstant(7, dl, MVT::i32)}),
+ 0);
+ HiSwap = SDValue(DAG.getMachineNode(
+ PPC::RLWIMI, dl, MVT::i32,
+ {HiSwap, Hi32, DAG.getTargetConstant(24, dl, MVT::i32),
+ DAG.getTargetConstant(16, dl, MVT::i32),
+ DAG.getTargetConstant(23, dl, MVT::i32)}),
+ 0);
+
+ SDValue LoRot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Lo32,
+ DAG.getConstant(8, dl, MVT::i32));
+ SDValue LoSwap =
+ SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
+ {LoRot, Lo32,
+ DAG.getTargetConstant(24, dl, MVT::i32),
+ DAG.getTargetConstant(0, dl, MVT::i32),
+ DAG.getTargetConstant(7, dl, MVT::i32)}),
+ 0);
+ LoSwap = SDValue(DAG.getMachineNode(
+ PPC::RLWIMI, dl, MVT::i32,
+ {LoSwap, Lo32, DAG.getTargetConstant(24, dl, MVT::i32),
+ DAG.getTargetConstant(16, dl, MVT::i32),
+ DAG.getTargetConstant(23, dl, MVT::i32)}),
+ 0);
+
+ // Combine: (LoSwap << 32) | HiSwap using rldimi
+ HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, HiSwap);
+ LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, LoSwap);
+ return SDValue(DAG.getMachineNode(PPC::RLDIMI, dl, MVT::i64,
+ {HiSwap, LoSwap,
+ DAG.getTargetConstant(32, dl, MVT::i32),
+ DAG.getTargetConstant(0, dl, MVT::i32)}),
+ 0);
+ }
// MTVSRDD
Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
Op.getOperand(0));
diff --git a/llvm/test/CodeGen/PowerPC/bswap64.ll b/llvm/test/CodeGen/PowerPC/bswap64.ll
index 5a8eca0fba9d4..b16c9b434b0fd 100644
--- a/llvm/test/CodeGen/PowerPC/bswap64.ll
+++ b/llvm/test/CodeGen/PowerPC/bswap64.ll
@@ -14,25 +14,19 @@
declare i64 @llvm.bswap.i64(i64)
-; For now both the set of instructions for P8 are unoptimized versions.
-; A future patch will leverage parallelism and improve the
-; efficiency and performance.
+; This patch verifies that the compiler generates optimized assembly for Power 8 64-bit
+; byte swap operations that enables instruction-level parallelism.
define i64 @bswap64(i64 %x) {
; POWER-8-LABEL: bswap64:
; POWER-8: # %bb.0: # %entry
-; POWER-8-NEXT: rotldi 5, 3, 16
-; POWER-8-NEXT: rotldi 4, 3, 8
-; POWER-8-NEXT: rldimi 4, 5, 8, 48
-; POWER-8-NEXT: rotldi 5, 3, 24
-; POWER-8-NEXT: rldimi 4, 5, 16, 40
-; POWER-8-NEXT: rotldi 5, 3, 32
-; POWER-8-NEXT: rldimi 4, 5, 24, 32
-; POWER-8-NEXT: rotldi 5, 3, 48
-; POWER-8-NEXT: rldimi 4, 5, 40, 16
-; POWER-8-NEXT: rotldi 5, 3, 56
-; POWER-8-NEXT: rldimi 4, 5, 48, 8
-; POWER-8-NEXT: rldimi 4, 3, 56, 0
-; POWER-8-NEXT: mr 3, 4
+; POWER-8-NEXT: rotlwi 4, 3, 8
+; POWER-8-NEXT: rldicl 5, 3, 32, 32
+; POWER-8-NEXT: rlwimi 4, 3, 24, 0, 7
+; POWER-8-NEXT: rlwimi 4, 3, 24, 16, 23
+; POWER-8-NEXT: rotlwi 3, 5, 8
+; POWER-8-NEXT: rlwimi 3, 5, 24, 0, 7
+; POWER-8-NEXT: rlwimi 3, 5, 24, 16, 23
+; POWER-8-NEXT: rldimi 3, 4, 32, 0
; POWER-8-NEXT: blr
;
; POWER-8-NO-ALTIVEC-LABEL: bswap64:
>From 811c65d414173bcc3566956174feabbdfbc25ca2 Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Tue, 31 Mar 2026 09:12:20 -0400
Subject: [PATCH 2/6] Refactoring using lambda and adding affected test
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 52 ++++++++-------------
llvm/test/CodeGen/PowerPC/pr35402.ll | 18 +++----
2 files changed, 28 insertions(+), 42 deletions(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index b180292f1d017..06eefa92c1001 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -11625,46 +11625,32 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
if (Subtarget.hasP8Vector() && !Subtarget.hasP9Vector()) {
SDValue Input = Op.getOperand(0);
- // Extract high and low 32 bits
- SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
- DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
- DAG.getConstant(32, dl, MVT::i64)));
- SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
-
- // Swap high 32 bits using: rotl + 2x rlwimi
- SDValue HiRot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Hi32,
+ auto Swap32 = [&](SDValue Val32) -> SDValue {
+ SDValue Rot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Val32,
DAG.getConstant(8, dl, MVT::i32));
- SDValue HiSwap =
- SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
- {HiRot, Hi32,
- DAG.getTargetConstant(24, dl, MVT::i32),
- DAG.getTargetConstant(0, dl, MVT::i32),
- DAG.getTargetConstant(7, dl, MVT::i32)}),
- 0);
- HiSwap = SDValue(DAG.getMachineNode(
+ SDValue Swap =
+ SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
+ {Rot, Val32,
+ DAG.getTargetConstant(24, dl, MVT::i32),
+ DAG.getTargetConstant(0, dl, MVT::i32),
+ DAG.getTargetConstant(7, dl, MVT::i32)}),
+ 0);
+ return SDValue(DAG.getMachineNode(
PPC::RLWIMI, dl, MVT::i32,
- {HiSwap, Hi32, DAG.getTargetConstant(24, dl, MVT::i32),
+ {Swap, Val32, DAG.getTargetConstant(24, dl, MVT::i32),
DAG.getTargetConstant(16, dl, MVT::i32),
DAG.getTargetConstant(23, dl, MVT::i32)}),
0);
+ };
- SDValue LoRot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Lo32,
- DAG.getConstant(8, dl, MVT::i32));
- SDValue LoSwap =
- SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
- {LoRot, Lo32,
- DAG.getTargetConstant(24, dl, MVT::i32),
- DAG.getTargetConstant(0, dl, MVT::i32),
- DAG.getTargetConstant(7, dl, MVT::i32)}),
- 0);
- LoSwap = SDValue(DAG.getMachineNode(
- PPC::RLWIMI, dl, MVT::i32,
- {LoSwap, Lo32, DAG.getTargetConstant(24, dl, MVT::i32),
- DAG.getTargetConstant(16, dl, MVT::i32),
- DAG.getTargetConstant(23, dl, MVT::i32)}),
- 0);
+ SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
+ DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
+ DAG.getConstant(32, dl, MVT::i64)));
+ SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
+
+ SDValue HiSwap = Swap32(Hi32);
+ SDValue LoSwap = Swap32(Lo32);
- // Combine: (LoSwap << 32) | HiSwap using rldimi
HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, HiSwap);
LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, LoSwap);
return SDValue(DAG.getMachineNode(PPC::RLDIMI, dl, MVT::i64,
diff --git a/llvm/test/CodeGen/PowerPC/pr35402.ll b/llvm/test/CodeGen/PowerPC/pr35402.ll
index bcbae3bbbb973..015b7fbcb96fc 100644
--- a/llvm/test/CodeGen/PowerPC/pr35402.ll
+++ b/llvm/test/CodeGen/PowerPC/pr35402.ll
@@ -5,17 +5,17 @@ target triple = "powerpc64le-linux-gnu"
define void @test(ptr %p, i64 %data) {
; CHECK-LABEL: test:
; CHECK: # %bb.0: # %entry
-; CHECK-NEXT: rotldi 5, 4, 16
-; CHECK-NEXT: rldicl 6, 4, 8, 56
-; CHECK-NEXT: rldimi 6, 5, 8, 48
-; CHECK-NEXT: rotldi 5, 4, 24
-; CHECK-NEXT: rldimi 6, 5, 16, 40
-; CHECK-NEXT: rotldi 5, 4, 32
-; CHECK-NEXT: rldimi 6, 5, 24, 32
-; CHECK-NEXT: rlwinm 5, 4, 8, 24, 31
+; CHECK-NEXT: rotlwi 5, 4, 8
+; CHECK-NEXT: rlwimi 5, 4, 24, 0, 7
; CHECK-NEXT: rlwimi 5, 4, 24, 16, 23
+; CHECK-NEXT: rldicl 4, 4, 32, 32
+; CHECK-NEXT: rotlwi 6, 4, 8
+; CHECK-NEXT: rlwimi 6, 4, 24, 0, 7
+; CHECK-NEXT: rlwimi 6, 4, 24, 16, 23
+; CHECK-NEXT: rldimi 6, 5, 32, 0
+; CHECK-NEXT: rldicl 4, 6, 32, 32
; CHECK-NEXT: stw 6, 0(3)
-; CHECK-NEXT: sth 5, 4(3)
+; CHECK-NEXT: sth 4, 4(3)
; CHECK-NEXT: blr
entry:
%0 = tail call i64 @llvm.bswap.i64(i64 %data)
>From 83e6a31ef0c28e8b1b39524a7b488de97b851364 Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Tue, 31 Mar 2026 11:53:35 -0400
Subject: [PATCH 3/6] Minor change
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 10 ++++------
1 file changed, 4 insertions(+), 6 deletions(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index 06eefa92c1001..66c927aadb1ec 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -489,11 +489,9 @@ PPCTargetLowering::PPCTargetLowering(const PPCTargetMachine &TM,
setOperationAction(ISD::BSWAP, MVT::i64, Legal);
} else {
setOperationAction(ISD::BSWAP, MVT::i32, Expand);
- setOperationAction(
- ISD::BSWAP, MVT::i64,
- ((Subtarget.hasP9Vector() || Subtarget.hasP8Vector()) && isPPC64)
- ? Custom
- : Expand);
+ setOperationAction(ISD::BSWAP, MVT::i64,
+ ((Subtarget.hasP8Vector()) && isPPC64) ? Custom
+ : Expand);
}
// CTPOP or CTTZ were introduced in P8/P9 respectively
@@ -11622,7 +11620,7 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
// Apply the optimization to Power8 and 64-bits which allows parallelism for
// rotate instructions which should make the bswap64 builtin faster.
- if (Subtarget.hasP8Vector() && !Subtarget.hasP9Vector()) {
+ if (!Subtarget.hasP9Vector()) {
SDValue Input = Op.getOperand(0);
auto Swap32 = [&](SDValue Val32) -> SDValue {
>From a3d30d86d845f7915b402b07a57e29c926cd1624 Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Tue, 12 May 2026 14:07:29 +0000
Subject: [PATCH 4/6] Refactoring changes
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 53 +++++++++++----------
1 file changed, 28 insertions(+), 25 deletions(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index 66c927aadb1ec..960c0e3eacdfa 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -11618,44 +11618,47 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
if (!Subtarget.isPPC64())
return Op;
- // Apply the optimization to Power8 and 64-bits which allows parallelism for
- // rotate instructions which should make the bswap64 builtin faster.
+ // Apply the optimization to Power8 and 64-bits which allows parallelism
+ // for rotate instructions which should make the bswap64 builtin faster.
if (!Subtarget.hasP9Vector()) {
SDValue Input = Op.getOperand(0);
+ // Helper lambda for rotate-and-insert operations (RLWIMI/RLDIMI)
+ auto CreateRotateInsert =
+ [&](unsigned Opcode, MVT VT, SDValue Dest, SDValue Src, unsigned RotAmt,
+ unsigned MaskBegin,
+ std::optional<unsigned> MaskEnd = std::nullopt) -> SDValue {
+ SmallVector<SDValue, 5> Ops = {
+ Dest, Src, DAG.getTargetConstant(RotAmt, dl, MVT::i32),
+ DAG.getTargetConstant(MaskBegin, dl, MVT::i32)};
+ if (MaskEnd.has_value())
+ Ops.push_back(DAG.getTargetConstant(*MaskEnd, dl, MVT::i32));
+
+ return SDValue(DAG.getMachineNode(Opcode, dl, VT, Ops), 0);
+ };
+ // Helper lambda to perform 32-bit byte swap: rotl(8) + 2x rlwimi
auto Swap32 = [&](SDValue Val32) -> SDValue {
SDValue Rot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Val32,
DAG.getConstant(8, dl, MVT::i32));
- SDValue Swap =
- SDValue(DAG.getMachineNode(PPC::RLWIMI, dl, MVT::i32,
- {Rot, Val32,
- DAG.getTargetConstant(24, dl, MVT::i32),
- DAG.getTargetConstant(0, dl, MVT::i32),
- DAG.getTargetConstant(7, dl, MVT::i32)}),
- 0);
- return SDValue(DAG.getMachineNode(
- PPC::RLWIMI, dl, MVT::i32,
- {Swap, Val32, DAG.getTargetConstant(24, dl, MVT::i32),
- DAG.getTargetConstant(16, dl, MVT::i32),
- DAG.getTargetConstant(23, dl, MVT::i32)}),
- 0);
+ // Insert bits [24:31] from Val32 into Rot at position [0:7]
+ SDValue Swap = CreateRotateInsert(PPC::RLWIMI, MVT::i32, Rot, Val32, 24, 0, 7);
+ // Insert bits [16:23] from Val32 into Swap at position [16:23]
+ return CreateRotateInsert(PPC::RLWIMI, MVT::i32, Swap, Val32, 24, 16, 23);
};
-
+ // Extract and swap high and low 32 bits independently (enables parallelism)
SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
DAG.getConstant(32, dl, MVT::i64)));
SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
- SDValue HiSwap = Swap32(Hi32);
- SDValue LoSwap = Swap32(Lo32);
+ // Combine swapped halves using rldimi: rotate LoSwap left by 32 to place it
+ // in the upper 32 bits, inserting into HiSwap which occupies the lower 32
+ // bits. This swaps the two halves' positions, completing the 64-bit
+ // reversal.
+ SDValue HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Hi32));
+ SDValue LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Lo32));
- HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, HiSwap);
- LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, LoSwap);
- return SDValue(DAG.getMachineNode(PPC::RLDIMI, dl, MVT::i64,
- {HiSwap, LoSwap,
- DAG.getTargetConstant(32, dl, MVT::i32),
- DAG.getTargetConstant(0, dl, MVT::i32)}),
- 0);
+ return CreateRotateInsert(PPC::RLDIMI, MVT::i64, HiSwap, LoSwap, 32, 0);
}
// MTVSRDD
Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
>From 3b6ff36dc7fa32cc974d373cb5e834905ca8468a Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Tue, 12 May 2026 14:11:20 +0000
Subject: [PATCH 5/6] format fix
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index 960c0e3eacdfa..a4c142abb9afe 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -11641,7 +11641,8 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
SDValue Rot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Val32,
DAG.getConstant(8, dl, MVT::i32));
// Insert bits [24:31] from Val32 into Rot at position [0:7]
- SDValue Swap = CreateRotateInsert(PPC::RLWIMI, MVT::i32, Rot, Val32, 24, 0, 7);
+ SDValue Swap =
+ CreateRotateInsert(PPC::RLWIMI, MVT::i32, Rot, Val32, 24, 0, 7);
// Insert bits [16:23] from Val32 into Swap at position [16:23]
return CreateRotateInsert(PPC::RLWIMI, MVT::i32, Swap, Val32, 24, 16, 23);
};
>From 4654b28e301fa24bf4d632d86696f394883f64f7 Mon Sep 17 00:00:00 2001
From: himadhith <himadhith.v at ibm.com>
Date: Tue, 12 May 2026 18:17:21 +0000
Subject: [PATCH 6/6] review changes
---
llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 106 ++++++++++----------
1 file changed, 52 insertions(+), 54 deletions(-)
diff --git a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
index a4c142abb9afe..f956488c52e65 100644
--- a/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
+++ b/llvm/lib/Target/PowerPC/PPCISelLowering.cpp
@@ -11618,61 +11618,59 @@ SDValue PPCTargetLowering::LowerBSWAP(SDValue Op, SelectionDAG &DAG) const {
if (!Subtarget.isPPC64())
return Op;
- // Apply the optimization to Power8 and 64-bits which allows parallelism
- // for rotate instructions which should make the bswap64 builtin faster.
- if (!Subtarget.hasP9Vector()) {
- SDValue Input = Op.getOperand(0);
- // Helper lambda for rotate-and-insert operations (RLWIMI/RLDIMI)
- auto CreateRotateInsert =
- [&](unsigned Opcode, MVT VT, SDValue Dest, SDValue Src, unsigned RotAmt,
- unsigned MaskBegin,
- std::optional<unsigned> MaskEnd = std::nullopt) -> SDValue {
- SmallVector<SDValue, 5> Ops = {
- Dest, Src, DAG.getTargetConstant(RotAmt, dl, MVT::i32),
- DAG.getTargetConstant(MaskBegin, dl, MVT::i32)};
- if (MaskEnd.has_value())
- Ops.push_back(DAG.getTargetConstant(*MaskEnd, dl, MVT::i32));
-
- return SDValue(DAG.getMachineNode(Opcode, dl, VT, Ops), 0);
- };
+ if (Subtarget.hasP9Vector()) {
+ // MTVSRDD
+ Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
+ Op.getOperand(0));
+ // XXBRD
+ Op = DAG.getNode(ISD::BSWAP, dl, MVT::v2i64, Op);
+ // MFVSRD
+ int VectorIndex = 0;
+ if (Subtarget.isLittleEndian())
+ VectorIndex = 1;
+ Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Op,
+ DAG.getTargetConstant(VectorIndex, dl, MVT::i32));
+ return Op;
+ }
- // Helper lambda to perform 32-bit byte swap: rotl(8) + 2x rlwimi
- auto Swap32 = [&](SDValue Val32) -> SDValue {
- SDValue Rot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Val32,
- DAG.getConstant(8, dl, MVT::i32));
- // Insert bits [24:31] from Val32 into Rot at position [0:7]
- SDValue Swap =
- CreateRotateInsert(PPC::RLWIMI, MVT::i32, Rot, Val32, 24, 0, 7);
- // Insert bits [16:23] from Val32 into Swap at position [16:23]
- return CreateRotateInsert(PPC::RLWIMI, MVT::i32, Swap, Val32, 24, 16, 23);
- };
- // Extract and swap high and low 32 bits independently (enables parallelism)
- SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
- DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
- DAG.getConstant(32, dl, MVT::i64)));
- SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
-
- // Combine swapped halves using rldimi: rotate LoSwap left by 32 to place it
- // in the upper 32 bits, inserting into HiSwap which occupies the lower 32
- // bits. This swaps the two halves' positions, completing the 64-bit
- // reversal.
- SDValue HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Hi32));
- SDValue LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Lo32));
-
- return CreateRotateInsert(PPC::RLDIMI, MVT::i64, HiSwap, LoSwap, 32, 0);
- }
- // MTVSRDD
- Op = DAG.getNode(ISD::BUILD_VECTOR, dl, MVT::v2i64, Op.getOperand(0),
- Op.getOperand(0));
- // XXBRD
- Op = DAG.getNode(ISD::BSWAP, dl, MVT::v2i64, Op);
- // MFVSRD
- int VectorIndex = 0;
- if (Subtarget.isLittleEndian())
- VectorIndex = 1;
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i64, Op,
- DAG.getTargetConstant(VectorIndex, dl, MVT::i32));
- return Op;
+ // For Power8, use parallel rotate instructions for faster bswap64.
+ SDValue Input = Op.getOperand(0);
+ // Helper to create rotate-and-insert operations (RLWIMI/RLDIMI).
+ auto CreateRotateInsert =
+ [&](unsigned Opcode, MVT VT, SDValue Dest, SDValue Src, unsigned RotAmt,
+ unsigned MaskBegin,
+ std::optional<unsigned> MaskEnd = std::nullopt) -> SDValue {
+ SmallVector<SDValue, 5> Ops = {
+ Dest, Src, DAG.getTargetConstant(RotAmt, dl, MVT::i32),
+ DAG.getTargetConstant(MaskBegin, dl, MVT::i32)};
+ if (MaskEnd.has_value())
+ Ops.push_back(DAG.getTargetConstant(*MaskEnd, dl, MVT::i32));
+
+ return SDValue(DAG.getMachineNode(Opcode, dl, VT, Ops), 0);
+ };
+
+ // Helper to perform 32-bit byte swap using rotl(8) + 2x rlwimi.
+ auto Swap32 = [&](SDValue Val32) -> SDValue {
+ SDValue Rot = DAG.getNode(ISD::ROTL, dl, MVT::i32, Val32,
+ DAG.getConstant(8, dl, MVT::i32));
+ // Insert bits [24:31] from Val32 into Rot at position [0:7].
+ SDValue Swap =
+ CreateRotateInsert(PPC::RLWIMI, MVT::i32, Rot, Val32, 24, 0, 7);
+ // Insert bits [16:23] from Val32 into Swap at position [16:23].
+ return CreateRotateInsert(PPC::RLWIMI, MVT::i32, Swap, Val32, 24, 16, 23);
+ };
+ // Extract and swap high and low 32-bit halves independently for parallelism.
+ SDValue Hi32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32,
+ DAG.getNode(ISD::SRL, dl, MVT::i64, Input,
+ DAG.getConstant(32, dl, MVT::i64)));
+ SDValue Lo32 = DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Input);
+
+ // Combine swapped halves: rotate LoSwap left by 32 bits and insert into
+ // HiSwap to swap their positions, completing the 64-bit byte reversal.
+ SDValue HiSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Hi32));
+ SDValue LoSwap = DAG.getNode(ISD::ZERO_EXTEND, dl, MVT::i64, Swap32(Lo32));
+
+ return CreateRotateInsert(PPC::RLDIMI, MVT::i64, HiSwap, LoSwap, 32, 0);
}
// ATOMIC_CMP_SWAP for i8/i16 needs to zero-extend its input since it will be
More information about the llvm-commits
mailing list