2018-11-27 05:47:28 +08:00
|
|
|
//===- AArch64SchedPredicates.td - AArch64 Sched Preds -----*- tablegen -*-===//
|
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2018-11-27 05:47:28 +08:00
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
//
|
|
|
|
|
// This file defines scheduling predicate definitions that are used by the
|
|
|
|
|
// AArch64 subtargets.
|
|
|
|
|
//
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
// Function mappers.
|
|
|
|
|
|
2018-12-11 00:24:30 +08:00
|
|
|
// Check the extension type in arithmetic instructions.
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getArithExtendType" in {
|
|
|
|
|
def CheckExtUXTB : CheckImmOperand_s<3, "AArch64_AM::UXTB">;
|
|
|
|
|
def CheckExtUXTH : CheckImmOperand_s<3, "AArch64_AM::UXTH">;
|
|
|
|
|
def CheckExtUXTW : CheckImmOperand_s<3, "AArch64_AM::UXTW">;
|
|
|
|
|
def CheckExtUXTX : CheckImmOperand_s<3, "AArch64_AM::UXTX">;
|
|
|
|
|
def CheckExtSXTB : CheckImmOperand_s<3, "AArch64_AM::SXTB">;
|
|
|
|
|
def CheckExtSXTH : CheckImmOperand_s<3, "AArch64_AM::SXTH">;
|
|
|
|
|
def CheckExtSXTW : CheckImmOperand_s<3, "AArch64_AM::SXTW">;
|
|
|
|
|
def CheckExtSXTX : CheckImmOperand_s<3, "AArch64_AM::SXTX">;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check for shifting in extended arithmetic instructions.
|
|
|
|
|
foreach I = {0-3} in {
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getArithShiftValue" in
|
|
|
|
|
def CheckExtBy#I : CheckImmOperand<3, I>;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-27 05:47:28 +08:00
|
|
|
// Check the extension type in the register offset addressing mode.
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getMemExtendType" in {
|
2018-12-11 00:24:30 +08:00
|
|
|
def CheckMemExtUXTW : CheckImmOperand_s<3, "AArch64_AM::UXTW">;
|
|
|
|
|
def CheckMemExtLSL : CheckImmOperand_s<3, "AArch64_AM::UXTX">;
|
|
|
|
|
def CheckMemExtSXTW : CheckImmOperand_s<3, "AArch64_AM::SXTW">;
|
|
|
|
|
def CheckMemExtSXTX : CheckImmOperand_s<3, "AArch64_AM::SXTX">;
|
2018-11-27 05:47:28 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check for scaling in the register offset addressing mode.
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getMemDoShift" in
|
2019-11-13 04:13:30 +08:00
|
|
|
def CheckMemScaled : CheckImmOperandSimple<4>;
|
2018-12-11 00:24:30 +08:00
|
|
|
|
|
|
|
|
// Check the shifting type in arithmetic and logic instructions.
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getShiftType" in {
|
|
|
|
|
def CheckShiftLSL : CheckImmOperand_s<3, "AArch64_AM::LSL">;
|
|
|
|
|
def CheckShiftLSR : CheckImmOperand_s<3, "AArch64_AM::LSR">;
|
|
|
|
|
def CheckShiftASR : CheckImmOperand_s<3, "AArch64_AM::ASR">;
|
|
|
|
|
def CheckShiftROR : CheckImmOperand_s<3, "AArch64_AM::ROR">;
|
|
|
|
|
def CheckShiftMSL : CheckImmOperand_s<3, "AArch64_AM::MSL">;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Check for shifting in arithmetic and logic instructions.
|
|
|
|
|
foreach I = {0-3, 8} in {
|
|
|
|
|
let FunctionMapper = "AArch64_AM::getShiftValue" in
|
|
|
|
|
def CheckShiftBy#I : CheckImmOperand<3, I>;
|
|
|
|
|
}
|
2018-11-27 05:47:28 +08:00
|
|
|
|
|
|
|
|
// Generic predicates.
|
|
|
|
|
|
2019-11-12 04:24:24 +08:00
|
|
|
// Identify whether an instruction is the 16-bit NEON form based on its result.
|
|
|
|
|
def CheckHForm : CheckAll<[CheckIsRegOperand<0>,
|
|
|
|
|
CheckAny<[CheckRegOperand<0, H0>,
|
|
|
|
|
CheckRegOperand<0, H1>,
|
|
|
|
|
CheckRegOperand<0, H2>,
|
|
|
|
|
CheckRegOperand<0, H3>,
|
|
|
|
|
CheckRegOperand<0, H4>,
|
|
|
|
|
CheckRegOperand<0, H5>,
|
|
|
|
|
CheckRegOperand<0, H6>,
|
|
|
|
|
CheckRegOperand<0, H7>,
|
|
|
|
|
CheckRegOperand<0, H8>,
|
|
|
|
|
CheckRegOperand<0, H9>,
|
|
|
|
|
CheckRegOperand<0, H10>,
|
|
|
|
|
CheckRegOperand<0, H11>,
|
|
|
|
|
CheckRegOperand<0, H12>,
|
|
|
|
|
CheckRegOperand<0, H13>,
|
|
|
|
|
CheckRegOperand<0, H14>,
|
|
|
|
|
CheckRegOperand<0, H15>,
|
|
|
|
|
CheckRegOperand<0, H16>,
|
|
|
|
|
CheckRegOperand<0, H17>,
|
|
|
|
|
CheckRegOperand<0, H18>,
|
|
|
|
|
CheckRegOperand<0, H19>,
|
|
|
|
|
CheckRegOperand<0, H20>,
|
|
|
|
|
CheckRegOperand<0, H21>,
|
|
|
|
|
CheckRegOperand<0, H22>,
|
|
|
|
|
CheckRegOperand<0, H23>,
|
|
|
|
|
CheckRegOperand<0, H24>,
|
|
|
|
|
CheckRegOperand<0, H25>,
|
|
|
|
|
CheckRegOperand<0, H26>,
|
|
|
|
|
CheckRegOperand<0, H27>,
|
|
|
|
|
CheckRegOperand<0, H28>,
|
|
|
|
|
CheckRegOperand<0, H29>,
|
|
|
|
|
CheckRegOperand<0, H30>,
|
|
|
|
|
CheckRegOperand<0, H31>]>]>;
|
|
|
|
|
|
|
|
|
|
// Identify whether an instruction is the 32-bit NEON form based on its result.
|
|
|
|
|
def CheckSForm : CheckAll<[CheckIsRegOperand<0>,
|
|
|
|
|
CheckAny<[CheckRegOperand<0, S0>,
|
|
|
|
|
CheckRegOperand<0, S1>,
|
|
|
|
|
CheckRegOperand<0, S2>,
|
|
|
|
|
CheckRegOperand<0, S3>,
|
|
|
|
|
CheckRegOperand<0, S4>,
|
|
|
|
|
CheckRegOperand<0, S5>,
|
|
|
|
|
CheckRegOperand<0, S6>,
|
|
|
|
|
CheckRegOperand<0, S7>,
|
|
|
|
|
CheckRegOperand<0, S8>,
|
|
|
|
|
CheckRegOperand<0, S9>,
|
|
|
|
|
CheckRegOperand<0, S10>,
|
|
|
|
|
CheckRegOperand<0, S11>,
|
|
|
|
|
CheckRegOperand<0, S12>,
|
|
|
|
|
CheckRegOperand<0, S13>,
|
|
|
|
|
CheckRegOperand<0, S14>,
|
|
|
|
|
CheckRegOperand<0, S15>,
|
|
|
|
|
CheckRegOperand<0, S16>,
|
|
|
|
|
CheckRegOperand<0, S17>,
|
|
|
|
|
CheckRegOperand<0, S18>,
|
|
|
|
|
CheckRegOperand<0, S19>,
|
|
|
|
|
CheckRegOperand<0, S20>,
|
|
|
|
|
CheckRegOperand<0, S21>,
|
|
|
|
|
CheckRegOperand<0, S22>,
|
|
|
|
|
CheckRegOperand<0, S23>,
|
|
|
|
|
CheckRegOperand<0, S24>,
|
|
|
|
|
CheckRegOperand<0, S25>,
|
|
|
|
|
CheckRegOperand<0, S26>,
|
|
|
|
|
CheckRegOperand<0, S27>,
|
|
|
|
|
CheckRegOperand<0, S28>,
|
|
|
|
|
CheckRegOperand<0, S29>,
|
|
|
|
|
CheckRegOperand<0, S30>,
|
|
|
|
|
CheckRegOperand<0, S31>]>]>;
|
|
|
|
|
|
2018-12-11 00:24:30 +08:00
|
|
|
// Identify whether an instruction is the 64-bit NEON form based on its result.
|
|
|
|
|
def CheckDForm : CheckAll<[CheckIsRegOperand<0>,
|
|
|
|
|
CheckAny<[CheckRegOperand<0, D0>,
|
|
|
|
|
CheckRegOperand<0, D1>,
|
|
|
|
|
CheckRegOperand<0, D2>,
|
|
|
|
|
CheckRegOperand<0, D3>,
|
|
|
|
|
CheckRegOperand<0, D4>,
|
|
|
|
|
CheckRegOperand<0, D5>,
|
|
|
|
|
CheckRegOperand<0, D6>,
|
|
|
|
|
CheckRegOperand<0, D7>,
|
|
|
|
|
CheckRegOperand<0, D8>,
|
|
|
|
|
CheckRegOperand<0, D9>,
|
|
|
|
|
CheckRegOperand<0, D10>,
|
|
|
|
|
CheckRegOperand<0, D11>,
|
|
|
|
|
CheckRegOperand<0, D12>,
|
|
|
|
|
CheckRegOperand<0, D13>,
|
|
|
|
|
CheckRegOperand<0, D14>,
|
|
|
|
|
CheckRegOperand<0, D15>,
|
|
|
|
|
CheckRegOperand<0, D16>,
|
|
|
|
|
CheckRegOperand<0, D17>,
|
|
|
|
|
CheckRegOperand<0, D18>,
|
|
|
|
|
CheckRegOperand<0, D19>,
|
|
|
|
|
CheckRegOperand<0, D20>,
|
|
|
|
|
CheckRegOperand<0, D21>,
|
|
|
|
|
CheckRegOperand<0, D22>,
|
|
|
|
|
CheckRegOperand<0, D23>,
|
|
|
|
|
CheckRegOperand<0, D24>,
|
|
|
|
|
CheckRegOperand<0, D25>,
|
|
|
|
|
CheckRegOperand<0, D26>,
|
|
|
|
|
CheckRegOperand<0, D27>,
|
|
|
|
|
CheckRegOperand<0, D28>,
|
|
|
|
|
CheckRegOperand<0, D29>,
|
|
|
|
|
CheckRegOperand<0, D30>,
|
|
|
|
|
CheckRegOperand<0, D31>]>]>;
|
|
|
|
|
|
|
|
|
|
// Identify whether an instruction is the 128-bit NEON form based on its result.
|
|
|
|
|
def CheckQForm : CheckAll<[CheckIsRegOperand<0>,
|
|
|
|
|
CheckAny<[CheckRegOperand<0, Q0>,
|
|
|
|
|
CheckRegOperand<0, Q1>,
|
|
|
|
|
CheckRegOperand<0, Q2>,
|
|
|
|
|
CheckRegOperand<0, Q3>,
|
|
|
|
|
CheckRegOperand<0, Q4>,
|
|
|
|
|
CheckRegOperand<0, Q5>,
|
|
|
|
|
CheckRegOperand<0, Q6>,
|
|
|
|
|
CheckRegOperand<0, Q7>,
|
|
|
|
|
CheckRegOperand<0, Q8>,
|
|
|
|
|
CheckRegOperand<0, Q9>,
|
|
|
|
|
CheckRegOperand<0, Q10>,
|
|
|
|
|
CheckRegOperand<0, Q11>,
|
|
|
|
|
CheckRegOperand<0, Q12>,
|
|
|
|
|
CheckRegOperand<0, Q13>,
|
|
|
|
|
CheckRegOperand<0, Q14>,
|
|
|
|
|
CheckRegOperand<0, Q15>,
|
|
|
|
|
CheckRegOperand<0, Q16>,
|
|
|
|
|
CheckRegOperand<0, Q17>,
|
|
|
|
|
CheckRegOperand<0, Q18>,
|
|
|
|
|
CheckRegOperand<0, Q19>,
|
|
|
|
|
CheckRegOperand<0, Q20>,
|
|
|
|
|
CheckRegOperand<0, Q21>,
|
|
|
|
|
CheckRegOperand<0, Q22>,
|
|
|
|
|
CheckRegOperand<0, Q23>,
|
|
|
|
|
CheckRegOperand<0, Q24>,
|
|
|
|
|
CheckRegOperand<0, Q25>,
|
|
|
|
|
CheckRegOperand<0, Q26>,
|
|
|
|
|
CheckRegOperand<0, Q27>,
|
|
|
|
|
CheckRegOperand<0, Q28>,
|
|
|
|
|
CheckRegOperand<0, Q29>,
|
|
|
|
|
CheckRegOperand<0, Q30>,
|
|
|
|
|
CheckRegOperand<0, Q31>]>]>;
|
|
|
|
|
|
2018-11-27 05:47:46 +08:00
|
|
|
// Identify arithmetic instructions with extend.
|
2018-12-15 04:04:58 +08:00
|
|
|
def IsArithExtOp : CheckOpcode<[ADDWrx, ADDXrx, ADDSWrx, ADDSXrx,
|
|
|
|
|
SUBWrx, SUBXrx, SUBSWrx, SUBSXrx,
|
|
|
|
|
ADDXrx64, ADDSXrx64,
|
2018-12-11 00:24:30 +08:00
|
|
|
SUBXrx64, SUBSXrx64]>;
|
|
|
|
|
|
|
|
|
|
// Identify arithmetic immediate instructions.
|
|
|
|
|
def IsArithImmOp : CheckOpcode<[ADDWri, ADDXri, ADDSWri, ADDSXri,
|
|
|
|
|
SUBWri, SUBXri, SUBSWri, SUBSXri]>;
|
2018-11-27 05:47:46 +08:00
|
|
|
|
2018-11-27 05:47:41 +08:00
|
|
|
// Identify arithmetic instructions with shift.
|
2018-12-11 00:24:30 +08:00
|
|
|
def IsArithShiftOp : CheckOpcode<[ADDWrs, ADDXrs, ADDSWrs, ADDSXrs,
|
|
|
|
|
SUBWrs, SUBXrs, SUBSWrs, SUBSXrs]>;
|
|
|
|
|
|
|
|
|
|
// Identify arithmetic instructions without shift.
|
|
|
|
|
def IsArithUnshiftOp : CheckOpcode<[ADDWrr, ADDXrr, ADDSWrr, ADDSXrr,
|
|
|
|
|
SUBWrr, SUBXrr, SUBSWrr, SUBSXrr]>;
|
|
|
|
|
|
|
|
|
|
// Identify logic immediate instructions.
|
|
|
|
|
def IsLogicImmOp : CheckOpcode<[ANDWri, ANDXri,
|
|
|
|
|
EORWri, EORXri,
|
|
|
|
|
ORRWri, ORRXri]>;
|
2018-11-27 05:47:41 +08:00
|
|
|
|
|
|
|
|
// Identify logic instructions with shift.
|
2018-12-11 00:24:30 +08:00
|
|
|
def IsLogicShiftOp : CheckOpcode<[ANDWrs, ANDXrs, ANDSWrs, ANDSXrs,
|
|
|
|
|
BICWrs, BICXrs, BICSWrs, BICSXrs,
|
|
|
|
|
EONWrs, EONXrs,
|
|
|
|
|
EORWrs, EORXrs,
|
|
|
|
|
ORNWrs, ORNXrs,
|
|
|
|
|
ORRWrs, ORRXrs]>;
|
|
|
|
|
|
|
|
|
|
// Identify logic instructions without shift.
|
|
|
|
|
def IsLogicUnshiftOp : CheckOpcode<[ANDWrr, ANDXrr, ANDSWrr, ANDSXrr,
|
|
|
|
|
BICWrr, BICXrr, BICSWrr, BICSXrr,
|
|
|
|
|
EONWrr, EONXrr,
|
|
|
|
|
EORWrr, EORXrr,
|
|
|
|
|
ORNWrr, ORNXrr,
|
|
|
|
|
ORRWrr, ORRXrr]>;
|
|
|
|
|
|
|
|
|
|
// Identify arithmetic and logic immediate instructions.
|
|
|
|
|
def IsArithLogicImmOp : CheckOpcode<!listconcat(IsArithImmOp.ValidOpcodes,
|
|
|
|
|
IsLogicImmOp.ValidOpcodes)>;
|
2018-11-27 05:47:41 +08:00
|
|
|
|
|
|
|
|
// Identify arithmetic and logic instructions with shift.
|
2018-12-11 00:24:30 +08:00
|
|
|
def IsArithLogicShiftOp : CheckOpcode<!listconcat(IsArithShiftOp.ValidOpcodes,
|
|
|
|
|
IsLogicShiftOp.ValidOpcodes)>;
|
|
|
|
|
|
|
|
|
|
// Identify arithmetic and logic instructions without shift.
|
|
|
|
|
def IsArithLogicUnshiftOp : CheckOpcode<!listconcat(IsArithUnshiftOp.ValidOpcodes,
|
|
|
|
|
IsLogicUnshiftOp.ValidOpcodes)>;
|
|
|
|
|
|
2019-01-04 01:28:09 +08:00
|
|
|
// Identify whether an instruction is an ASIMD
|
|
|
|
|
// load using the post index addressing mode.
|
|
|
|
|
def IsLoadASIMDPostOp : CheckOpcode<[LD1Onev8b_POST, LD1Onev4h_POST, LD1Onev2s_POST, LD1Onev1d_POST,
|
|
|
|
|
LD1Onev16b_POST, LD1Onev8h_POST, LD1Onev4s_POST, LD1Onev2d_POST,
|
|
|
|
|
LD1Twov8b_POST, LD1Twov4h_POST, LD1Twov2s_POST, LD1Twov1d_POST,
|
|
|
|
|
LD1Twov16b_POST, LD1Twov8h_POST, LD1Twov4s_POST, LD1Twov2d_POST,
|
|
|
|
|
LD1Threev8b_POST, LD1Threev4h_POST, LD1Threev2s_POST, LD1Threev1d_POST,
|
|
|
|
|
LD1Threev16b_POST, LD1Threev8h_POST, LD1Threev4s_POST, LD1Threev2d_POST,
|
|
|
|
|
LD1Fourv8b_POST, LD1Fourv4h_POST, LD1Fourv2s_POST, LD1Fourv1d_POST,
|
|
|
|
|
LD1Fourv16b_POST, LD1Fourv8h_POST, LD1Fourv4s_POST, LD1Fourv2d_POST,
|
|
|
|
|
LD1i8_POST, LD1i16_POST, LD1i32_POST, LD1i64_POST,
|
|
|
|
|
LD1Rv8b_POST, LD1Rv4h_POST, LD1Rv2s_POST, LD1Rv1d_POST,
|
|
|
|
|
LD1Rv16b_POST, LD1Rv8h_POST, LD1Rv4s_POST, LD1Rv2d_POST,
|
|
|
|
|
LD2Twov8b_POST, LD2Twov4h_POST, LD2Twov2s_POST,
|
|
|
|
|
LD2Twov16b_POST, LD2Twov8h_POST, LD2Twov4s_POST, LD2Twov2d_POST,
|
|
|
|
|
LD2i8_POST, LD2i16_POST, LD2i32_POST, LD2i64_POST,
|
|
|
|
|
LD2Rv8b_POST, LD2Rv4h_POST, LD2Rv2s_POST, LD2Rv1d_POST,
|
|
|
|
|
LD2Rv16b_POST, LD2Rv8h_POST, LD2Rv4s_POST, LD2Rv2d_POST,
|
|
|
|
|
LD3Threev8b_POST, LD3Threev4h_POST, LD3Threev2s_POST,
|
|
|
|
|
LD3Threev16b_POST, LD3Threev8h_POST, LD3Threev4s_POST, LD3Threev2d_POST,
|
|
|
|
|
LD3i8_POST, LD3i16_POST, LD3i32_POST, LD3i64_POST,
|
|
|
|
|
LD3Rv8b_POST, LD3Rv4h_POST, LD3Rv2s_POST, LD3Rv1d_POST,
|
|
|
|
|
LD3Rv16b_POST, LD3Rv8h_POST, LD3Rv4s_POST, LD3Rv2d_POST,
|
|
|
|
|
LD4Fourv8b_POST, LD4Fourv4h_POST, LD4Fourv2s_POST,
|
|
|
|
|
LD4Fourv16b_POST, LD4Fourv8h_POST, LD4Fourv4s_POST, LD4Fourv2d_POST,
|
|
|
|
|
LD4i8_POST, LD4i16_POST, LD4i32_POST, LD4i64_POST,
|
|
|
|
|
LD4Rv8b_POST, LD4Rv4h_POST, LD4Rv2s_POST, LD4Rv1d_POST,
|
|
|
|
|
LD4Rv16b_POST, LD4Rv8h_POST, LD4Rv4s_POST, LD4Rv2d_POST]>;
|
|
|
|
|
|
|
|
|
|
// Identify whether an instruction is an ASIMD
|
|
|
|
|
// store using the post index addressing mode.
|
|
|
|
|
def IsStoreASIMDPostOp : CheckOpcode<[ST1Onev8b_POST, ST1Onev4h_POST, ST1Onev2s_POST, ST1Onev1d_POST,
|
|
|
|
|
ST1Onev16b_POST, ST1Onev8h_POST, ST1Onev4s_POST, ST1Onev2d_POST,
|
|
|
|
|
ST1Twov8b_POST, ST1Twov4h_POST, ST1Twov2s_POST, ST1Twov1d_POST,
|
|
|
|
|
ST1Twov16b_POST, ST1Twov8h_POST, ST1Twov4s_POST, ST1Twov2d_POST,
|
|
|
|
|
ST1Threev8b_POST, ST1Threev4h_POST, ST1Threev2s_POST, ST1Threev1d_POST,
|
|
|
|
|
ST1Threev16b_POST, ST1Threev8h_POST, ST1Threev4s_POST, ST1Threev2d_POST,
|
|
|
|
|
ST1Fourv8b_POST, ST1Fourv4h_POST, ST1Fourv2s_POST, ST1Fourv1d_POST,
|
|
|
|
|
ST1Fourv16b_POST, ST1Fourv8h_POST, ST1Fourv4s_POST, ST1Fourv2d_POST,
|
|
|
|
|
ST1i8_POST, ST1i16_POST, ST1i32_POST, ST1i64_POST,
|
|
|
|
|
ST2Twov8b_POST, ST2Twov4h_POST, ST2Twov2s_POST,
|
|
|
|
|
ST2Twov16b_POST, ST2Twov8h_POST, ST2Twov4s_POST, ST2Twov2d_POST,
|
|
|
|
|
ST2i8_POST, ST2i16_POST, ST2i32_POST, ST2i64_POST,
|
|
|
|
|
ST3Threev8b_POST, ST3Threev4h_POST, ST3Threev2s_POST,
|
|
|
|
|
ST3Threev16b_POST, ST3Threev8h_POST, ST3Threev4s_POST, ST3Threev2d_POST,
|
|
|
|
|
ST3i8_POST, ST3i16_POST, ST3i32_POST, ST3i64_POST,
|
|
|
|
|
ST4Fourv8b_POST, ST4Fourv4h_POST, ST4Fourv2s_POST,
|
|
|
|
|
ST4Fourv16b_POST, ST4Fourv8h_POST, ST4Fourv4s_POST, ST4Fourv2d_POST,
|
|
|
|
|
ST4i8_POST, ST4i16_POST, ST4i32_POST, ST4i64_POST]>;
|
|
|
|
|
|
|
|
|
|
// Identify whether an instruction is an ASIMD load
|
|
|
|
|
// or store using the post index addressing mode.
|
|
|
|
|
def IsLoadStoreASIMDPostOp : CheckOpcode<!listconcat(IsLoadASIMDPostOp.ValidOpcodes,
|
|
|
|
|
IsStoreASIMDPostOp.ValidOpcodes)>;
|
|
|
|
|
|
|
|
|
|
// Identify whether an instruction is a load
|
|
|
|
|
// using the register offset addressing mode.
|
|
|
|
|
def IsLoadRegOffsetOp : CheckOpcode<[PRFMroW, PRFMroX,
|
|
|
|
|
LDRBBroW, LDRBBroX,
|
|
|
|
|
LDRSBWroW, LDRSBWroX, LDRSBXroW, LDRSBXroX,
|
|
|
|
|
LDRHHroW, LDRHHroX,
|
|
|
|
|
LDRSHWroW, LDRSHWroX, LDRSHXroW, LDRSHXroX,
|
|
|
|
|
LDRWroW, LDRWroX,
|
|
|
|
|
LDRSWroW, LDRSWroX,
|
|
|
|
|
LDRXroW, LDRXroX,
|
|
|
|
|
LDRBroW, LDRBroX,
|
|
|
|
|
LDRHroW, LDRHroX,
|
|
|
|
|
LDRSroW, LDRSroX,
|
2019-11-13 04:13:30 +08:00
|
|
|
LDRDroW, LDRDroX,
|
|
|
|
|
LDRQroW, LDRQroX]>;
|
2019-01-04 01:28:09 +08:00
|
|
|
|
2019-11-24 02:11:31 +08:00
|
|
|
// Identify whether an instruction is a store
|
2019-01-04 01:28:09 +08:00
|
|
|
// using the register offset addressing mode.
|
|
|
|
|
def IsStoreRegOffsetOp : CheckOpcode<[STRBBroW, STRBBroX,
|
|
|
|
|
STRHHroW, STRHHroX,
|
|
|
|
|
STRWroW, STRWroX,
|
|
|
|
|
STRXroW, STRXroX,
|
|
|
|
|
STRBroW, STRBroX,
|
|
|
|
|
STRHroW, STRHroX,
|
|
|
|
|
STRSroW, STRSroX,
|
2019-11-13 04:13:30 +08:00
|
|
|
STRDroW, STRDroX,
|
|
|
|
|
STRQroW, STRQroX]>;
|
2019-01-04 01:28:09 +08:00
|
|
|
|
|
|
|
|
// Identify whether an instruction is a load or
|
|
|
|
|
// store using the register offset addressing mode.
|
|
|
|
|
def IsLoadStoreRegOffsetOp : CheckOpcode<!listconcat(IsLoadRegOffsetOp.ValidOpcodes,
|
|
|
|
|
IsStoreRegOffsetOp.ValidOpcodes)>;
|
|
|
|
|
|
2018-11-27 05:47:28 +08:00
|
|
|
// Target predicates.
|
|
|
|
|
|
2018-12-11 00:24:30 +08:00
|
|
|
// Identify an instruction that effectively transfers a register to another.
|
|
|
|
|
def IsCopyIdiomFn : TIIPredicate<"isCopyIdiom",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[// MOV {Rd, SP}, {SP, Rn} =>
|
|
|
|
|
// ADD {Rd, SP}, {SP, Rn}, #0
|
|
|
|
|
MCOpcodeSwitchCase<
|
|
|
|
|
[ADDWri, ADDXri],
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckAll<
|
|
|
|
|
[CheckIsRegOperand<0>,
|
|
|
|
|
CheckIsRegOperand<1>,
|
|
|
|
|
CheckAny<
|
|
|
|
|
[CheckRegOperand<0, WSP>,
|
|
|
|
|
CheckRegOperand<0, SP>,
|
|
|
|
|
CheckRegOperand<1, WSP>,
|
|
|
|
|
CheckRegOperand<1, SP>]>,
|
|
|
|
|
CheckZeroOperand<2>]>>>,
|
|
|
|
|
// MOV Rd, Rm =>
|
|
|
|
|
// ORR Rd, ZR, Rm, LSL #0
|
|
|
|
|
MCOpcodeSwitchCase<
|
|
|
|
|
[ORRWrs, ORRXrs],
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckAll<
|
|
|
|
|
[CheckIsRegOperand<1>,
|
|
|
|
|
CheckIsRegOperand<2>,
|
|
|
|
|
CheckAny<
|
|
|
|
|
[CheckRegOperand<1, WZR>,
|
2018-12-20 06:24:31 +08:00
|
|
|
CheckRegOperand<1, XZR>]>,
|
2018-12-11 00:24:30 +08:00
|
|
|
CheckShiftBy0]>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def IsCopyIdiomPred : MCSchedPredicate<IsCopyIdiomFn>;
|
|
|
|
|
|
2018-11-27 05:47:46 +08:00
|
|
|
// Identify arithmetic instructions with an extended register.
|
2018-12-11 00:24:30 +08:00
|
|
|
def RegExtendedFn : TIIPredicate<"hasExtendedReg",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[MCOpcodeSwitchCase<
|
|
|
|
|
IsArithExtOp.ValidOpcodes,
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckNot<CheckZeroOperand<3>>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def RegExtendedPred : MCSchedPredicate<RegExtendedFn>;
|
2018-11-27 05:47:46 +08:00
|
|
|
|
|
|
|
|
// Identify arithmetic and logic instructions with a shifted register.
|
2018-12-11 00:24:30 +08:00
|
|
|
def RegShiftedFn : TIIPredicate<"hasShiftedReg",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[MCOpcodeSwitchCase<
|
|
|
|
|
IsArithLogicShiftOp.ValidOpcodes,
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckNot<CheckZeroOperand<3>>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def RegShiftedPred : MCSchedPredicate<RegShiftedFn>;
|
2018-11-27 05:47:41 +08:00
|
|
|
|
2018-11-27 05:47:28 +08:00
|
|
|
// Identify a load or store using the register offset addressing mode
|
|
|
|
|
// with an extended or scaled register.
|
2018-12-11 00:24:30 +08:00
|
|
|
def ScaledIdxFn : TIIPredicate<"isScaledAddr",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[MCOpcodeSwitchCase<
|
|
|
|
|
IsLoadStoreRegOffsetOp.ValidOpcodes,
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckAny<[CheckNot<CheckMemExtLSL>,
|
|
|
|
|
CheckMemScaled]>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def ScaledIdxPred : MCSchedPredicate<ScaledIdxFn>;
|
|
|
|
|
|
|
|
|
|
// Identify an instruction that effectively resets a FP register to zero.
|
|
|
|
|
def IsZeroFPIdiomFn : TIIPredicate<"isZeroFPIdiom",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[// MOVI Vd, #0
|
|
|
|
|
MCOpcodeSwitchCase<
|
|
|
|
|
[MOVIv8b_ns, MOVIv16b_ns,
|
|
|
|
|
MOVID, MOVIv2d_ns],
|
|
|
|
|
MCReturnStatement<CheckZeroOperand<1>>>,
|
|
|
|
|
// MOVI Vd, #0, LSL #0
|
|
|
|
|
MCOpcodeSwitchCase<
|
|
|
|
|
[MOVIv4i16, MOVIv8i16,
|
|
|
|
|
MOVIv2i32, MOVIv4i32],
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckAll<
|
|
|
|
|
[CheckZeroOperand<1>,
|
|
|
|
|
CheckZeroOperand<2>]>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def IsZeroFPIdiomPred : MCSchedPredicate<IsZeroFPIdiomFn>;
|
|
|
|
|
|
|
|
|
|
// Identify an instruction that effectively resets a GP register to zero.
|
|
|
|
|
def IsZeroIdiomFn : TIIPredicate<"isZeroIdiom",
|
|
|
|
|
MCOpcodeSwitchStatement<
|
|
|
|
|
[// ORR Rd, ZR, #0
|
|
|
|
|
MCOpcodeSwitchCase<
|
|
|
|
|
[ORRWri, ORRXri],
|
|
|
|
|
MCReturnStatement<
|
|
|
|
|
CheckAll<
|
|
|
|
|
[CheckIsRegOperand<1>,
|
|
|
|
|
CheckAny<
|
|
|
|
|
[CheckRegOperand<1, WZR>,
|
|
|
|
|
CheckRegOperand<1, XZR>]>,
|
|
|
|
|
CheckZeroOperand<2>]>>>],
|
|
|
|
|
MCReturnStatement<FalsePred>>>;
|
|
|
|
|
def IsZeroIdiomPred : MCSchedPredicate<IsZeroIdiomFn>;
|
