[SystemZ] Introduce distinction between the jg/jl family of mnemonics for GNU as vs HLASM

[anirudhp]

Summary

• This patch adds in the distinction between jg[*] and jl[*] pc-relative mnemonics based on the variant/dialect.
• Under the hlasm variant, we use the jl[*] family of mnemonics and under the att (GNU as) variant, we use the jg[*] family of mnemonics.
• jgnop which was added in https://reviews.llvm.org/D92185, is now restricted to att variant. jlnop is introduced and restricted to hlasm variant.
• The br[*]l additional mnemonics are mapped to either jl[*]/jg[*] based on the variant.

[uweigand]

Looks good in general. Just as a cosmetic issue, it would be nicer to be able to simply write:

def BRUAsm#V  : MnemonicCondBranchAlias <CV<V>, "br#", "j#">;
def BRULAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jg#", "att">;
def BRUL_HLASMAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jl#", "hlasm">;

and have the additional assembler dialect constraint based on the mnemonic handled within MnemonicCondBranchAlias. Completely untested, but would something along the following lines work?

class MnemonicCondBranchAlias<CondVariant V, string from, string to,
                              string asmvariant = V.asmvariant> {
  if !or(!eq(V.asmvariant, ""), !eq(V.asmvariant, asmvariant)) then
    def "" : MnemonicAlias<!subst("#", V.suffix, from), !subst("#", V.suffix, to),
                           asmvariant>;
}

(It might have to be a multiclass instead of class, possibly.)

[anirudhp]

• Improved the implementation of MnemonicCondBranch by abstracting away details from SystemZInstrInfo.td
• For this, a multi-class had to be used.

[anirudhp]

In D97581#2593918, @uweigand wrote:

Looks good in general. Just as a cosmetic issue, it would be nicer to be able to simply write:

def BRUAsm#V  : MnemonicCondBranchAlias <CV<V>, "br#", "j#">;
def BRULAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jg#", "att">;
def BRUL_HLASMAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jl#", "hlasm">;

and have the additional assembler dialect constraint based on the mnemonic handled within MnemonicCondBranchAlias. Completely untested, but would something along the following lines work?

class MnemonicCondBranchAlias<CondVariant V, string from, string to,
                              string asmvariant = V.asmvariant> {
  if !or(!eq(V.asmvariant, ""), !eq(V.asmvariant, asmvariant)) then
    def "" : MnemonicAlias<!subst("#", V.suffix, from), !subst("#", V.suffix, to),
                           asmvariant>;
}

(It might have to be a multiclass instead of class, possibly.)

I abstracted away the implementation into SystemZInstrFormats.td. As you pointed out, it should be a multiclass.

[uweigand]

In D97581#2594444, @anirudhp wrote:

• Improved the implementation of MnemonicCondBranch by abstracting away details from SystemZInstrInfo.td
• For this, a multi-class had to be used.

Excellent, thank you! This LGTM now.

