[PowerPC] Improve materialization for immediates which is almost a 32 bit splat.

[Esme]

Summary

Some 64 bit constants can be materialized with fewer instructions than we currently use.
We consider a 64 bit immediate value divided into four parts, Hi16OfHi32 (bits 48...63), Lo16OfHi32 (bits 32...47), Hi16OfLo32 (bits 16...31), Lo16OfLo32 (bits 0...15). When any three parts are equal, the immediate can be treated as "almost" a splat of a 32 bit value in a 64 bit register.
For example:

define  i64 @almost_splat() {
entry:
  ; 0xCCFFCCFF0123CCFF (Hi16OfHi32 == Lo16OfHi32 ==Lo16OfLo32)
  ret i64 14771750698406366463
}

Currently we use 5 instruction to materialize the immediate:

# %bb.0:                                # %entry
	lis 3, -13057
	ori 3, 3, 52479
	rldic 3, 3, 32, 0
	oris 3, 3, 291
	ori 3, 3, 52479
	blr

To improve that we can use 3 instructions to generate the splat and use 1 instruction to modify the different part:

# %bb.0:                                # %entry
	lis 3, 291
	ori 3, 3, 52479
	rldimi 3, 3, 32, 0       // 0x0123CCFF0123CCFF is generated here
	rldimi 3, 3, 48, 0       // modify Hi16OfHi32, then we get 0xCCFFCCFF0123CCFF
	blr

[shchenz]

llvm/test/CodeGen/PowerPC/constants-i64.ll

378

please commit the new cases first

[Esme]

Address comments.

[Esme]

ping

[shchenz]

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

1334

For compile time concern, since the 1 instruction patterns for Imm & 0xffffffff00000000 are simple, can we move the new code before line 1318 and do some simple check for 1 instruction pattern in selectI64ImmDirect?

1341

nit: there is a getI32Imm lambda at line 1314.

1357

I don't get the point here.
original input: 0xAAAABBBBAAAACCCC
splat result: 0XAAAABBBBAAAABBBB
after the ORI8: 0XAAAABBBBAAAABBBB | 0xCCCC != 0xAAAABBBBAAAACCCC ?

Seems another rldimi is needed to insert Lo16OfLo32 to the splat result.

[Esme]

Addressed comments and verified the materialization results.
However, I can't find a proper instruction to turn 0xABCD ADDD ABCD ADDD into 0xABCD ABCD ABCD ADDD, ie. modify Lo16OfHi32 (bits 32...47), so I didn't handle the pattern like 0xABCD ABCD ABCD ADDD.

[Esme]

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

1334

Sorry I didn't quite understand this comment.
Imm & 0xffffffff00000000 always takes more than 1 instruction because it is impossible to match the 1-instruction-pattern:

// 1-1) Patterns : {zeros}{15-bit valve}
//                 {ones}{15-bit valve}

// 1-2) Patterns : {zeros}{15-bit valve}{16 zeros}
//                 {ones}{15-bit valve}{16 zeros}

[shchenz]

In D139813#4034807, @Esme wrote:

Addressed comments and verified the materialization results.
However, I can't find a proper instruction to turn 0xABCD ADDD ABCD ADDD into 0xABCD ABCD ABCD ADDD, ie. modify Lo16OfHi32 (bits 32...47), so I didn't handle the pattern like 0xABCD ABCD ABCD ADDD.

Thanks, the new selection seems correct. For pattern 0xABCD ABCD ABCD ADDD, yeah, I can not find a 4 instruction selection for it either.

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

1334

I mean the new codes can be moved before line 1317 with some simple checks. For example if select Imm & 0xffffffff00000000 requires no less than 2 instructions and the lower 32 bit also requires 2 instructions, the new splat handling can be done first. Generating a 5 instruction pattern and then marking them as dead can be avoided even the new codes are hit.

[Esme]

Addressed comments.

[shchenz]

LGTM. Thanks for the improvement. Please wait for some days for other reviewers.

llvm/lib/Target/PowerPC/PPCISelDAGToDAG.cpp

Result = CurDAG->getMachineNode(PPC::ORIS8, dl, MVT::i64,
                                     SDValue(Result, 0), getI32Imm(Hi16));
     ++InstCntDirect;
   }
   if (uint32_t Lo16 = Lo_32(Imm) & 0xffff) {
     Result = CurDAG->getMachineNode(PPC::ORI8, dl, MVT::i64, SDValue(Result, 0),
                                     getI32Imm(Lo16));
     ++InstCntDirect;
   }
