contrib/llvm/lib/Target/AArch64/AArch64Schedule.td

   1 //==-- AArch64Schedule.td - AArch64 Scheduling Definitions -*- tablegen -*-===//
   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 // Define TII for use in SchedVariant Predicates.
  11 // const MachineInstr *MI and const TargetSchedModel *SchedModel
  12 // are defined by default.
  13 def : PredicateProlog<[{
  14   const AArch64InstrInfo *TII =
  15     static_cast<const AArch64InstrInfo*>(SchedModel->getInstrInfo());
  16   (void)TII;
  17 }]>;
  18
  19 // AArch64 Scheduler Definitions
  20
  21 def WriteImm       : SchedWrite; // MOVN, MOVZ
  22 // TODO: Provide variants for MOV32/64imm Pseudos that dynamically
  23 // select the correct sequence of WriteImms.
  24
  25 def WriteI         : SchedWrite; // ALU
  26 def WriteISReg     : SchedWrite; // ALU of Shifted-Reg
  27 def WriteIEReg     : SchedWrite; // ALU of Extended-Reg
  28 def ReadI          : SchedRead;  // ALU
  29 def ReadISReg      : SchedRead;  // ALU of Shifted-Reg
  30 def ReadIEReg      : SchedRead;  // ALU of Extended-Reg
  31 def WriteExtr      : SchedWrite; // EXTR shifts a reg pair
  32 def ReadExtrHi     : SchedRead;  // Read the high reg of the EXTR pair
  33 def WriteIS        : SchedWrite; // Shift/Scale
  34 def WriteID32      : SchedWrite; // 32-bit Divide
  35 def WriteID64      : SchedWrite; // 64-bit Divide
  36 def ReadID         : SchedRead;  // 32/64-bit Divide
  37 def WriteIM32      : SchedWrite; // 32-bit Multiply
  38 def WriteIM64      : SchedWrite; // 64-bit Multiply
  39 def ReadIM         : SchedRead;  // 32/64-bit Multiply
  40 def ReadIMA        : SchedRead;  // 32/64-bit Multiply Accumulate
  41 def WriteBr        : SchedWrite; // Branch
  42 def WriteBrReg     : SchedWrite; // Indirect Branch
  43
  44 def WriteLD        : SchedWrite; // Load from base addr plus immediate offset
  45 def WriteST        : SchedWrite; // Store to base addr plus immediate offset
  46 def WriteSTP       : SchedWrite; // Store a register pair.
  47 def WriteAdr       : SchedWrite; // Address pre/post increment.
  48
  49 def WriteLDIdx : SchedWrite; // Load from a register index (maybe scaled).
  50 def WriteSTIdx : SchedWrite; // Store to a register index (maybe scaled).
  51 def ReadAdrBase : SchedRead; // Read the base resister of a reg-offset LD/ST.
  52
  53 // Serialized two-level address load.
  54 // EXAMPLE: LOADGot
  55 def WriteLDAdr : WriteSequence<[WriteAdr, WriteLD]>;
  56
  57 // Serialized two-level address lookup.
  58 // EXAMPLE: MOVaddr...
  59 def WriteAdrAdr : WriteSequence<[WriteAdr, WriteAdr]>;
  60
  61 // The second register of a load-pair.
  62 // LDP,LDPSW,LDNP,LDXP,LDAXP
  63 def WriteLDHi : SchedWrite;
  64
  65 // Store-exclusive is a store followed by a dependent load.
  66 def WriteSTX : WriteSequence<[WriteST, WriteLD]>;
  67
  68 def WriteSys     : SchedWrite; // Long, variable latency system ops.
  69 def WriteBarrier : SchedWrite; // Memory barrier.
  70 def WriteHint    : SchedWrite; // Hint instruction.
  71
  72 def WriteF       : SchedWrite; // General floating-point ops.
  73 def WriteFCmp    : SchedWrite; // Floating-point compare.
  74 def WriteFCvt    : SchedWrite; // Float conversion.
  75 def WriteFCopy   : SchedWrite; // Float-int register copy.
  76 def WriteFImm    : SchedWrite; // Floating-point immediate.
  77 def WriteFMul    : SchedWrite; // Floating-point multiply.
  78 def WriteFDiv    : SchedWrite; // Floating-point division.
  79
  80 def WriteV   : SchedWrite; // Vector ops.
  81 def WriteVLD : SchedWrite; // Vector loads.
  82 def WriteVST : SchedWrite; // Vector stores.
  83
  84 def WriteAtomic : SchedWrite; // Atomic memory operations (CAS, Swap, LDOP)
  85
  86 // Read the unwritten lanes of the VLD's destination registers.
  87 def ReadVLD : SchedRead;
  88
  89 // Sequential vector load and shuffle.
  90 def WriteVLDShuffle     : WriteSequence<[WriteVLD, WriteV]>;
  91 def WriteVLDPairShuffle : WriteSequence<[WriteVLD, WriteV, WriteV]>;
  92
  93 // Store a shuffled vector.
  94 def WriteVSTShuffle : WriteSequence<[WriteV, WriteVST]>;
  95 def WriteVSTPairShuffle : WriteSequence<[WriteV, WriteV, WriteVST]>;