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 op_addr_mode1 : Operand<iPTR> {
  17   let PrintMethod = "printAddrMode1";
  18   let NumMIOperands = 3;
  19   let MIOperandInfo = (ops ptr_rc, ptr_rc, i32imm);
  20 }
  21
  22 def memri : Operand<iPTR> {
  23   let PrintMethod = "printMemRegImm";
  24   let NumMIOperands = 2;
  25   let MIOperandInfo = (ops i32imm, ptr_rc);
  26 }
  27
  28 // Define ARM specific addressing mode.
  29 //Addressing Mode 1: data processing operands
  30 def addr_mode1 : ComplexPattern<iPTR, 3, "SelectAddrMode1", [imm, sra, shl, srl]>;
  31
  32 //register plus/minus 12 bit offset
  33 def iaddr  : ComplexPattern<iPTR, 2, "SelectAddrRegImm", [frameindex]>;
  34 //register plus scaled register
  35 //def raddr  : ComplexPattern<iPTR, 2, "SelectAddrRegReg", []>;
  36
  37 //===----------------------------------------------------------------------===//
  38 // Instructions
  39 //===----------------------------------------------------------------------===//
  40
  41 class InstARM<dag ops, string asmstr, list<dag> pattern> : Instruction {
  42   let Namespace = "ARM";
  43
  44   dag OperandList = ops;
  45   let AsmString   = asmstr;
  46   let Pattern = pattern;
  47 }
  48
  49 def brtarget : Operand<OtherVT>;
  50
  51 // Operand for printing out a condition code.
  52 let PrintMethod = "printCCOperand" in
  53   def CCOp : Operand<i32>;
  54
  55 def SDT_ARMCallSeq : SDTypeProfile<0, 1, [ SDTCisVT<0, i32> ]>;
  56 def callseq_start  : SDNode<"ISD::CALLSEQ_START", SDT_ARMCallSeq,
  57                              [SDNPHasChain, SDNPOutFlag]>;
  58 def callseq_end    : SDNode<"ISD::CALLSEQ_END",   SDT_ARMCallSeq,
  59                              [SDNPHasChain, SDNPOutFlag]>;
  60
  61 def SDT_ARMcall    : SDTypeProfile<0, -1, [SDTCisInt<0>]>;
  62 def ARMcall        : SDNode<"ARMISD::CALL", SDT_ARMcall,
  63                            [SDNPHasChain, SDNPOptInFlag, SDNPOutFlag]>;
  64 def retflag        : SDNode<"ARMISD::RET_FLAG", SDTRet,
  65                            [SDNPHasChain, SDNPOptInFlag]>;
  66
  67 def SDTarmselect   : SDTypeProfile<1, 3, [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>, SDTCisInt<0>, SDTCisVT<2, i32>]>;
  68
  69 def armselect      : SDNode<"ARMISD::SELECT", SDTarmselect, [SDNPInFlag, SDNPOutFlag]>;
  70
  71 def SDTarmbr       : SDTypeProfile<0, 2, [SDTCisVT<0, OtherVT>, SDTCisVT<1, i32>]>;
  72 def armbr          : SDNode<"ARMISD::BR", SDTarmbr, [SDNPHasChain, SDNPInFlag]>;
  73
  74 def SDTVoidBinOp : SDTypeProfile<0, 2, [SDTCisSameAs<0, 1>]>;
  75 def armcmp       : SDNode<"ARMISD::CMP",  SDTVoidBinOp, [SDNPOutFlag]>;
  76
  77 def armfsitos    : SDNode<"ARMISD::FSITOS", SDTUnaryOp>;
  78
  79 def ADJCALLSTACKUP : InstARM<(ops i32imm:$amt),
  80                             "!ADJCALLSTACKUP $amt",
  81                             [(callseq_end imm:$amt)]>;
  82
  83 def ADJCALLSTACKDOWN : InstARM<(ops i32imm:$amt),
  84                                "!ADJCALLSTACKDOWN $amt",
  85                                [(callseq_start imm:$amt)]>;
  86
  87 let isReturn = 1 in {
  88   def bx: InstARM<(ops), "bx r14", [(retflag)]>;
  89 }
  90
  91 let  Defs = [R0, R1, R2, R3, R14] in {
  92   def bl: InstARM<(ops i32imm:$func, variable_ops), "bl $func", [(ARMcall tglobaladdr:$func)]>;
  93 }
  94
  95 def ldr   : InstARM<(ops IntRegs:$dst, memri:$addr),
  96                      "ldr $dst, $addr",
  97                      [(set IntRegs:$dst, (load iaddr:$addr))]>;
  98
  99 def str  : InstARM<(ops IntRegs:$src, memri:$addr),
 100                     "str $src, $addr",
 101                     [(store IntRegs:$src, iaddr:$addr)]>;
 102
 103 def MOV   : InstARM<(ops IntRegs:$dst, op_addr_mode1:$src),
 104                     "mov $dst, $src", [(set IntRegs:$dst, addr_mode1:$src)]>;
 105
 106 def ADD     : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
 107                        "add $dst, $a, $b",
 108                        [(set IntRegs:$dst, (add IntRegs:$a, addr_mode1:$b))]>;
 109
 110 // "LEA" forms of add
 111 def lea_addri : InstARM<(ops IntRegs:$dst, memri:$addr),
 112                          "add $dst, ${addr:arith}",
 113                          [(set IntRegs:$dst, iaddr:$addr)]>;
 114
 115
 116 def SUB     : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
 117                        "sub $dst, $a, $b",
 118                        [(set IntRegs:$dst, (sub IntRegs:$a, addr_mode1:$b))]>;
 119
 120 def AND     : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
 121                        "and $dst, $a, $b",
 122                        [(set IntRegs:$dst, (and IntRegs:$a, addr_mode1:$b))]>;
 123
 124 def EOR     : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
 125                        "eor $dst, $a, $b",
 126                        [(set IntRegs:$dst, (xor IntRegs:$a, addr_mode1:$b))]>;
 127
 128 def ORR     : InstARM<(ops IntRegs:$dst, IntRegs:$a, op_addr_mode1:$b),
 129                        "orr $dst, $a, $b",
 130                        [(set IntRegs:$dst, (or IntRegs:$a, addr_mode1:$b))]>;
 131
 132 let isTwoAddress = 1 in {
 133   def movcond : InstARM<(ops IntRegs:$dst, IntRegs:$false,
 134                          op_addr_mode1:$true, CCOp:$cc),
 135                          "mov$cc $dst, $true",
 136                          [(set IntRegs:$dst, (armselect addr_mode1:$true,
 137                            IntRegs:$false, imm:$cc))]>;
 138 }
 139
 140 def MUL     : InstARM<(ops IntRegs:$dst, IntRegs:$a, IntRegs:$b),
 141                        "mul $dst, $a, $b",
 142                        [(set IntRegs:$dst, (mul IntRegs:$a, IntRegs:$b))]>;
 143
 144 def bcond      : InstARM<(ops brtarget:$dst, CCOp:$cc),
 145                          "b$cc $dst",
 146                          [(armbr bb:$dst, imm:$cc)]>;
 147
 148 def b      : InstARM<(ops brtarget:$dst),
 149                          "b $dst",
 150                          [(br bb:$dst)]>;
 151
 152 def cmp      : InstARM<(ops IntRegs:$a, op_addr_mode1:$b),
 153                        "cmp $a, $b",
 154                        [(armcmp IntRegs:$a, addr_mode1:$b)]>;
 155
 156
 157 // Floating Point Conversion
 158 // We use bitconvert for moving the data between the register classes.
 159 // The format conversion is done with ARM specific nodes
 160
 161 def FMSR    : InstARM<(ops FPRegs:$dst, IntRegs:$src),
 162                        "fmsr $dst, $src", [(set FPRegs:$dst, (bitconvert IntRegs:$src))]>;
 163
 164 def FMRS    : InstARM<(ops IntRegs:$dst, FPRegs:$src),
 165                        "fmrs $dst, $src", [(set IntRegs:$dst, (bitconvert FPRegs:$src))]>;
 166
 167 def FSITOS  : InstARM<(ops FPRegs:$dst, FPRegs:$src),
 168                        "fsitos $dst, $src", [(set FPRegs:$dst, (armfsitos FPRegs:$src))]>;