| //===- HexagonImmediates.td - Hexagon immediate processing -*- tablegen -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illnois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // From IA64's InstrInfo file |
| def s32Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s16Imm : Operand<i32> { |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s12Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s11Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s11_0Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s11_1Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s11_2Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s11_3Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s10Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s9Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s8Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s8Imm64 : Operand<i64> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s6Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s4Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s4_0Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s4_1Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s4_2Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def s4_3Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u64Imm : Operand<i64> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u32Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u16Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u16_0Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u16_1Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u16_2Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u11_3Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u10Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u9Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u8Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u7Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u6Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u6_0Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u6_1Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u6_2Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u6_3Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u5Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u4Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u3Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u2Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def u1Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def n8Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def m6Imm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printImmOperand"; |
| } |
| |
| def nOneImm : Operand<i32> { |
| // For now, we use a generic print function for all operands. |
| let PrintMethod = "printNOneImmOperand"; |
| } |
| |
| // |
| // Immediate predicates |
| // |
| def s32ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<32>(v); |
| }]>; |
| |
| def s32_24ImmPred : PatLeaf<(i32 imm), [{ |
| // s32_24ImmPred predicate - True if the immediate fits in a 32-bit sign |
| // extended field that is a multiple of 0x1000000. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<32,24>(v); |
| }]>; |
| |
| def s32_16s8ImmPred : PatLeaf<(i32 imm), [{ |
| // s32_16s8ImmPred predicate - True if the immediate fits in a 32-bit sign |
| // extended field that is a multiple of 0x10000. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<24,16>(v); |
| }]>; |
| |
| def s16ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<16>(v); |
| }]>; |
| |
| |
| def s13ImmPred : PatLeaf<(i32 imm), [{ |
| // immS13 predicate - True if the immediate fits in a 13-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<13>(v); |
| }]>; |
| |
| |
| def s12ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<12>(v); |
| }]>; |
| |
| def s11_0ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<11>(v); |
| }]>; |
| |
| |
| def s11_1ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<11,1>(v); |
| }]>; |
| |
| |
| def s11_2ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<11,2>(v); |
| }]>; |
| |
| |
| def s11_3ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<11,3>(v); |
| }]>; |
| |
| |
| def s10ImmPred : PatLeaf<(i32 imm), [{ |
| // s10ImmPred predicate - True if the immediate fits in a 10-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<10>(v); |
| }]>; |
| |
| |
| def s9ImmPred : PatLeaf<(i32 imm), [{ |
| // s9ImmPred predicate - True if the immediate fits in a 9-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<9>(v); |
| }]>; |
| |
| |
| def s8ImmPred : PatLeaf<(i32 imm), [{ |
| // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<8>(v); |
| }]>; |
| |
| |
| def s8Imm64Pred : PatLeaf<(i64 imm), [{ |
| // s8ImmPred predicate - True if the immediate fits in a 8-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<8>(v); |
| }]>; |
| |
| |
| def s6ImmPred : PatLeaf<(i32 imm), [{ |
| // s6ImmPred predicate - True if the immediate fits in a 6-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<6>(v); |
| }]>; |
| |
| |
| def s4_0ImmPred : PatLeaf<(i32 imm), [{ |
| // s4_0ImmPred predicate - True if the immediate fits in a 4-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<4>(v); |
| }]>; |
| |
| |
| def s4_1ImmPred : PatLeaf<(i32 imm), [{ |
| // s4_1ImmPred predicate - True if the immediate fits in a 4-bit sign extended |
| // field of 2. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<4,1>(v); |
| }]>; |
| |
| |
| def s4_2ImmPred : PatLeaf<(i32 imm), [{ |
| // s4_2ImmPred predicate - True if the immediate fits in a 4-bit sign extended |
| // field that is a multiple of 4. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<4,2>(v); |
| }]>; |
| |
| |
| def s4_3ImmPred : PatLeaf<(i32 imm), [{ |
| // s4_3ImmPred predicate - True if the immediate fits in a 4-bit sign extended |
| // field that is a multiple of 8. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedInt<4,3>(v); |
| }]>; |
| |
| |
| def u64ImmPred : PatLeaf<(i64 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| // Adding "N ||" to supress gcc unused warning. |
| return (N || true); |
| }]>; |
| |
| def u32ImmPred : PatLeaf<(i32 imm), [{ |
| // immS16 predicate - True if the immediate fits in a 16-bit sign extended |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<32>(v); |
| }]>; |
| |
| def u16ImmPred : PatLeaf<(i32 imm), [{ |
| // u16ImmPred predicate - True if the immediate fits in a 16-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<16>(v); |
| }]>; |
| |
| def u16_s8ImmPred : PatLeaf<(i32 imm), [{ |
| // u16_s8ImmPred predicate - True if the immediate fits in a 16-bit sign |
| // extended s8 field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedUInt<16,8>(v); |
| }]>; |
| |
| def u9ImmPred : PatLeaf<(i32 imm), [{ |
| // u9ImmPred predicate - True if the immediate fits in a 9-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<9>(v); |
| }]>; |
| |
| |
| def u8ImmPred : PatLeaf<(i32 imm), [{ |
| // u8ImmPred predicate - True if the immediate fits in a 8-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<8>(v); |
| }]>; |
| |
| def u7ImmPred : PatLeaf<(i32 imm), [{ |
| // u7ImmPred predicate - True if the immediate fits in a 8-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<7>(v); |
| }]>; |
| |
| |
| def u6ImmPred : PatLeaf<(i32 imm), [{ |
| // u6ImmPred predicate - True if the immediate fits in a 6-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<6>(v); |
| }]>; |
| |
| def u6_0ImmPred : PatLeaf<(i32 imm), [{ |
| // u6_0ImmPred predicate - True if the immediate fits in a 6-bit unsigned |
| // field. Same as u6ImmPred. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<6>(v); |
| }]>; |
| |
| def u6_1ImmPred : PatLeaf<(i32 imm), [{ |
| // u6_1ImmPred predicate - True if the immediate fits in a 6-bit unsigned |
| // field that is 1 bit alinged - multiple of 2. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedUInt<6,1>(v); |
| }]>; |
| |
| def u6_2ImmPred : PatLeaf<(i32 imm), [{ |
| // u6_2ImmPred predicate - True if the immediate fits in a 6-bit unsigned |
| // field that is 2 bits alinged - multiple of 4. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedUInt<6,2>(v); |
| }]>; |
| |
| def u6_3ImmPred : PatLeaf<(i32 imm), [{ |
| // u6_3ImmPred predicate - True if the immediate fits in a 6-bit unsigned |
| // field that is 3 bits alinged - multiple of 8. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isShiftedUInt<6,3>(v); |
| }]>; |
| |
| def u5ImmPred : PatLeaf<(i32 imm), [{ |
| // u5ImmPred predicate - True if the immediate fits in a 5-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<5>(v); |
| }]>; |
| |
| |
| def u3ImmPred : PatLeaf<(i32 imm), [{ |
| // u3ImmPred predicate - True if the immediate fits in a 3-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<3>(v); |
| }]>; |
| |
| |
| def u2ImmPred : PatLeaf<(i32 imm), [{ |
| // u2ImmPred predicate - True if the immediate fits in a 2-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<2>(v); |
| }]>; |
| |
| |
| def u1ImmPred : PatLeaf<(i1 imm), [{ |
| // u1ImmPred predicate - True if the immediate fits in a 1-bit unsigned |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isUInt<1>(v); |
| }]>; |
| |
| def m6ImmPred : PatLeaf<(i32 imm), [{ |
| // m6ImmPred predicate - True if the immediate is negative and fits in |
| // a 6-bit negative number. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return isInt<6>(v); |
| }]>; |
| |
| //InN means negative integers in [-(2^N - 1), 0] |
| def n8ImmPred : PatLeaf<(i32 imm), [{ |
| // n8ImmPred predicate - True if the immediate fits in a 8-bit signed |
| // field. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return (-255 <= v && v <= 0); |
| }]>; |
| |
| def nOneImmPred : PatLeaf<(i32 imm), [{ |
| // nOneImmPred predicate - True if the immediate is -1. |
| int64_t v = (int64_t)N->getSExtValue(); |
| return (-1 == v); |
| }]>; |
| |