contrib/llvm/lib/Target/SystemZ/SystemZPatterns.td

   1 //===-- SystemZPatterns.td - SystemZ-specific pattern rules ---*- tblgen-*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // Record that INSN performs a 64-bit version of unary operator OPERATOR
  11 // in which the operand is sign-extended from 32 to 64 bits.
  12 multiclass SXU<SDPatternOperator operator, Instruction insn> {
  13   def : Pat<(operator (sext (i32 GR32:$src))),
  14             (insn GR32:$src)>;
  15   def : Pat<(operator (sext_inreg GR64:$src, i32)),
  16             (insn (EXTRACT_SUBREG GR64:$src, subreg_32bit))>;
  17 }
  18
  19 // Record that INSN performs a 64-bit version of binary operator OPERATOR
  20 // in which the first operand has class CLS and which the second operand
  21 // is sign-extended from a 32-bit register.
  22 multiclass SXB<SDPatternOperator operator, RegisterOperand cls,
  23                Instruction insn> {
  24   def : Pat<(operator cls:$src1, (sext GR32:$src2)),
  25             (insn cls:$src1, GR32:$src2)>;
  26   def : Pat<(operator cls:$src1, (sext_inreg GR64:$src2, i32)),
  27             (insn cls:$src1, (EXTRACT_SUBREG GR64:$src2, subreg_32bit))>;
  28 }
  29
  30 // Like SXB, but for zero extension.
  31 multiclass ZXB<SDPatternOperator operator, RegisterOperand cls,
  32                Instruction insn> {
  33   def : Pat<(operator cls:$src1, (zext GR32:$src2)),
  34             (insn cls:$src1, GR32:$src2)>;
  35   def : Pat<(operator cls:$src1, (and GR64:$src2, 0xffffffff)),
  36             (insn cls:$src1, (EXTRACT_SUBREG GR64:$src2, subreg_32bit))>;
  37 }
  38
  39 // Record that INSN performs a binary read-modify-write operation,
  40 // with LOAD, OPERATOR and STORE being the read, modify and write
  41 // respectively.  MODE is the addressing mode and IMM is the type
  42 // of the second operand.
  43 class RMWI<SDPatternOperator load, SDPatternOperator operator,
  44            SDPatternOperator store, AddressingMode mode,
  45            PatFrag imm, Instruction insn>
  46   : Pat<(store (operator (load mode:$addr), imm:$src), mode:$addr),
  47         (insn mode:$addr, (UIMM8 imm:$src))>;
  48
  49 // Record that INSN performs binary operation OPERATION on a byte
  50 // memory location.  IMM is the type of the second operand.
  51 multiclass RMWIByte<SDPatternOperator operator, AddressingMode mode,
  52                     Instruction insn> {
  53   def : RMWI<zextloadi8, operator, truncstorei8, mode, imm32, insn>;
  54   def : RMWI<zextloadi8, operator, truncstorei8, mode, imm64, insn>;
  55   def : RMWI<sextloadi8, operator, truncstorei8, mode, imm32, insn>;
  56   def : RMWI<sextloadi8, operator, truncstorei8, mode, imm64, insn>;
  57   def : RMWI<extloadi8, operator, truncstorei8, mode, imm32, insn>;
  58   def : RMWI<extloadi8, operator, truncstorei8, mode, imm64, insn>;
  59 }
  60
  61 // Record that INSN performs insertion TYPE into a register of class CLS.
  62 // The inserted operand is loaded using LOAD from an address of mode MODE.
  63 multiclass InsertMem<string type, Instruction insn, RegisterOperand cls,
  64                      SDPatternOperator load, AddressingMode mode> {
  65   def : Pat<(!cast<SDPatternOperator>("or_as_"##type)
  66               cls:$src1, (load mode:$src2)),
  67             (insn cls:$src1, mode:$src2)>;
  68   def : Pat<(!cast<SDPatternOperator>("or_as_rev"##type)
  69               (load mode:$src2), cls:$src1),
  70             (insn cls:$src1, mode:$src2)>;
  71 }