mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
ca0f4dc4f0
This commit starts with a "git mv ARM64 AArch64" and continues out from there, renaming the C++ classes, intrinsics, and other target-local objects for consistency. "ARM64" test directories are also moved, and tests that began their life in ARM64 use an arm64 triple, those from AArch64 use an aarch64 triple. Both should be equivalent though. This finishes the AArch64 merge, and everyone should feel free to continue committing as normal now. llvm-svn: 209577
105 lines
4.3 KiB
TableGen
105 lines
4.3 KiB
TableGen
//==-- AArch64Schedule.td - AArch64 Scheduling Definitions -*- tablegen -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Define TII for use in SchedVariant Predicates.
|
|
// const MachineInstr *MI and const TargetSchedModel *SchedModel
|
|
// are defined by default.
|
|
def : PredicateProlog<[{
|
|
const AArch64InstrInfo *TII =
|
|
static_cast<const AArch64InstrInfo*>(SchedModel->getInstrInfo());
|
|
(void)TII;
|
|
}]>;
|
|
|
|
// AArch64 Scheduler Definitions
|
|
|
|
def WriteImm : SchedWrite; // MOVN, MOVZ
|
|
// TODO: Provide variants for MOV32/64imm Pseudos that dynamically
|
|
// select the correct sequence of WriteImms.
|
|
|
|
def WriteI : SchedWrite; // ALU
|
|
def WriteISReg : SchedWrite; // ALU of Shifted-Reg
|
|
def WriteIEReg : SchedWrite; // ALU of Extended-Reg
|
|
def ReadI : SchedRead; // ALU
|
|
def ReadISReg : SchedRead; // ALU of Shifted-Reg
|
|
def ReadIEReg : SchedRead; // ALU of Extended-Reg
|
|
def WriteExtr : SchedWrite; // EXTR shifts a reg pair
|
|
def ReadExtrHi : SchedRead; // Read the high reg of the EXTR pair
|
|
def WriteIS : SchedWrite; // Shift/Scale
|
|
def WriteID32 : SchedWrite; // 32-bit Divide
|
|
def WriteID64 : SchedWrite; // 64-bit Divide
|
|
def ReadID : SchedRead; // 32/64-bit Divide
|
|
def WriteIM32 : SchedWrite; // 32-bit Multiply
|
|
def WriteIM64 : SchedWrite; // 64-bit Multiply
|
|
def ReadIM : SchedRead; // 32/64-bit Multiply
|
|
def ReadIMA : SchedRead; // 32/64-bit Multiply Accumulate
|
|
def WriteBr : SchedWrite; // Branch
|
|
def WriteBrReg : SchedWrite; // Indirect Branch
|
|
|
|
def WriteLD : SchedWrite; // Load from base addr plus immediate offset
|
|
def WriteST : SchedWrite; // Store to base addr plus immediate offset
|
|
def WriteSTP : SchedWrite; // Store a register pair.
|
|
def WriteAdr : SchedWrite; // Address pre/post increment.
|
|
|
|
def WriteLDIdx : SchedWrite; // Load from a register index (maybe scaled).
|
|
def WriteSTIdx : SchedWrite; // Store to a register index (maybe scaled).
|
|
def ReadAdrBase : SchedRead; // Read the base resister of a reg-offset LD/ST.
|
|
|
|
// Predicate for determining when a shiftable register is shifted.
|
|
def RegShiftedPred : SchedPredicate<[{TII->hasShiftedReg(MI)}]>;
|
|
|
|
// Predicate for determining when a extendedable register is extended.
|
|
def RegExtendedPred : SchedPredicate<[{TII->hasExtendedReg(MI)}]>;
|
|
|
|
// ScaledIdxPred is true if a WriteLDIdx operand will be
|
|
// scaled. Subtargets can use this to dynamically select resources and
|
|
// latency for WriteLDIdx and ReadAdrBase.
|
|
def ScaledIdxPred : SchedPredicate<[{TII->isScaledAddr(MI)}]>;
|
|
|
|
// Serialized two-level address load.
|
|
// EXAMPLE: LOADGot
|
|
def WriteLDAdr : WriteSequence<[WriteAdr, WriteLD]>;
|
|
|
|
// Serialized two-level address lookup.
|
|
// EXAMPLE: MOVaddr...
|
|
def WriteAdrAdr : WriteSequence<[WriteAdr, WriteAdr]>;
|
|
|
|
// The second register of a load-pair.
|
|
// LDP,LDPSW,LDNP,LDXP,LDAXP
|
|
def WriteLDHi : SchedWrite;
|
|
|
|
// Store-exclusive is a store followed by a dependent load.
|
|
def WriteSTX : WriteSequence<[WriteST, WriteLD]>;
|
|
|
|
def WriteSys : SchedWrite; // Long, variable latency system ops.
|
|
def WriteBarrier : SchedWrite; // Memory barrier.
|
|
def WriteHint : SchedWrite; // Hint instruction.
|
|
|
|
def WriteF : SchedWrite; // General floating-point ops.
|
|
def WriteFCmp : SchedWrite; // Floating-point compare.
|
|
def WriteFCvt : SchedWrite; // Float conversion.
|
|
def WriteFCopy : SchedWrite; // Float-int register copy.
|
|
def WriteFImm : SchedWrite; // Floating-point immediate.
|
|
def WriteFMul : SchedWrite; // Floating-point multiply.
|
|
def WriteFDiv : SchedWrite; // Floating-point division.
|
|
|
|
def WriteV : SchedWrite; // Vector ops.
|
|
def WriteVLD : SchedWrite; // Vector loads.
|
|
def WriteVST : SchedWrite; // Vector stores.
|
|
|
|
// Read the unwritten lanes of the VLD's destination registers.
|
|
def ReadVLD : SchedRead;
|
|
|
|
// Sequential vector load and shuffle.
|
|
def WriteVLDShuffle : WriteSequence<[WriteVLD, WriteV]>;
|
|
def WriteVLDPairShuffle : WriteSequence<[WriteVLD, WriteV, WriteV]>;
|
|
|
|
// Store a shuffled vector.
|
|
def WriteVSTShuffle : WriteSequence<[WriteV, WriteVST]>;
|
|
def WriteVSTPairShuffle : WriteSequence<[WriteV, WriteV, WriteVST]>;
|