llvm/lib/Target/SystemZ/SystemZInstrFormats.td

 class ICV<string name>
   : CondVariant<!cast<CondVariant>("IntCondVariant"#name).ccmask,
                 !cast<CondVariant>("IntCondVariant"#name).suffix,
                 !cast<CondVariant>("IntCondVariant"#name).alternate,
                 !cast<CondVariant>("IntCondVariant"#name).asmvariant>;
 
 // Defines a class that makes it easier to define
 // a MnemonicAlias when CondVariant's are involved.
-class MnemonicCondBranchAlias<CondVariant V, string from, string to>
-  : MnemonicAlias<!subst("#", V.suffix, from), !subst("#", V.suffix, to),
-                  V.asmvariant>;
+multiclass MnemonicCondBranchAlias<CondVariant V, string from, string to,
+                                   string asmvariant = V.asmvariant> {
+  if !or(!eq(V.asmvariant, ""), !eq(V.asmvariant, asmvariant)) then
+    def "" : MnemonicAlias<!subst("#", V.suffix, from),
+                           !subst("#", V.suffix, to),
+                           asmvariant>;
+}
 
 //===----------------------------------------------------------------------===//
 // Instruction definitions with semantics
 //===----------------------------------------------------------------------===//
 //
 // These classes have the form [Cond]<Category><Format>, where <Format> is one
 // of the formats defined above and where <Category> describes the inputs
 // and outputs.  "Cond" is used if the instruction is conditional,

llvm/lib/Target/SystemZ/SystemZInstrInfo.td

def BICAsm : AsmCondBranchRXY<"bic", 0xe347>,
                  Requires<[FeatureMiscellaneousExtensions2]>;
   }
 
   // Define AsmParser extended mnemonics for each general condition-code mask
   // (integer or floating-point)
   foreach V = [ "E", "NE", "H", "NH", "L", "NL", "HE", "NHE", "LE", "NLE",
                 "Z", "NZ", "P", "NP", "M", "NM", "LH", "NLH", "O", "NO" ] in {
     def JAsm#V  : FixedCondBranchRI <CV<V>, "j#",  0xA74>;
-    def JGAsm#V : FixedCondBranchRIL<CV<V>, "jg#", 0xC04>;
+    def JGAsm#V : FixedCondBranchRIL<CV<V>, "j{g|l}#", 0xC04>;
     let isIndirectBranch = 1 in {
       def BAsm#V  : FixedCondBranchRX <CV<V>, "b#",  0x47>;
       def BRAsm#V : FixedCondBranchRR <CV<V>, "b#r", 0x07>;
       def BIAsm#V : FixedCondBranchRXY<CV<V>, "bi#", 0xe347>,
                     Requires<[FeatureMiscellaneousExtensions2]>;
     }
   }
 }
 
 // Unconditional branches.  These are in fact simply variants of the
 // conditional branches with the condition mask set to "always".
 let isBranch = 1, isTerminator = 1, isBarrier = 1 in {
   def J  : FixedCondBranchRI <CondAlways, "j",  0xA74, br>;
-  def JG : FixedCondBranchRIL<CondAlways, "jg", 0xC04>;
+  def JG : FixedCondBranchRIL<CondAlways, "j{g|lu}", 0xC04>;
   let isIndirectBranch = 1 in {
     def B  : FixedCondBranchRX<CondAlways, "b",  0x47>;
     def BR : FixedCondBranchRR<CondAlways, "br", 0x07, brind>;
     def BI : FixedCondBranchRXY<CondAlways, "bi", 0xe347, brind>,
              Requires<[FeatureMiscellaneousExtensions2]>;
   }
 }
 
 // NOPs.  These are again variants of the conditional branches, with the
 // condition mask set to "never".  NOP_bare can't be an InstAlias since it
 // would need R0D hard coded which is not part of ADDR64BitRegClass.
 def NOP  : InstAlias<"nop\t$XBD", (BCAsm 0, bdxaddr12only:$XBD), 0>;
 let isAsmParserOnly = 1, hasNoSchedulingInfo = 1, M1 = 0, XBD2 = 0 in
   def NOP_bare  : InstRXb<0x47,(outs), (ins), "nop", []>;
 def NOPR : InstAlias<"nopr\t$R", (BCRAsm 0, GR64:$R), 0>;
 def NOPR_bare : InstAlias<"nopr", (BCRAsm 0, R0D), 0>;
 
 // An alias of BRC 0, label
 def JNOP : InstAlias<"jnop\t$RI2", (BRCAsm 0, brtarget16:$RI2), 0>;
 
 // An alias of BRCL 0, label
-def JGNOP : InstAlias<"jgnop\t$RI2", (BRCLAsm 0, brtarget32:$RI2), 0>;
+// jgnop on att ; jlnop on hlasm
+def JGNOP : InstAlias<"{jgnop|jlnop}\t$RI2", (BRCLAsm 0, brtarget32:$RI2), 0>;
 
 // Fused compare-and-branch instructions.
 //
 // These instructions do not use or clobber the condition codes.
 // We nevertheless pretend that the relative compare-and-branch
 // instructions clobber CC, so that we can lower them to separate
 // comparisons and BRCLs if the branch ends up being out of range.
 let isBranch = 1, isTerminator = 1 in {

 def JAS   : MnemonicAlias<"jas", "bras">;
 def JASL  : MnemonicAlias<"jasl", "brasl">;
 def JXH   : MnemonicAlias<"jxh", "brxh">;
 def JXLE  : MnemonicAlias<"jxle", "brxle">;
 def JXHG  : MnemonicAlias<"jxhg", "brxhg">;
 def JXLEG : MnemonicAlias<"jxleg", "brxlg">;
 
 def BRU   : MnemonicAlias<"bru", "j">;
-def BRUL  : MnemonicAlias<"brul", "jg">;
+def BRUL  : MnemonicAlias<"brul", "jg", "att">;
+def BRUL_HLASM  : MnemonicAlias<"brul", "jlu", "hlasm">;
 
 foreach V = [ "E", "NE", "H", "NH", "L", "NL", "HE", "NHE", "LE", "NLE",
               "Z", "NZ", "P", "NP", "M", "NM", "LH", "NLH", "O", "NO" ] in {
-  def BRUAsm#V : MnemonicCondBranchAlias <CV<V>, "br#", "j#">;
-  def BRULAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jg#">;
+  defm BRUAsm#V  : MnemonicCondBranchAlias <CV<V>, "br#", "j#", CV<V>.asmvariant>;
+  defm BRULAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jg#", "att">;
+  defm BRUL_HLASMAsm#V : MnemonicCondBranchAlias <CV<V>, "br#l", "jl#", "hlasm">;
 }

llvm/test/MC/SystemZ/insn-bad.s

#CHECK: jnop    0x10000
   brc 0, -1
   brc 0, 1
   brc 0, 0x10000
   jnop  -0x100002
   jnop  -1
   jnop  1
   jnop  0x10000
 
+#CHECK: error: invalid instruction
+#CHECK: jlu     label
+#CHECK: error: invalid instruction
+#CHECK: jlne    label
+#CHECK: error: invalid instruction
+#CHECK: jlnh    label
+#CHECK: error: invalid instruction
+#CHECK: jll     label
+#CHECK: error: invalid instruction
+#CHECK: jlnl    label
+#CHECK: error: invalid instruction
+#CHECK: jlhe    label
+#CHECK: error: invalid instruction
+#CHECK: jlnhe   label
+#CHECK: error: invalid instruction
+#CHECK: jlle    label
+#CHECK: error: invalid instruction
+#CHECK: jlnle   label
+#CHECK: error: invalid instruction
+#CHECK: jlz     label
+#CHECK: error: invalid instruction
+#CHECK: jlnz    label
+#CHECK: error: invalid instruction
+#CHECK: jlp     label
+#CHECK: error: invalid instruction
+#CHECK: jlnp    label
+#CHECK: error: invalid instruction
+#CHECK: jlm     label
+#CHECK: error: invalid instruction
+#CHECK: jlnm    label
+#CHECK: error: invalid instruction
+#CHECK: jllh    label
+#CHECK: error: invalid instruction
+#CHECK: jllnlh  label
+#CHECK: error: invalid instruction
+#CHECK: jlo     label
+#CHECK: error: invalid instruction
+#CHECK: jlno    label
+
+  jlu label
+  jlne  label
+  jlnh  label
+  jll label
+  jlnl  label
+  jlhe  label
+  jlnhe label
+  jlle  label
+  jlnle label
+  jlz label
+  jlnz  label
+  jlp label
+  jlnp  label
+  jlm label
+  jlnm  label
+  jllh  label
+  jllnlh  label
+  jlo label
+  jlno  label
+
 #CHECK: error: invalid operand
 #CHECK: brc foo, bar
 #CHECK: error: invalid operand
 #CHECK: brc -1, bar
 #CHECK: error: invalid operand
 #CHECK: brc 16, bar
 
   brc foo, bar
#CHECK: jgnop 0x100000000
   brcl  0, -1
   brcl  0, 1
   brcl  0, 0x100000000
   jgnop -0x1000000002
   jgnop -1
   jgnop 1
   jgnop 0x100000000
 
+
+#CHECK: error: invalid instruction
+#CHECK: jlnop label 
+  jlnop label
+
 #CHECK: error: invalid operand
 #CHECK: brcl  foo, bar
 #CHECK: error: invalid operand
 #CHECK: brcl  -1, bar
 #CHECK: error: invalid operand
 #CHECK: brcl  16, bar
 
   brcl  foo, bar