+
+  // Try to use 4 instructions to materialize the immediate which is "almost" a
+  // splat of a 32 bit immediate.
+  if (InstCntDirect > 4) {
+    uint32_t Hi16OfHi32 = (Hi_32(Imm) >> 16) & 0xffff;
+    uint32_t Lo16OfHi32 = Hi_32(Imm) & 0xffff;
+    uint32_t Hi16OfLo32 = (Lo_32(Imm) >> 16) & 0xffff;
+    uint32_t Lo16OfLo32 = Lo_32(Imm) & 0xffff;
+
+    auto getSplat = [CurDAG, dl](uint32_t Hi16, uint32_t Lo16) {
+      auto getI32Imm = [CurDAG, dl](unsigned Imm) {
+        return CurDAG->getTargetConstant(Imm, dl, MVT::i32);
+      };
+      SDNode *Result =
+          CurDAG->getMachineNode(PPC::LIS8, dl, MVT::i64, getI32Imm(Hi16));
+      Result = CurDAG->getMachineNode(PPC::ORI8, dl, MVT::i64,
+                                      SDValue(Result, 0), getI32Imm(Lo16));
+      SDValue Ops[] = {SDValue(Result, 0), SDValue(Result, 0), getI32Imm(32),
+                       getI32Imm(0)};
+      return CurDAG->getMachineNode(PPC::RLDIMI, dl, MVT::i64, Ops);
+    };
+
+    if (Hi16OfHi32 == Hi16OfLo32) {
+      InstCntDirect = 4;
+      Result = getSplat(Hi16OfHi32, Lo16OfHi32);
+      Result = CurDAG->getMachineNode(
+          PPC::ORI8, dl, MVT::i64, SDValue(Result, 0),
+          CurDAG->getTargetConstant(Lo16OfLo32, dl, MVT::i32));
+    } else if (Lo16OfHi32 == Lo16OfLo32) {
+      InstCntDirect = 4;
+      Result = getSplat(Hi16OfHi32, Lo16OfHi32);
+      Result = CurDAG->getMachineNode(
+          PPC::ORIS8, dl, MVT::i64, SDValue(Result, 0),
+          CurDAG->getTargetConstant(Hi16OfLo32, dl, MVT::i32));
+    }
+  }
+
   if (InstCnt)
     *InstCnt = InstCntDirect;
   return Result;
 }
 
 // Select a 64-bit constant.
 static SDNode *selectI64Imm(SelectionDAG *CurDAG, SDNode *N) {
   SDLoc dl(N);

llvm/test/CodeGen/PowerPC/constants-i64.ll

 ; CHECK-NEXT:    rldic 3, 3, 33, 30
 ; CHECK-NEXT:    oris 3, 3, 39436
 ; CHECK-NEXT:    ori 3, 3, 61633
 ; CHECK-NEXT:    blr
 entry:
   ret i64 11174473921
 }
 
 define i64 @imm19() {
 ; CHECK-LABEL: imm19:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:  lis 3, -13105
 ; CHECK-NEXT:  ori 3, 3, 52479
-; CHECK-NEXT:  rldic 3, 3, 32, 0
-; CHECK-NEXT:  oris 3, 3, 52431
+; CHECK-NEXT:  rldimi 3, 3, 32, 0
 ; CHECK-NEXT:  ori 3, 3, 291
 ; CHECK-NEXT:  blr
 entry:
   ret i64 14758239902941249827 ;0xCCCFCCFFCCCF0123
 }
 
 define i64 @imm20() {
 ; CHECK-LABEL: imm20:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:  lis 3, -13057
 ; CHECK-NEXT:  ori 3, 3, 52479
-; CHECK-NEXT:  rldic 3, 3, 32, 0
+; CHECK-NEXT:  rldimi 3, 3, 32, 0
 ; CHECK-NEXT:  oris 3, 3, 291
-; CHECK-NEXT:  ori 3, 3, 52479
 ; CHECK-NEXT:  blr
 entry:
   ret i64 14771750698406366463 ;0xCCFFCCFF0123CCFF
 }
 
 attributes #0 = { nounwind readnone }