mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-26 07:29:55 +00:00
This adds a second implementation of the AArch64 architecture to LLVM, accessible in parallel via the "arm64" triple. The plan over the coming weeks & months is to merge the two into a single backend, during which time thorough code review should naturally occur. Everything will be easier with the target in-tree though, hence this commit. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@205090 91177308-0d34-0410-b5e6-96231b3b80d8
93 lines
3.7 KiB
TableGen
93 lines
3.7 KiB
TableGen
//===-- ARMSchedule.td - ARM 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 ARM64InstrInfo *TII =
|
|
static_cast<const ARM64InstrInfo*>(SchedModel->getInstrInfo());
|
|
(void)TII;
|
|
}]>;
|
|
|
|
// ARM64 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 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 WriteIM32 : SchedWrite; // 32-bit Multiply
|
|
def WriteIM64 : SchedWrite; // 64-bit Multiply
|
|
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.
|
|
|
|
// 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]>;
|