[Sparc] Use ANDN instead of AND if constant can be encoded more efficiently

[dcederman]

Summary

In the case of (and reg, constant) or (or reg, constant), it can be beneficial to use a ANDNrr/ORNrr instruction instead of ANDrr/ORrr, if the complement of the constant can be encoded using a single SETHI instruction instead of a SETHI/ORri pair.

If the constant has more than one use, it is probably better to keep it in its original form.

[jyknight]

Seems unclear to me that the "more than one use" bit is the right assumption. But sure, let's go with that for now.

lib/Target/Sparc/SparcInstrInfo.td

103

Please add the rationale for "N->hasOneUse()" in a comment here, not just in commit message.

[dcederman]

When I was testing the code I saw that it sometimes generated two versions of the same constant, one with the single SETHI with the complement form, and one with the standard SETHI/ORri pair. So I added the hasOneUse() part to prevent the case when a constant is encoded using three instructions instead of just one or two.

lib/Target/Sparc/SparcInstrInfo.td

 }]>;
 
 def HI22 : SDNodeXForm<imm, [{
   // Transformation function: shift the immediate value down into the low bits.
   return CurDAG->getTargetConstant((unsigned)N->getZExtValue() >> 10, SDLoc(N),
                                    MVT::i32);
 }]>;
 
+// Return the complement of a HI22 immediate value.
+def HI22_not : SDNodeXForm<imm, [{
+  return CurDAG->getTargetConstant(~(unsigned)N->getZExtValue() >> 10, SDLoc(N),
+                                   MVT::i32);
+}]>;
+
 def SETHIimm : PatLeaf<(imm), [{
   return isShiftedUInt<22, 10>(N->getZExtValue());
 }], HI22>;
 
+def SETHIimm_not : PatLeaf<(i32 imm), [{
+  return N->hasOneUse() && isShiftedUInt<22, 10>(~(unsigned)N->getZExtValue());
+}], HI22_not>;
+
 // Addressing modes.
 def ADDRrr : ComplexPattern<iPTR, 2, "SelectADDRrr", [], []>;
 def ADDRri : ComplexPattern<iPTR, 2, "SelectADDRri", [frameindex], []>;
 
 // Address operands
 def SparcMEMrrAsmOperand : AsmOperandClass {
   let Name = "MEMrr";
   let ParserMethod = "parseMEMOperand";

 def XNORrr  : F3_1<2, 0b000111,
                    (outs IntRegs:$rd), (ins IntRegs:$rs1, IntRegs:$rs2),
                    "xnor $rs1, $rs2, $rd",
                    [(set i32:$rd, (not (xor i32:$rs1, i32:$rs2)))]>;
 def XNORri  : F3_2<2, 0b000111,
                    (outs IntRegs:$rd), (ins IntRegs:$rs1, simm13Op:$simm13),
                    "xnor $rs1, $simm13, $rd", []>;
 
+def : Pat<(and IntRegs:$rs1, SETHIimm_not:$rs2),
+          (ANDNrr i32:$rs1, (SETHIi SETHIimm_not:$rs2))>;
+
+def : Pat<(or IntRegs:$rs1, SETHIimm_not:$rs2),
+          (ORNrr i32:$rs1,  (SETHIi SETHIimm_not:$rs2))>;
+
 let Defs = [ICC] in {
   defm ANDCC  : F3_12np<"andcc",  0b010001>;
   defm ANDNCC : F3_12np<"andncc", 0b010101>;
   defm ORCC   : F3_12np<"orcc",   0b010010>;
   defm ORNCC  : F3_12np<"orncc",  0b010110>;
   defm XORCC  : F3_12np<"xorcc",  0b010011>;
   defm XNORCC : F3_12np<"xnorcc", 0b010111>;
 }

test/CodeGen/SPARC/sethiandn.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=sparc | FileCheck %s -check-prefix=SPARC
+
+define i32 @test_andn(i32 %x) nounwind {
+; SPARC-LABEL: test_andn:
+; SPARC:       ! %bb.0: ! %entry
+; SPARC-NEXT:    sethi 4194272, %o1
+; SPARC-NEXT:    retl
+; SPARC-NEXT:    andn %o0, %o1, %o0
+entry:
+  %and = and i32 %x, 32767
+  ret i32 %and
+}
+
+define i32 @test_orn(i32 %x) nounwind {
+; SPARC-LABEL: test_orn:
+; SPARC:       ! %bb.0: ! %entry
+; SPARC-NEXT:    sethi 4194272, %o1
+; SPARC-NEXT:    retl
+; SPARC-NEXT:    orn %o0, %o1, %o0
+entry:
+  %or = or i32 %x, 32767
+  ret i32 %or
+}
+
+; If constant is used more than once it is probably
+; better to keep it in its original form.
+define i32 @test_used_more_than_once(i32 %x) nounwind {
+; SPARC-LABEL: test_used_more_than_once:
+; SPARC:       ! %bb.0: ! %entry
+; SPARC-NEXT:    sethi 31, %o1
+; SPARC-NEXT:    or %o1, 1023, %o1
+; SPARC-NEXT:    or %o0, %o1, %o2
+; SPARC-NEXT:    and %o0, %o1, %o0
+; SPARC-NEXT:    retl
+; SPARC-NEXT:    xor %o2, %o0, %o0
+entry:
+  %0 = or i32 %x, 32767
+  %and = and i32 %x, 32767
+  %res = xor i32 %0, %and
+  ret i32 %res
+}