mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
1425 lines
45 KiB
TableGen
1425 lines
45 KiB
TableGen
//===-- GenericOpcodes.td - Opcodes used with GlobalISel ---*- tablegen -*-===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the generic opcodes used with GlobalISel.
|
|
// After instruction selection, these opcodes should not appear.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Unary ops.
|
|
//------------------------------------------------------------------------------
|
|
|
|
class GenericInstruction : StandardPseudoInstruction {
|
|
let isPreISelOpcode = true;
|
|
}
|
|
|
|
// Provide a variant of an instruction with the same operands, but
|
|
// different instruction flags. This is intended to provide a
|
|
// convenient way to define strict floating point variants of ordinary
|
|
// floating point instructions.
|
|
class ConstrainedIntruction<GenericInstruction baseInst> :
|
|
GenericInstruction {
|
|
let OutOperandList = baseInst.OutOperandList;
|
|
let InOperandList = baseInst.InOperandList;
|
|
let isCommutable = baseInst.isCommutable;
|
|
|
|
// TODO: Do we need a better way to mark reads from FP mode than
|
|
// hasSideEffects?
|
|
let hasSideEffects = true;
|
|
let mayRaiseFPException = true;
|
|
}
|
|
|
|
// Extend the underlying scalar type of an operation, leaving the high bits
|
|
// unspecified.
|
|
def G_ANYEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Sign extend the underlying scalar type of an operation, copying the sign bit
|
|
// into the newly-created space.
|
|
def G_SEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Sign extend the a value from an arbitrary bit position, copying the sign bit
|
|
// into all bits above it. This is equivalent to a shl + ashr pair with an
|
|
// appropriate shift amount. $sz is an immediate (MachineOperand::isImm()
|
|
// returns true) to allow targets to have some bitwidths legal and others
|
|
// lowered. This opcode is particularly useful if the target has sign-extension
|
|
// instructions that are cheaper than the constituent shifts as the optimizer is
|
|
// able to make decisions on whether it's better to hang on to the G_SEXT_INREG
|
|
// or to lower it and optimize the individual shifts.
|
|
def G_SEXT_INREG : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, untyped_imm_0:$sz);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Zero extend the underlying scalar type of an operation, putting zero bits
|
|
// into the newly-created space.
|
|
def G_ZEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
|
|
// Truncate the underlying scalar type of an operation. This is equivalent to
|
|
// G_EXTRACT for scalar types, but acts elementwise on vectors.
|
|
def G_TRUNC : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_IMPLICIT_DEF : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_PHI : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins variable_ops);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FRAME_INDEX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_GLOBAL_VALUE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_INTTOPTR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_PTRTOINT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_BITCAST : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Only supports scalar result types
|
|
def G_CONSTANT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$imm);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Only supports scalar result types
|
|
def G_FCONSTANT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$imm);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_VASTART : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins type0:$list);
|
|
let hasSideEffects = false;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_VAARG : GenericInstruction {
|
|
let OutOperandList = (outs type0:$val);
|
|
let InOperandList = (ins type1:$list, unknown:$align);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_CTLZ : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_CTLZ_ZERO_UNDEF : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_CTTZ : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_CTTZ_ZERO_UNDEF : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_CTPOP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_BSWAP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_BITREVERSE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_ADDRSPACE_CAST : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_BLOCK_ADDR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$ba);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_JUMP_TABLE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$jti);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_DYN_STACKALLOC : GenericInstruction {
|
|
let OutOperandList = (outs ptype0:$dst);
|
|
let InOperandList = (ins type1:$size, i32imm:$align);
|
|
let hasSideEffects = true;
|
|
}
|
|
|
|
def G_FREEZE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Binary ops.
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic addition.
|
|
def G_ADD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic subtraction.
|
|
def G_SUB : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic multiplication.
|
|
def G_MUL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic signed division.
|
|
def G_SDIV : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic unsigned division.
|
|
def G_UDIV : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic signed remainder.
|
|
def G_SREM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic unsigned remainder.
|
|
def G_UREM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic signed division and remainder.
|
|
def G_SDIVREM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$div, type0:$rem);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic unsigned division and remainder.
|
|
def G_UDIVREM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$div, type0:$rem);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic bitwise and.
|
|
def G_AND : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic bitwise or.
|
|
def G_OR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic bitwise xor.
|
|
def G_XOR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic left-shift.
|
|
def G_SHL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic logical right-shift.
|
|
def G_LSHR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic arithmetic right-shift.
|
|
def G_ASHR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
|
|
/// fshl(X,Y,Z): (X << (Z % bitwidth)) | (Y >> (bitwidth - (Z % bitwidth)))
|
|
def G_FSHL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$src3);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Funnel 'double' shifts take 3 operands, 2 inputs and the shift amount.
|
|
/// fshr(X,Y,Z): (X << (bitwidth - (Z % bitwidth))) | (Y >> (Z % bitwidth))
|
|
def G_FSHR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$src3);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Rotate bits right.
|
|
def G_ROTR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Rotate bits left.
|
|
def G_ROTL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic integer comparison.
|
|
def G_ICMP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic floating-point comparison.
|
|
def G_FCMP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$tst, type1:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic select
|
|
def G_SELECT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$tst, type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic pointer offset.
|
|
def G_PTR_ADD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic pointer mask. type1 should be an integer with the same
|
|
// bitwidth as the pointer type.
|
|
def G_PTRMASK : GenericInstruction {
|
|
let OutOperandList = (outs ptype0:$dst);
|
|
let InOperandList = (ins ptype0:$src, type1:$bits);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic signed integer minimum.
|
|
def G_SMIN : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic signed integer maximum.
|
|
def G_SMAX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic unsigned integer minimum.
|
|
def G_UMIN : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic unsigned integer maximum.
|
|
def G_UMAX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic integer absolute value.
|
|
def G_ABS : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Overflow ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic unsigned addition producing a carry flag.
|
|
def G_UADDO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic unsigned addition consuming and producing a carry flag.
|
|
def G_UADDE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic signed addition producing a carry flag.
|
|
def G_SADDO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic signed addition consuming and producing a carry flag.
|
|
def G_SADDE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic unsigned subtraction producing a carry flag.
|
|
def G_USUBO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
// Generic unsigned subtraction consuming and producing a carry flag.
|
|
def G_USUBE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic signed subtraction producing a carry flag.
|
|
def G_SSUBO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic signed subtraction consuming and producing a carry flag.
|
|
def G_SSUBE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type1:$carry_in);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic unsigned multiplication producing a carry flag.
|
|
def G_UMULO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic signed multiplication producing a carry flag.
|
|
def G_SMULO : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, type1:$carry_out);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Multiply two numbers at twice the incoming bit width (unsigned) and return
|
|
// the high half of the result.
|
|
def G_UMULH : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Multiply two numbers at twice the incoming bit width (signed) and return
|
|
// the high half of the result.
|
|
def G_SMULH : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Saturating ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic saturating unsigned addition.
|
|
def G_UADDSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic saturating signed addition.
|
|
def G_SADDSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic saturating unsigned subtraction.
|
|
def G_USUBSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic saturating signed subtraction.
|
|
def G_SSUBSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic saturating unsigned left shift.
|
|
def G_USHLSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic saturating signed left shift.
|
|
def G_SSHLSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type1:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
/// RESULT = [US]MULFIX(LHS, RHS, SCALE) - Perform fixed point
|
|
/// multiplication on 2 integers with the same width and scale. SCALE
|
|
/// represents the scale of both operands as fixed point numbers. This
|
|
/// SCALE parameter must be a constant integer. A scale of zero is
|
|
/// effectively performing multiplication on 2 integers.
|
|
def G_SMULFIX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
def G_UMULFIX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
/// Same as the corresponding unsaturated fixed point instructions, but the
|
|
/// result is clamped between the min and max values representable by the
|
|
/// bits of the first 2 operands.
|
|
def G_SMULFIXSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
def G_UMULFIXSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
/// RESULT = [US]DIVFIX(LHS, RHS, SCALE) - Perform fixed point division on
|
|
/// 2 integers with the same width and scale. SCALE represents the scale
|
|
/// of both operands as fixed point numbers. This SCALE parameter must be a
|
|
/// constant integer.
|
|
def G_SDIVFIX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
def G_UDIVFIX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
/// Same as the corresponding unsaturated fixed point instructions,
|
|
/// but the result is clamped between the min and max values
|
|
/// representable by the bits of the first 2 operands.
|
|
def G_SDIVFIXSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
def G_UDIVFIXSAT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type0:$src1, untyped_imm_0:$scale);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating Point Unary Ops.
|
|
//------------------------------------------------------------------------------
|
|
|
|
def G_FNEG : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FPEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FPTRUNC : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FPTOSI : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FPTOUI : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_SITOFP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_UITOFP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FABS : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FCOPYSIGN : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type1:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_FCANONICALIZE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// FMINNUM/FMAXNUM - Perform floating-point minimum or maximum on two
|
|
// values.
|
|
//
|
|
// In the case where a single input is a NaN (either signaling or quiet),
|
|
// the non-NaN input is returned.
|
|
//
|
|
// The return value of (FMINNUM 0.0, -0.0) could be either 0.0 or -0.0.
|
|
def G_FMINNUM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
def G_FMAXNUM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// FMINNUM_IEEE/FMAXNUM_IEEE - Perform floating-point minimum or maximum on
|
|
// two values, following the IEEE-754 2008 definition. This differs from
|
|
// FMINNUM/FMAXNUM in the handling of signaling NaNs. If one input is a
|
|
// signaling NaN, returns a quiet NaN.
|
|
def G_FMINNUM_IEEE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
def G_FMAXNUM_IEEE : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// FMINIMUM/FMAXIMUM - NaN-propagating minimum/maximum that also treat -0.0
|
|
// as less than 0.0. While FMINNUM_IEEE/FMAXNUM_IEEE follow IEEE 754-2008
|
|
// semantics, FMINIMUM/FMAXIMUM follow IEEE 754-2018 draft semantics.
|
|
def G_FMINIMUM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
def G_FMAXIMUM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Floating Point Binary ops.
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic FP addition.
|
|
def G_FADD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic FP subtraction.
|
|
def G_FSUB : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic FP multiplication.
|
|
def G_FMUL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
let isCommutable = true;
|
|
}
|
|
|
|
// Generic fused multiply-add instruction.
|
|
// Behaves like llvm fma intrinsic ie src1 * src2 + src3
|
|
def G_FMA : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type0:$src3);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
/// Generic FP multiply and add. Perform a * b + c, while getting the
|
|
/// same result as the separately rounded operations, unlike G_FMA.
|
|
def G_FMAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2, type0:$src3);
|
|
let hasSideEffects = false;
|
|
let isCommutable = false;
|
|
}
|
|
|
|
// Generic FP division.
|
|
def G_FDIV : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic FP remainder.
|
|
def G_FREM : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point exponentiation.
|
|
def G_FPOW : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1, type0:$src2);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point exponentiation, with an integer power.
|
|
def G_FPOWI : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src0, type1:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point base-e exponential of a value.
|
|
def G_FEXP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point base-2 exponential of a value.
|
|
def G_FEXP2 : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point base-e logarithm of a value.
|
|
def G_FLOG : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point base-2 logarithm of a value.
|
|
def G_FLOG2 : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point base-10 logarithm of a value.
|
|
def G_FLOG10 : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point ceiling of a value.
|
|
def G_FCEIL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point cosine of a value.
|
|
def G_FCOS : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point sine of a value.
|
|
def G_FSIN : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point square root of a value.
|
|
// This returns NaN for negative nonzero values.
|
|
// NOTE: Unlike libm sqrt(), this never sets errno. In all other respects it's
|
|
// libm-conformant.
|
|
def G_FSQRT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point floor of a value.
|
|
def G_FFLOOR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point round to next integer.
|
|
def G_FRINT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Floating point round to the nearest integer.
|
|
def G_FNEARBYINT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Opcodes for LLVM Intrinsics
|
|
//------------------------------------------------------------------------------
|
|
def G_INTRINSIC_TRUNC : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_INTRINSIC_ROUND : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_INTRINSIC_LRINT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_INTRINSIC_ROUNDEVEN : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_READCYCLECOUNTER : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins);
|
|
let hasSideEffects = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Memory ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic load. Expects a MachineMemOperand in addition to explicit
|
|
// operands. If the result size is larger than the memory size, the
|
|
// high bits are undefined. If the result is a vector type and larger
|
|
// than the memory size, the high elements are undefined (i.e. this is
|
|
// not a per-element, vector anyextload)
|
|
def G_LOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins ptype1:$addr);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Generic sign-extended load. Expects a MachineMemOperand in addition to explicit operands.
|
|
def G_SEXTLOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins ptype1:$addr);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Generic zero-extended load. Expects a MachineMemOperand in addition to explicit operands.
|
|
def G_ZEXTLOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins ptype1:$addr);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Generic indexed load. Combines a GEP with a load. $newaddr is set to $base + $offset.
|
|
// If $am is 0 (post-indexed), then the value is loaded from $base; if $am is 1 (pre-indexed)
|
|
// then the value is loaded from $newaddr.
|
|
def G_INDEXED_LOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
|
|
let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Same as G_INDEXED_LOAD except that the load performed is sign-extending, as with G_SEXTLOAD.
|
|
def G_INDEXED_SEXTLOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
|
|
let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Same as G_INDEXED_LOAD except that the load performed is zero-extending, as with G_ZEXTLOAD.
|
|
def G_INDEXED_ZEXTLOAD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst, ptype1:$newaddr);
|
|
let InOperandList = (ins ptype1:$base, type2:$offset, unknown:$am);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
}
|
|
|
|
// Generic store. Expects a MachineMemOperand in addition to explicit operands.
|
|
def G_STORE : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins type0:$src, ptype1:$addr);
|
|
let hasSideEffects = false;
|
|
let mayStore = true;
|
|
}
|
|
|
|
// Combines a store with a GEP. See description of G_INDEXED_LOAD for indexing behaviour.
|
|
def G_INDEXED_STORE : GenericInstruction {
|
|
let OutOperandList = (outs ptype0:$newaddr);
|
|
let InOperandList = (ins type1:$src, ptype0:$base, ptype2:$offset,
|
|
unknown:$am);
|
|
let hasSideEffects = false;
|
|
let mayStore = true;
|
|
}
|
|
|
|
// Generic atomic cmpxchg with internal success check. Expects a
|
|
// MachineMemOperand in addition to explicit operands.
|
|
def G_ATOMIC_CMPXCHG_WITH_SUCCESS : GenericInstruction {
|
|
let OutOperandList = (outs type0:$oldval, type1:$success);
|
|
let InOperandList = (ins type2:$addr, type0:$cmpval, type0:$newval);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
// Generic atomic cmpxchg. Expects a MachineMemOperand in addition to explicit
|
|
// operands.
|
|
def G_ATOMIC_CMPXCHG : GenericInstruction {
|
|
let OutOperandList = (outs type0:$oldval);
|
|
let InOperandList = (ins ptype1:$addr, type0:$cmpval, type0:$newval);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
// Generic atomicrmw. Expects a MachineMemOperand in addition to explicit
|
|
// operands.
|
|
class G_ATOMICRMW_OP : GenericInstruction {
|
|
let OutOperandList = (outs type0:$oldval);
|
|
let InOperandList = (ins ptype1:$addr, type0:$val);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_ATOMICRMW_XCHG : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_ADD : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_SUB : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_AND : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_NAND : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_OR : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_XOR : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_MAX : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_MIN : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_UMAX : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_UMIN : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_FADD : G_ATOMICRMW_OP;
|
|
def G_ATOMICRMW_FSUB : G_ATOMICRMW_OP;
|
|
|
|
def G_FENCE : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins i32imm:$ordering, i32imm:$scope);
|
|
let hasSideEffects = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Variadic ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Extract a register of the specified size, starting from the block given by
|
|
// index. This will almost certainly be mapped to sub-register COPYs after
|
|
// register banks have been selected.
|
|
def G_EXTRACT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$res);
|
|
let InOperandList = (ins type1:$src, untyped_imm_0:$offset);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Extract multiple registers specified size, starting from blocks given by
|
|
// indexes. This will almost certainly be mapped to sub-register COPYs after
|
|
// register banks have been selected.
|
|
// The output operands are always ordered from lowest bits to highest:
|
|
// %bits_0_7:(s8), %bits_8_15:(s8),
|
|
// %bits_16_23:(s8), %bits_24_31:(s8) = G_UNMERGE_VALUES %0:(s32)
|
|
def G_UNMERGE_VALUES : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst0, variable_ops);
|
|
let InOperandList = (ins type1:$src);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Insert a smaller register into a larger one at the specified bit-index.
|
|
def G_INSERT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, type1:$op, untyped_imm_0:$offset);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Concatenate multiple registers of the same size into a wider register.
|
|
// The input operands are always ordered from lowest bits to highest:
|
|
// %0:(s32) = G_MERGE_VALUES %bits_0_7:(s8), %bits_8_15:(s8),
|
|
// %bits_16_23:(s8), %bits_24_31:(s8)
|
|
def G_MERGE_VALUES : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src0, variable_ops);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Create a vector from multiple scalar registers. No implicit
|
|
/// conversion is performed (i.e. the result element type must be the
|
|
/// same as all source operands)
|
|
def G_BUILD_VECTOR : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src0, variable_ops);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Like G_BUILD_VECTOR, but truncates the larger operand types to fit the
|
|
/// destination vector elt type.
|
|
def G_BUILD_VECTOR_TRUNC : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src0, variable_ops);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
/// Create a vector by concatenating vectors together.
|
|
def G_CONCAT_VECTORS : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src0, variable_ops);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Intrinsic without side effects.
|
|
def G_INTRINSIC : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins unknown:$intrin, variable_ops);
|
|
let hasSideEffects = false;
|
|
|
|
// Conservatively assume this is convergent. If there turnes out to
|
|
// be a need, there should be separate convergent intrinsic opcodes.
|
|
let isConvergent = 1;
|
|
}
|
|
|
|
// Intrinsic with side effects.
|
|
def G_INTRINSIC_W_SIDE_EFFECTS : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins unknown:$intrin, variable_ops);
|
|
let hasSideEffects = true;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
|
|
// Conservatively assume this is convergent. If there turnes out to
|
|
// be a need, there should be separate convergent intrinsic opcodes.
|
|
let isConvergent = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Branches.
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic unconditional branch.
|
|
def G_BR : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins unknown:$src1);
|
|
let hasSideEffects = false;
|
|
let isBranch = true;
|
|
let isTerminator = true;
|
|
let isBarrier = true;
|
|
}
|
|
|
|
// Generic conditional branch.
|
|
def G_BRCOND : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins type0:$tst, unknown:$truebb);
|
|
let hasSideEffects = false;
|
|
let isBranch = true;
|
|
let isTerminator = true;
|
|
}
|
|
|
|
// Generic indirect branch.
|
|
def G_BRINDIRECT : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins type0:$src1);
|
|
let hasSideEffects = false;
|
|
let isBranch = true;
|
|
let isTerminator = true;
|
|
let isBarrier = true;
|
|
let isIndirectBranch = true;
|
|
}
|
|
|
|
// Generic branch to jump table entry
|
|
def G_BRJT : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$tbl, unknown:$jti, type1:$idx);
|
|
let hasSideEffects = false;
|
|
let isBranch = true;
|
|
let isTerminator = true;
|
|
let isBarrier = true;
|
|
let isIndirectBranch = true;
|
|
}
|
|
|
|
def G_READ_REGISTER : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins unknown:$register);
|
|
let hasSideEffects = true;
|
|
|
|
// Assume convergent. It's probably not worth the effort of somehow
|
|
// modeling convergent and nonconvergent register accesses.
|
|
let isConvergent = true;
|
|
}
|
|
|
|
def G_WRITE_REGISTER : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins unknown:$register, type0:$value);
|
|
let hasSideEffects = true;
|
|
|
|
// Assume convergent. It's probably not worth the effort of somehow
|
|
// modeling convergent and nonconvergent register accesses.
|
|
let isConvergent = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Vector ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic insertelement.
|
|
def G_INSERT_VECTOR_ELT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, type1:$elt, type2:$idx);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic extractelement.
|
|
def G_EXTRACT_VECTOR_ELT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$src, type2:$idx);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic shufflevector.
|
|
//
|
|
// The mask operand should be an IR Constant which exactly matches the
|
|
// corresponding mask for the IR shufflevector instruction.
|
|
def G_SHUFFLE_VECTOR: GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$v1, type1:$v2, unknown:$mask);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Vector reductions
|
|
//------------------------------------------------------------------------------
|
|
|
|
class VectorReduction : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$v);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_VECREDUCE_SEQ_FADD : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$acc, type2:$v);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_VECREDUCE_SEQ_FMUL : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type1:$acc, type2:$v);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
def G_VECREDUCE_FADD : VectorReduction;
|
|
def G_VECREDUCE_FMUL : VectorReduction;
|
|
|
|
def G_VECREDUCE_FMAX : VectorReduction;
|
|
def G_VECREDUCE_FMIN : VectorReduction;
|
|
|
|
def G_VECREDUCE_ADD : VectorReduction;
|
|
def G_VECREDUCE_MUL : VectorReduction;
|
|
def G_VECREDUCE_AND : VectorReduction;
|
|
def G_VECREDUCE_OR : VectorReduction;
|
|
def G_VECREDUCE_XOR : VectorReduction;
|
|
def G_VECREDUCE_SMAX : VectorReduction;
|
|
def G_VECREDUCE_SMIN : VectorReduction;
|
|
def G_VECREDUCE_UMAX : VectorReduction;
|
|
def G_VECREDUCE_UMIN : VectorReduction;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Constrained floating point ops
|
|
//------------------------------------------------------------------------------
|
|
|
|
def G_STRICT_FADD : ConstrainedIntruction<G_FADD>;
|
|
def G_STRICT_FSUB : ConstrainedIntruction<G_FSUB>;
|
|
def G_STRICT_FMUL : ConstrainedIntruction<G_FMUL>;
|
|
def G_STRICT_FDIV : ConstrainedIntruction<G_FDIV>;
|
|
def G_STRICT_FREM : ConstrainedIntruction<G_FREM>;
|
|
def G_STRICT_FMA : ConstrainedIntruction<G_FMA>;
|
|
def G_STRICT_FSQRT : ConstrainedIntruction<G_FSQRT>;
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Memory intrinsics
|
|
//------------------------------------------------------------------------------
|
|
|
|
def G_MEMCPY : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$dst_addr, ptype1:$src_addr, type2:$size, untyped_imm_0:$tailcall);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_MEMCPY_INLINE : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$dst_addr, ptype1:$src_addr, type2:$size);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_MEMMOVE : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$dst_addr, ptype1:$src_addr, type2:$size, untyped_imm_0:$tailcall);
|
|
let hasSideEffects = false;
|
|
let mayLoad = true;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_MEMSET : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$dst_addr, type1:$value, type2:$size, untyped_imm_0:$tailcall);
|
|
let hasSideEffects = false;
|
|
let mayStore = true;
|
|
}
|
|
|
|
def G_BZERO : GenericInstruction {
|
|
let OutOperandList = (outs);
|
|
let InOperandList = (ins ptype0:$dst_addr, type1:$size, untyped_imm_0:$tailcall);
|
|
let hasSideEffects = false;
|
|
let mayStore = true;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Bitfield extraction.
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Generic signed bitfield extraction. The operands are in the range
|
|
// 0 <= lsb < lsb + width <= src bitwidth, where all values are unsigned.
|
|
def G_SBFX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, type1:$lsb, type1:$width);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Generic unsigned bitfield extraction. The operands are in the range
|
|
// 0 <= lsb < lsb + width <= src bitwidth, where all values are unsigned.
|
|
def G_UBFX : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, type1:$lsb, type1:$width);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Optimization hints
|
|
//------------------------------------------------------------------------------
|
|
|
|
// Asserts that an operation has already been zero-extended from a specific
|
|
// type.
|
|
def G_ASSERT_ZEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, untyped_imm_0:$sz);
|
|
let hasSideEffects = false;
|
|
}
|
|
|
|
// Asserts that an operation has already been sign-extended from a specific
|
|
// type.
|
|
def G_ASSERT_SEXT : GenericInstruction {
|
|
let OutOperandList = (outs type0:$dst);
|
|
let InOperandList = (ins type0:$src, untyped_imm_0:$sz);
|
|
let hasSideEffects = false;
|
|
}
|