lib/Target/ARM/ARMInstrInfo.td

   1 //===- ARMInstrInfo.td - Target Description for ARM Target ----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the "Instituto Nokia de Tecnologia" and
   6 // is distributed under the University of Illinois Open Source
   7 // License. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10 //
  11 // This file describes the ARM instructions in TableGen format.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 // Address operands
  16 def memri : Operand<iPTR> {
  17   let PrintMethod = "printMemRegImm";
  18   let NumMIOperands = 2;
  19   let MIOperandInfo = (ops i32imm, ptr_rc);
  20 }
  21
  22 // Define ARM specific addressing mode.
  23 //register plus/minus 12 bit offset
  24 def iaddr  : ComplexPattern<iPTR, 2, "SelectAddrRegImm", [frameindex]>;
  25 //register plus scaled register
  26 //def raddr  : ComplexPattern<iPTR, 2, "SelectAddrRegReg", []>;
  27
  28 //===----------------------------------------------------------------------===//
  29 // Instructions
  30 //===----------------------------------------------------------------------===//
  31
  32 class InstARM<dag ops, string asmstr, list<dag> pattern> : Instruction {
  33   let Namespace = "ARM";
  34
  35   dag OperandList = ops;
  36   let AsmString   = asmstr;
  37   let Pattern = pattern;
  38 }
  39
  40 def brtarget : Operand<OtherVT>;
  41
  42 // Operand for printing out a condition code.
  43 let PrintMethod = "printCCOperand" in
  44   def CCOp : Operand<i32>;
  45
  46 def SDT_ARMCallSeq : SDTypeProfile<0, 1, [ SDTCisVT<0, i32> ]>;
  47 def callseq_start  : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeq,
  48                              [SDNPHasChain, SDNPOutFlag]>;
  49 def callseq_end    : SDNode<"ISD::CALLSEQ_END",   SDT_ARMCallSeq,
  50                              [SDNPHasChain, SDNPOutFlag]>;
  51
  52 def SDT_ARMcall    : SDTypeProfile<0, -1, [SDTCisInt<0>]>;
  53 def ARMcall        : SDNode<"ARMISD::CALL", SDT_ARMcall,
  54                            [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  55 def retflag        : SDNode<"ARMISD::RET_FLAG", SDTRet,
  56                            [SDNPHasChain, SDNPOptInFlag]>;
  57
  58 def SDTarmselect   : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisVT<2, i32>]>;
  59
  60 def armselect      : SDNode<"ARMISD::SELECT", SDTarmselect, [SDNPInFlag, SDNPOutFlag]>;
  61
  62 def SDTarmbr       : SDTypeProfile<0, 2, [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>]>;
  63 def armbr          : SDNode<"ARMISD::BR", SDTarmbr, [SDNPHasChain, SDNPInFlag]>;
  64
  65 def SDTVoidBinOp : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
  66 def armcmp       : SDNode<"ARMISD::CMP",  SDTVoidBinOp, [SDNPOutFlag]>;
  67
  68 def ADJCALLSTACKUP : InstARM<(ops i32imm:$amt),
  69                             "!ADJCALLSTACKUP $amt",
  70                             [(callseq_end imm:$amt)]>;
  71
  72 def ADJCALLSTACKDOWN : InstARM<(ops i32imm:$amt),
  73                                "!ADJCALLSTACKDOWN $amt",
  74                                [(callseq_start imm:$amt)]>;
  75
  76 let isReturn = 1 in {
  77   def bx: InstARM<(ops), "bx r14", [(retflag)]>;
  78 }
  79
  80 let  Defs = [R0, R1, R2, R3, R14] in {
  81   def bl: InstARM<(ops i32imm:$func, variable_ops), "bl $func", [(ARMcall tglobaladdr:$func)]>;
  82 }
  83
  84 def ldr   : InstARM<(ops IntRegs:$dst, memri:$addr),
  85                      "ldr $dst, $addr",
  86                      [(set IntRegs:$dst, (load iaddr:$addr))]>;
  87
  88 def str  : InstARM<(ops IntRegs:$src, memri:$addr),
  89                     "str $src, $addr",
  90                     [(store IntRegs:$src, iaddr:$addr)]>;
  91
  92 def movrr   : InstARM<(ops IntRegs:$dst, IntRegs:$src),
  93                        "mov $dst, $src", []>;
  94
  95 def movri   : InstARM<(ops IntRegs:$dst, i32imm:$src),
  96                        "mov $dst, $src", [(set IntRegs:$dst, imm:$src)]>;
  97
  98 def addri   : InstARM<(ops IntRegs:$dst, IntRegs:$a, i32imm:$b),
  99                        "add $dst, $a, $b",
 100                        [(set IntRegs:$dst, (add IntRegs:$a, imm:$b))]>;
 101
 102 // "LEA" forms of add
 103 def lea_addri : InstARM<(ops IntRegs:$dst, memri:$addr),
 104                          "add $dst, ${addr:arith}",
 105                          [(set IntRegs:$dst, iaddr:$addr)]>;
 106
 107
 108 def subri   : InstARM<(ops IntRegs:$dst, IntRegs:$a, i32imm:$b),
 109                        "sub $dst, $a, $b",
 110                        [(set IntRegs:$dst, (sub IntRegs:$a, imm:$b))]>;
 111
 112 def andrr     : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
 113                        "and $dst, $a, $b",
 114                        [(set IntRegs:$dst, (and IntRegs:$a, IntRegs:$b))]>;
 115
 116 let isTwoAddress = 1 in {
 117   def movcond : InstARM<(ops IntRegs:$dst, IntRegs:$false, IntRegs:$true, CCOp:$cc),
 118                          "mov$cc $dst, $true",
 119                          [(set IntRegs:$dst, (armselect IntRegs:$true, IntRegs:$false, imm:$cc))]>;
 120 }
 121
 122 def bcond      : InstARM<(ops brtarget:$dst, CCOp:$cc),
 123                          "b$cc $dst",
 124                          [(armbr bb:$dst, imm:$cc)]>;
 125
 126 def cmp      : InstARM<(ops IntRegs:$a, IntRegs:$b),
 127                        "cmp $a, $b",
 128                        [(armcmp IntRegs:$a, IntRegs:$b)]>;