2004-08-01 03:23:34 +00:00
|
|
|
//===- Target.td - Target Independent TableGen interface ---*- tablegen -*-===//
|
2011-02-10 19:56:23 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2011-02-10 19:56:23 +00:00
|
|
|
//
|
2003-10-21 15:17:13 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-07-29 23:07:13 +00:00
|
|
|
//
|
|
|
|
// This file defines the target-independent interfaces which should be
|
|
|
|
// implemented by each target which is using a TableGen based code generator.
|
|
|
|
//
|
2003-05-29 18:48:17 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-03-24 18:52:35 +00:00
|
|
|
// Include all information about LLVM intrinsics.
|
|
|
|
include "llvm/Intrinsics.td"
|
2003-07-30 05:50:12 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Register file description - These classes are used to fill in the target
|
2005-10-04 05:09:20 +00:00
|
|
|
// description classes.
|
2003-07-30 05:50:12 +00:00
|
|
|
|
2005-10-04 05:09:20 +00:00
|
|
|
class RegisterClass; // Forward def
|
2003-07-30 05:50:12 +00:00
|
|
|
|
2010-05-25 19:49:33 +00:00
|
|
|
// SubRegIndex - Use instances of SubRegIndex to identify subregisters.
|
2012-02-01 23:16:41 +00:00
|
|
|
class SubRegIndex<list<SubRegIndex> comps = []> {
|
2010-05-24 14:48:12 +00:00
|
|
|
string Namespace = "";
|
2012-02-01 23:16:41 +00:00
|
|
|
|
|
|
|
// ComposedOf - A list of two SubRegIndex instances, [A, B].
|
|
|
|
// This indicates that this SubRegIndex is the result of composing A and B.
|
|
|
|
list<SubRegIndex> ComposedOf = comps;
|
2010-05-24 14:48:12 +00:00
|
|
|
}
|
|
|
|
|
2011-06-27 21:06:21 +00:00
|
|
|
// RegAltNameIndex - The alternate name set to use for register operands of
|
|
|
|
// this register class when printing.
|
|
|
|
class RegAltNameIndex {
|
|
|
|
string Namespace = "";
|
|
|
|
}
|
|
|
|
def NoRegAltName : RegAltNameIndex;
|
|
|
|
|
2004-09-14 04:17:02 +00:00
|
|
|
// Register - You should define one instance of this class for each register
|
|
|
|
// in the target machine. String n will become the "name" of the register.
|
2011-06-27 21:06:21 +00:00
|
|
|
class Register<string n, list<string> altNames = []> {
|
2003-05-29 18:48:17 +00:00
|
|
|
string Namespace = "";
|
2008-02-26 21:11:01 +00:00
|
|
|
string AsmName = n;
|
2011-06-27 21:06:21 +00:00
|
|
|
list<string> AltNames = altNames;
|
2004-08-21 02:17:39 +00:00
|
|
|
|
2005-09-30 04:13:23 +00:00
|
|
|
// Aliases - A list of registers that this register overlaps with. A read or
|
2007-02-20 20:52:03 +00:00
|
|
|
// modification of this register can potentially read or modify the aliased
|
2005-09-30 04:13:23 +00:00
|
|
|
// registers.
|
|
|
|
list<Register> Aliases = [];
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2007-04-20 21:13:46 +00:00
|
|
|
// SubRegs - A list of registers that are parts of this register. Note these
|
|
|
|
// are "immediate" sub-registers and the registers within the list do not
|
|
|
|
// themselves overlap. e.g. For X86, EAX's SubRegs list contains only [AX],
|
|
|
|
// not [AX, AH, AL].
|
|
|
|
list<Register> SubRegs = [];
|
|
|
|
|
2010-05-26 17:27:12 +00:00
|
|
|
// SubRegIndices - For each register in SubRegs, specify the SubRegIndex used
|
|
|
|
// to address it. Sub-sub-register indices are automatically inherited from
|
|
|
|
// SubRegs.
|
|
|
|
list<SubRegIndex> SubRegIndices = [];
|
|
|
|
|
2011-06-27 21:06:21 +00:00
|
|
|
// RegAltNameIndices - The alternate name indices which are valid for this
|
|
|
|
// register.
|
|
|
|
list<RegAltNameIndex> RegAltNameIndices = [];
|
|
|
|
|
2010-05-26 17:27:12 +00:00
|
|
|
// CompositeIndices - Specify subreg indices that don't correspond directly to
|
|
|
|
// a register in SubRegs and are not inherited. The following formats are
|
|
|
|
// supported:
|
|
|
|
//
|
|
|
|
// (a) Identity - Reg:a == Reg
|
|
|
|
// (a b) Alias - Reg:a == Reg:b
|
|
|
|
// (a b,c) Composite - Reg:a == (Reg:b):c
|
|
|
|
//
|
|
|
|
// This can be used to disambiguate a sub-sub-register that exists in more
|
|
|
|
// than one subregister and other weird stuff.
|
|
|
|
list<dag> CompositeIndices = [];
|
|
|
|
|
2007-11-11 19:50:10 +00:00
|
|
|
// DwarfNumbers - Numbers used internally by gcc/gdb to identify the register.
|
2006-03-24 21:13:21 +00:00
|
|
|
// These values can be determined by locating the <target>.h file in the
|
|
|
|
// directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES. The
|
|
|
|
// order of these names correspond to the enumeration used by gcc. A value of
|
2007-11-11 19:53:50 +00:00
|
|
|
// -1 indicates that the gcc number is undefined and -2 that register number
|
|
|
|
// is invalid for this mode/flavour.
|
2007-11-11 19:50:10 +00:00
|
|
|
list<int> DwarfNumbers = [];
|
2011-04-20 18:19:48 +00:00
|
|
|
|
|
|
|
// CostPerUse - Additional cost of instructions using this register compared
|
|
|
|
// to other registers in its class. The register allocator will try to
|
|
|
|
// minimize the number of instructions using a register with a CostPerUse.
|
2011-10-18 18:40:53 +00:00
|
|
|
// This is used by the x86-64 and ARM Thumb targets where some registers
|
2011-04-20 18:19:48 +00:00
|
|
|
// require larger instruction encodings.
|
|
|
|
int CostPerUse = 0;
|
2012-01-18 00:16:39 +00:00
|
|
|
|
|
|
|
// CoveredBySubRegs - When this bit is set, the value of this register is
|
|
|
|
// completely determined by the value of its sub-registers. For example, the
|
|
|
|
// x86 register AX is covered by its sub-registers AL and AH, but EAX is not
|
|
|
|
// covered by its sub-register AX.
|
|
|
|
bit CoveredBySubRegs = 0;
|
2003-05-29 18:48:17 +00:00
|
|
|
}
|
|
|
|
|
2007-04-20 21:13:46 +00:00
|
|
|
// RegisterWithSubRegs - This can be used to define instances of Register which
|
|
|
|
// need to specify sub-registers.
|
|
|
|
// List "subregs" specifies which registers are sub-registers to this one. This
|
|
|
|
// is used to populate the SubRegs and AliasSet fields of TargetRegisterDesc.
|
2011-02-10 19:56:23 +00:00
|
|
|
// This allows the code generator to be careful not to put two values with
|
2007-04-20 21:13:46 +00:00
|
|
|
// overlapping live ranges into registers which alias.
|
|
|
|
class RegisterWithSubRegs<string n, list<Register> subregs> : Register<n> {
|
|
|
|
let SubRegs = subregs;
|
2003-07-30 05:50:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// RegisterClass - Now that all of the registers are defined, and aliases
|
|
|
|
// between registers are defined, specify which registers belong to which
|
|
|
|
// register classes. This also defines the default allocation order of
|
|
|
|
// registers by register allocators.
|
|
|
|
//
|
2005-12-01 04:51:06 +00:00
|
|
|
class RegisterClass<string namespace, list<ValueType> regTypes, int alignment,
|
2011-06-27 21:06:21 +00:00
|
|
|
dag regList, RegAltNameIndex idx = NoRegAltName> {
|
2005-08-19 18:48:48 +00:00
|
|
|
string Namespace = namespace;
|
|
|
|
|
2006-05-14 02:05:19 +00:00
|
|
|
// RegType - Specify the list ValueType of the registers in this register
|
|
|
|
// class. Note that all registers in a register class must have the same
|
2011-02-10 19:56:23 +00:00
|
|
|
// ValueTypes. This is a list because some targets permit storing different
|
2006-05-15 18:35:02 +00:00
|
|
|
// types in same register, for example vector values with 128-bit total size,
|
|
|
|
// but different count/size of items, like SSE on x86.
|
2003-07-30 22:16:41 +00:00
|
|
|
//
|
2005-12-01 04:51:06 +00:00
|
|
|
list<ValueType> RegTypes = regTypes;
|
|
|
|
|
|
|
|
// Size - Specify the spill size in bits of the registers. A default value of
|
|
|
|
// zero lets tablgen pick an appropriate size.
|
|
|
|
int Size = 0;
|
2003-07-30 22:16:41 +00:00
|
|
|
|
|
|
|
// Alignment - Specify the alignment required of the registers when they are
|
|
|
|
// stored or loaded to memory.
|
|
|
|
//
|
2003-07-30 05:50:12 +00:00
|
|
|
int Alignment = alignment;
|
2003-07-30 22:16:41 +00:00
|
|
|
|
2007-09-19 01:35:01 +00:00
|
|
|
// CopyCost - This value is used to specify the cost of copying a value
|
|
|
|
// between two registers in this register class. The default value is one
|
|
|
|
// meaning it takes a single instruction to perform the copying. A negative
|
|
|
|
// value means copying is extremely expensive or impossible.
|
|
|
|
int CopyCost = 1;
|
|
|
|
|
2003-07-30 22:16:41 +00:00
|
|
|
// MemberList - Specify which registers are in this class. If the
|
|
|
|
// allocation_order_* method are not specified, this also defines the order of
|
|
|
|
// allocation used by the register allocator.
|
|
|
|
//
|
2011-06-15 23:28:14 +00:00
|
|
|
dag MemberList = regList;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2011-06-27 21:06:21 +00:00
|
|
|
// AltNameIndex - The alternate register name to use when printing operands
|
|
|
|
// of this register class. Every register in the register class must have
|
|
|
|
// a valid alternate name for the given index.
|
|
|
|
RegAltNameIndex altNameIndex = idx;
|
|
|
|
|
2010-05-24 21:46:58 +00:00
|
|
|
// SubRegClasses - Specify the register class of subregisters as a list of
|
|
|
|
// dags: (RegClass SubRegIndex, SubRegindex, ...)
|
|
|
|
list<dag> SubRegClasses = [];
|
2003-07-30 22:16:41 +00:00
|
|
|
|
2011-06-02 23:07:20 +00:00
|
|
|
// isAllocatable - Specify that the register class can be used for virtual
|
|
|
|
// registers and register allocation. Some register classes are only used to
|
|
|
|
// model instruction operand constraints, and should have isAllocatable = 0.
|
|
|
|
bit isAllocatable = 1;
|
|
|
|
|
2011-06-18 00:50:49 +00:00
|
|
|
// AltOrders - List of alternative allocation orders. The default order is
|
|
|
|
// MemberList itself, and that is good enough for most targets since the
|
|
|
|
// register allocators automatically remove reserved registers and move
|
|
|
|
// callee-saved registers to the end.
|
|
|
|
list<dag> AltOrders = [];
|
|
|
|
|
|
|
|
// AltOrderSelect - The body of a function that selects the allocation order
|
|
|
|
// to use in a given machine function. The code will be inserted in a
|
|
|
|
// function like this:
|
|
|
|
//
|
|
|
|
// static inline unsigned f(const MachineFunction &MF) { ... }
|
|
|
|
//
|
|
|
|
// The function should return 0 to select the default order defined by
|
|
|
|
// MemberList, 1 to select the first AltOrders entry and so on.
|
|
|
|
code AltOrderSelect = [{}];
|
2003-07-30 05:50:12 +00:00
|
|
|
}
|
|
|
|
|
2011-06-15 23:28:14 +00:00
|
|
|
// The memberList in a RegisterClass is a dag of set operations. TableGen
|
|
|
|
// evaluates these set operations and expand them into register lists. These
|
|
|
|
// are the most common operation, see test/TableGen/SetTheory.td for more
|
|
|
|
// examples of what is possible:
|
|
|
|
//
|
|
|
|
// (add R0, R1, R2) - Set Union. Each argument can be an individual register, a
|
|
|
|
// register class, or a sub-expression. This is also the way to simply list
|
|
|
|
// registers.
|
|
|
|
//
|
|
|
|
// (sub GPR, SP) - Set difference. Subtract the last arguments from the first.
|
|
|
|
//
|
|
|
|
// (and GPR, CSR) - Set intersection. All registers from the first set that are
|
|
|
|
// also in the second set.
|
|
|
|
//
|
|
|
|
// (sequence "R%u", 0, 15) -> [R0, R1, ..., R15]. Generate a sequence of
|
|
|
|
// numbered registers.
|
|
|
|
//
|
|
|
|
// (shl GPR, 4) - Remove the first N elements.
|
|
|
|
//
|
|
|
|
// (trunc GPR, 4) - Truncate after the first N elements.
|
|
|
|
//
|
|
|
|
// (rotl GPR, 1) - Rotate N places to the left.
|
|
|
|
//
|
|
|
|
// (rotr GPR, 1) - Rotate N places to the right.
|
|
|
|
//
|
|
|
|
// (decimate GPR, 2) - Pick every N'th element, starting with the first.
|
|
|
|
//
|
2012-01-24 18:06:05 +00:00
|
|
|
// (interleave A, B, ...) - Interleave the elements from each argument list.
|
|
|
|
//
|
2011-06-15 23:28:14 +00:00
|
|
|
// All of these operators work on ordered sets, not lists. That means
|
|
|
|
// duplicates are removed from sub-expressions.
|
|
|
|
|
|
|
|
// Set operators. The rest is defined in TargetSelectionDAG.td.
|
|
|
|
def sequence;
|
|
|
|
def decimate;
|
2012-01-24 18:06:05 +00:00
|
|
|
def interleave;
|
2003-07-30 05:50:12 +00:00
|
|
|
|
Add a RegisterTuples class to Target.td and TableGen.
A RegisterTuples instance is used to synthesize super-registers by
zipping together lists of sub-registers. This is useful for generating
pseudo-registers representing register sequence constraints like 'two
consecutive GPRs', or 'an even-odd pair of floating point registers'.
The RegisterTuples def can be used in register set operations when
building register classes. That is the only way of accessing the
synthesized super-registers.
For example, the ARM QQ register class of pseudo-registers could have
been formed like this:
// Form pairs Q0_Q1, Q2_Q3, ...
def QQPairs : RegisterTuples<[qsub_0, qsub_1],
[(decimate QPR, 2),
(decimate (shl QPR, 1), 2)]>;
def QQ : RegisterClass<..., (add QQPairs)>;
Similarly, pseudo-registers representing '3 consecutive D-regs with
wraparound' look like:
// Form D0_D1_D2, D1_D2_D3, ..., D30_D31_D0, D31_D0_D1.
def DSeqTriples : RegisterTuples<[dsub_0, dsub_1, dsub_2],
[(rotl DPR, 0),
(rotl DPR, 1),
(rotl DPR, 2)]>;
TableGen automatically computes aliasing information for the synthesized
registers.
Register tuples are still somewhat experimental. We still need to see
how they interact with MC.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@133407 91177308-0d34-0410-b5e6-96231b3b80d8
2011-06-20 02:50:54 +00:00
|
|
|
// RegisterTuples - Automatically generate super-registers by forming tuples of
|
|
|
|
// sub-registers. This is useful for modeling register sequence constraints
|
|
|
|
// with pseudo-registers that are larger than the architectural registers.
|
|
|
|
//
|
|
|
|
// The sub-register lists are zipped together:
|
|
|
|
//
|
|
|
|
// def EvenOdd : RegisterTuples<[sube, subo], [(add R0, R2), (add R1, R3)]>;
|
|
|
|
//
|
|
|
|
// Generates the same registers as:
|
|
|
|
//
|
|
|
|
// let SubRegIndices = [sube, subo] in {
|
|
|
|
// def R0_R1 : RegisterWithSubRegs<"", [R0, R1]>;
|
|
|
|
// def R2_R3 : RegisterWithSubRegs<"", [R2, R3]>;
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// The generated pseudo-registers inherit super-classes and fields from their
|
|
|
|
// first sub-register. Most fields from the Register class are inferred, and
|
|
|
|
// the AsmName and Dwarf numbers are cleared.
|
|
|
|
//
|
|
|
|
// RegisterTuples instances can be used in other set operations to form
|
|
|
|
// register classes and so on. This is the only way of using the generated
|
|
|
|
// registers.
|
|
|
|
class RegisterTuples<list<SubRegIndex> Indices, list<dag> Regs> {
|
|
|
|
// SubRegs - N lists of registers to be zipped up. Super-registers are
|
|
|
|
// synthesized from the first element of each SubRegs list, the second
|
|
|
|
// element and so on.
|
|
|
|
list<dag> SubRegs = Regs;
|
|
|
|
|
|
|
|
// SubRegIndices - N SubRegIndex instances. This provides the names of the
|
|
|
|
// sub-registers in the synthesized super-registers.
|
|
|
|
list<SubRegIndex> SubRegIndices = Indices;
|
|
|
|
|
|
|
|
// Compose sub-register indices like in a normal Register.
|
|
|
|
list<dag> CompositeIndices = [];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-03-24 21:13:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// DwarfRegNum - This class provides a mapping of the llvm register enumeration
|
|
|
|
// to the register numbering used by gcc and gdb. These values are used by a
|
2010-04-05 04:09:20 +00:00
|
|
|
// debug information writer to describe where values may be located during
|
|
|
|
// execution.
|
2007-11-11 19:50:10 +00:00
|
|
|
class DwarfRegNum<list<int> Numbers> {
|
|
|
|
// DwarfNumbers - Numbers used internally by gcc/gdb to identify the register.
|
2006-03-24 21:13:21 +00:00
|
|
|
// These values can be determined by locating the <target>.h file in the
|
|
|
|
// directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES. The
|
|
|
|
// order of these names correspond to the enumeration used by gcc. A value of
|
2010-10-30 13:46:39 +00:00
|
|
|
// -1 indicates that the gcc number is undefined and -2 that register number
|
|
|
|
// is invalid for this mode/flavour.
|
2007-11-11 19:50:10 +00:00
|
|
|
list<int> DwarfNumbers = Numbers;
|
2006-03-24 21:13:21 +00:00
|
|
|
}
|
|
|
|
|
2011-05-30 17:49:59 +00:00
|
|
|
// DwarfRegAlias - This class declares that a given register uses the same dwarf
|
|
|
|
// numbers as another one. This is useful for making it clear that the two
|
|
|
|
// registers do have the same number. It also lets us build a mapping
|
|
|
|
// from dwarf register number to llvm register.
|
|
|
|
class DwarfRegAlias<Register reg> {
|
|
|
|
Register DwarfAlias = reg;
|
|
|
|
}
|
|
|
|
|
2005-10-19 19:51:16 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pull in the common support for scheduling
|
|
|
|
//
|
2008-11-24 07:34:46 +00:00
|
|
|
include "llvm/Target/TargetSchedule.td"
|
2005-10-19 19:51:16 +00:00
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
class Predicate; // Forward def
|
2005-10-19 19:51:16 +00:00
|
|
|
|
2003-07-30 05:50:12 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-08-03 18:18:31 +00:00
|
|
|
// Instruction set description - These classes correspond to the C++ classes in
|
|
|
|
// the Target/TargetInstrInfo.h file.
|
2003-07-30 05:50:12 +00:00
|
|
|
//
|
2003-05-29 18:48:17 +00:00
|
|
|
class Instruction {
|
|
|
|
string Namespace = "";
|
|
|
|
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
dag OutOperandList; // An dag containing the MI def operand list.
|
|
|
|
dag InOperandList; // An dag containing the MI use operand list.
|
2004-08-01 04:40:43 +00:00
|
|
|
string AsmString = ""; // The .s format to print the instruction with.
|
2004-08-01 03:23:34 +00:00
|
|
|
|
|
|
|
// Pattern - Set to the DAG pattern for this instruction, if we know of one,
|
|
|
|
// otherwise, uninitialized.
|
|
|
|
list<dag> Pattern;
|
|
|
|
|
|
|
|
// The follow state will eventually be inferred automatically from the
|
|
|
|
// instruction pattern.
|
|
|
|
|
|
|
|
list<Register> Uses = []; // Default to using no non-operand registers
|
|
|
|
list<Register> Defs = []; // Default to modifying no non-operand registers
|
2003-05-29 18:48:17 +00:00
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
// Predicates - List of predicates which will be turned into isel matching
|
|
|
|
// code.
|
|
|
|
list<Predicate> Predicates = [];
|
|
|
|
|
2011-07-13 23:22:26 +00:00
|
|
|
// Size - Size of encoded instruction, or zero if the size cannot be determined
|
|
|
|
// from the opcode.
|
|
|
|
int Size = 0;
|
|
|
|
|
2011-07-19 21:06:00 +00:00
|
|
|
// DecoderNamespace - The "namespace" in which this instruction exists, on
|
|
|
|
// targets like ARM which multiple ISA namespaces exist.
|
|
|
|
string DecoderNamespace = "";
|
|
|
|
|
2011-07-13 23:22:26 +00:00
|
|
|
// Code size, for instruction selection.
|
|
|
|
// FIXME: What does this actually mean?
|
2006-07-19 00:24:41 +00:00
|
|
|
int CodeSize = 0;
|
|
|
|
|
2006-04-19 20:38:28 +00:00
|
|
|
// Added complexity passed onto matching pattern.
|
|
|
|
int AddedComplexity = 0;
|
2006-04-19 18:07:24 +00:00
|
|
|
|
2003-05-29 18:48:17 +00:00
|
|
|
// These bits capture information about the high-level semantics of the
|
|
|
|
// instruction.
|
2003-07-29 23:02:49 +00:00
|
|
|
bit isReturn = 0; // Is this instruction a return instruction?
|
|
|
|
bit isBranch = 0; // Is this instruction a branch instruction?
|
2007-11-12 07:39:39 +00:00
|
|
|
bit isIndirectBranch = 0; // Is this instruction an indirect branch?
|
2010-08-08 01:49:35 +00:00
|
|
|
bit isCompare = 0; // Is this instruction a comparison instruction?
|
2010-11-17 20:13:28 +00:00
|
|
|
bit isMoveImm = 0; // Is this instruction a move immediate instruction?
|
2011-03-15 05:09:26 +00:00
|
|
|
bit isBitcast = 0; // Is this instruction a bitcast instruction?
|
2004-07-31 02:07:07 +00:00
|
|
|
bit isBarrier = 0; // Can control flow fall through this instruction?
|
2003-07-29 23:02:49 +00:00
|
|
|
bit isCall = 0; // Is this instruction a call instruction?
|
2008-12-03 18:15:48 +00:00
|
|
|
bit canFoldAsLoad = 0; // Can this be folded as a simple memory operand?
|
2008-01-07 23:16:55 +00:00
|
|
|
bit mayLoad = 0; // Is it possible for this inst to read memory?
|
|
|
|
bit mayStore = 0; // Is it possible for this inst to write memory?
|
2005-01-02 02:27:48 +00:00
|
|
|
bit isConvertibleToThreeAddress = 0; // Can this 2-addr instruction promote?
|
|
|
|
bit isCommutable = 0; // Is this 3 operand instruction commutable?
|
2003-07-29 23:02:49 +00:00
|
|
|
bit isTerminator = 0; // Is this part of the terminator for a basic block?
|
2007-06-26 00:48:07 +00:00
|
|
|
bit isReMaterializable = 0; // Is this instruction re-materializable?
|
2007-05-16 20:47:01 +00:00
|
|
|
bit isPredicable = 0; // Is this instruction predicable?
|
2004-09-28 18:34:14 +00:00
|
|
|
bit hasDelaySlot = 0; // Does this instruction have an delay slot?
|
2009-10-29 18:10:34 +00:00
|
|
|
bit usesCustomInserter = 0; // Pseudo instr needing special help.
|
2011-08-30 19:09:48 +00:00
|
|
|
bit hasPostISelHook = 0; // To be *adjusted* after isel by target hook.
|
2005-12-04 08:13:17 +00:00
|
|
|
bit hasCtrlDep = 0; // Does this instruction r/w ctrl-flow chains?
|
2007-06-19 01:26:51 +00:00
|
|
|
bit isNotDuplicable = 0; // Is it unsafe to duplicate this instruction?
|
2008-05-28 22:54:52 +00:00
|
|
|
bit isAsCheapAsAMove = 0; // As cheap (or cheaper) than a move instruction.
|
2009-10-01 08:21:18 +00:00
|
|
|
bit hasExtraSrcRegAllocReq = 0; // Sources have special regalloc requirement?
|
|
|
|
bit hasExtraDefRegAllocReq = 0; // Defs have special regalloc requirement?
|
2011-07-06 21:33:38 +00:00
|
|
|
bit isPseudo = 0; // Is this instruction a pseudo-instruction?
|
|
|
|
// If so, won't have encoding information for
|
|
|
|
// the [MC]CodeEmitter stuff.
|
2007-12-14 01:48:59 +00:00
|
|
|
|
2008-01-10 07:59:24 +00:00
|
|
|
// Side effect flags - When set, the flags have these meanings:
|
2007-12-17 21:02:07 +00:00
|
|
|
//
|
2008-01-10 07:59:24 +00:00
|
|
|
// hasSideEffects - The instruction has side effects that are not
|
|
|
|
// captured by any operands of the instruction or other flags.
|
2008-05-28 22:54:52 +00:00
|
|
|
//
|
2008-01-10 07:59:24 +00:00
|
|
|
// neverHasSideEffects - Set on an instruction with no pattern if it has no
|
|
|
|
// side effects.
|
|
|
|
bit hasSideEffects = 0;
|
|
|
|
bit neverHasSideEffects = 0;
|
2008-05-28 22:54:52 +00:00
|
|
|
|
2009-08-11 22:17:52 +00:00
|
|
|
// Is this instruction a "real" instruction (with a distinct machine
|
|
|
|
// encoding), or is it a pseudo instruction used for codegen modeling
|
|
|
|
// purposes.
|
2011-07-06 21:33:38 +00:00
|
|
|
// FIXME: For now this is distinct from isPseudo, above, as code-gen-only
|
|
|
|
// instructions can (and often do) still have encoding information
|
|
|
|
// associated with them. Once we've migrated all of them over to true
|
|
|
|
// pseudo-instructions that are lowered to real instructions prior to
|
|
|
|
// the printer/emitter, we can remove this attribute and just use isPseudo.
|
2011-10-18 19:18:52 +00:00
|
|
|
//
|
|
|
|
// The intended use is:
|
|
|
|
// isPseudo: Does not have encoding information and should be expanded,
|
|
|
|
// at the latest, during lowering to MCInst.
|
|
|
|
//
|
|
|
|
// isCodeGenOnly: Does have encoding information and can go through to the
|
|
|
|
// CodeEmitter unchanged, but duplicates a canonical instruction
|
|
|
|
// definition's encoding and should be ignored when constructing the
|
|
|
|
// assembler match tables.
|
2009-08-11 22:17:52 +00:00
|
|
|
bit isCodeGenOnly = 0;
|
|
|
|
|
2010-05-20 20:20:32 +00:00
|
|
|
// Is this instruction a pseudo instruction for use by the assembler parser.
|
|
|
|
bit isAsmParserOnly = 0;
|
|
|
|
|
2006-01-27 01:46:15 +00:00
|
|
|
InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling.
|
2006-11-01 00:26:27 +00:00
|
|
|
|
2007-01-12 07:25:16 +00:00
|
|
|
string Constraints = ""; // OperandConstraint, e.g. $src = $dst.
|
2010-04-05 03:10:20 +00:00
|
|
|
|
2006-11-15 22:55:04 +00:00
|
|
|
/// DisableEncoding - List of operand names (e.g. "$op1,$op2") that should not
|
|
|
|
/// be encoded into the output machineinstr.
|
|
|
|
string DisableEncoding = "";
|
2010-04-05 03:10:20 +00:00
|
|
|
|
2010-11-15 05:19:05 +00:00
|
|
|
string PostEncoderMethod = "";
|
2011-02-18 21:51:29 +00:00
|
|
|
string DecoderMethod = "";
|
2010-11-15 05:19:05 +00:00
|
|
|
|
2010-04-05 03:10:20 +00:00
|
|
|
/// Target-specific flags. This becomes the TSFlags field in TargetInstrDesc.
|
2010-06-08 22:51:23 +00:00
|
|
|
bits<64> TSFlags = 0;
|
2011-02-04 17:12:15 +00:00
|
|
|
|
|
|
|
///@name Assembler Parser Support
|
|
|
|
///@{
|
|
|
|
|
|
|
|
string AsmMatchConverter = "";
|
|
|
|
|
2012-04-20 16:29:46 +00:00
|
|
|
/// TwoOperandAliasConstraint - Enable TableGen to auto-generate a
|
|
|
|
/// two-operand matcher inst-alias for a three operand instruction.
|
|
|
|
/// For example, the arm instruction "add r3, r3, r5" can be written
|
|
|
|
/// as "add r3, r5". The constraint is of the same form as a tied-operand
|
|
|
|
/// constraint. For example, "$Rn = $Rd".
|
2012-04-19 23:59:23 +00:00
|
|
|
string TwoOperandAliasConstraint = "";
|
|
|
|
|
2011-02-04 17:12:15 +00:00
|
|
|
///@}
|
2003-08-06 15:31:02 +00:00
|
|
|
}
|
|
|
|
|
2011-07-08 17:36:35 +00:00
|
|
|
/// PseudoInstExpansion - Expansion information for a pseudo-instruction.
|
|
|
|
/// Which instruction it expands to and how the operands map from the
|
|
|
|
/// pseudo.
|
|
|
|
class PseudoInstExpansion<dag Result> {
|
|
|
|
dag ResultInst = Result; // The instruction to generate.
|
|
|
|
bit isPseudo = 1;
|
|
|
|
}
|
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
/// Predicates - These are extra conditionals which are turned into instruction
|
|
|
|
/// selector matching code. Currently each predicate is just a string.
|
|
|
|
class Predicate<string cond> {
|
|
|
|
string CondString = cond;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2010-10-30 19:38:20 +00:00
|
|
|
/// AssemblerMatcherPredicate - If this feature can be used by the assembler
|
|
|
|
/// matcher, this is true. Targets should set this by inheriting their
|
|
|
|
/// feature from the AssemblerPredicate class in addition to Predicate.
|
|
|
|
bit AssemblerMatcherPredicate = 0;
|
2011-07-08 01:53:10 +00:00
|
|
|
|
|
|
|
/// AssemblerCondString - Name of the subtarget feature being tested used
|
|
|
|
/// as alternative condition string used for assembler matcher.
|
|
|
|
/// e.g. "ModeThumb" is translated to "(Bits & ModeThumb) != 0".
|
|
|
|
/// "!ModeThumb" is translated to "(Bits & ModeThumb) == 0".
|
|
|
|
/// It can also list multiple features separated by ",".
|
|
|
|
/// e.g. "ModeThumb,FeatureThumb2" is translated to
|
|
|
|
/// "(Bits & ModeThumb) != 0 && (Bits & FeatureThumb2) != 0".
|
|
|
|
string AssemblerCondString = "";
|
2012-04-24 22:40:08 +00:00
|
|
|
|
|
|
|
/// PredicateName - User-level name to use for the predicate. Mainly for use
|
|
|
|
/// in diagnostics such as missing feature errors in the asm matcher.
|
|
|
|
string PredicateName = "";
|
2005-12-14 22:02:59 +00:00
|
|
|
}
|
|
|
|
|
2007-05-03 00:27:11 +00:00
|
|
|
/// NoHonorSignDependentRounding - This predicate is true if support for
|
|
|
|
/// sign-dependent-rounding is not enabled.
|
|
|
|
def NoHonorSignDependentRounding
|
2011-12-02 22:16:29 +00:00
|
|
|
: Predicate<"!TM.Options.HonorSignDependentRoundingFPMath()">;
|
2007-05-03 00:27:11 +00:00
|
|
|
|
2005-12-14 22:02:59 +00:00
|
|
|
class Requires<list<Predicate> preds> {
|
|
|
|
list<Predicate> Predicates = preds;
|
|
|
|
}
|
2003-08-06 15:31:02 +00:00
|
|
|
|
2010-11-02 00:13:15 +00:00
|
|
|
/// ops definition - This is just a simple marker used to identify the operand
|
|
|
|
/// list for an instruction. outs and ins are identical both syntactically and
|
|
|
|
/// semanticallyr; they are used to define def operands and use operands to
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
/// improve readibility. This should be used like this:
|
|
|
|
/// (outs R32:$dst), (ins R32:$src1, R32:$src2) or something similar.
|
2004-08-01 04:40:43 +00:00
|
|
|
def ops;
|
Change instruction description to split OperandList into OutOperandList and
InOperandList. This gives one piece of important information: # of results
produced by an instruction.
An example of the change:
def ADD32rr : I<0x01, MRMDestReg, (ops GR32:$dst, GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
=>
def ADD32rr : I<0x01, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
"add{l} {$src2, $dst|$dst, $src2}",
[(set GR32:$dst, (add GR32:$src1, GR32:$src2))]>;
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40033 91177308-0d34-0410-b5e6-96231b3b80d8
2007-07-19 01:14:50 +00:00
|
|
|
def outs;
|
|
|
|
def ins;
|
2004-08-11 01:53:34 +00:00
|
|
|
|
2005-08-18 23:17:07 +00:00
|
|
|
/// variable_ops definition - Mark this instruction as taking a variable number
|
|
|
|
/// of operands.
|
|
|
|
def variable_ops;
|
|
|
|
|
2009-07-29 20:43:05 +00:00
|
|
|
|
|
|
|
/// PointerLikeRegClass - Values that are designed to have pointer width are
|
|
|
|
/// derived from this. TableGen treats the register class as having a symbolic
|
|
|
|
/// type that it doesn't know, and resolves the actual regclass to use by using
|
|
|
|
/// the TargetRegisterInfo::getPointerRegClass() hook at codegen time.
|
2009-07-29 21:10:12 +00:00
|
|
|
class PointerLikeRegClass<int Kind> {
|
|
|
|
int RegClassKind = Kind;
|
2009-07-29 20:43:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-05-18 20:44:26 +00:00
|
|
|
/// ptr_rc definition - Mark this operand as being a pointer value whose
|
|
|
|
/// register class is resolved dynamically via a callback to TargetInstrInfo.
|
|
|
|
/// FIXME: We should probably change this to a class which contain a list of
|
|
|
|
/// flags. But currently we have but one flag.
|
2009-07-29 21:10:12 +00:00
|
|
|
def ptr_rc : PointerLikeRegClass<0>;
|
2006-05-18 20:44:26 +00:00
|
|
|
|
2008-03-11 10:09:17 +00:00
|
|
|
/// unknown definition - Mark this operand as being of unknown type, causing
|
|
|
|
/// it to be resolved by inference in the context it is used.
|
|
|
|
def unknown;
|
|
|
|
|
2009-08-10 18:41:10 +00:00
|
|
|
/// AsmOperandClass - Representation for the kinds of operands which the target
|
|
|
|
/// specific parser can create and the assembly matcher may need to distinguish.
|
|
|
|
///
|
|
|
|
/// Operand classes are used to define the order in which instructions are
|
|
|
|
/// matched, to ensure that the instruction which gets matched for any
|
|
|
|
/// particular list of operands is deterministic.
|
|
|
|
///
|
|
|
|
/// The target specific parser must be able to classify a parsed operand into a
|
|
|
|
/// unique class which does not partially overlap with any other classes. It can
|
|
|
|
/// match a subset of some other class, in which case the super class field
|
|
|
|
/// should be defined.
|
|
|
|
class AsmOperandClass {
|
2009-08-10 21:00:45 +00:00
|
|
|
/// The name to use for this class, which should be usable as an enum value.
|
2009-08-10 18:41:10 +00:00
|
|
|
string Name = ?;
|
|
|
|
|
2010-05-22 21:02:29 +00:00
|
|
|
/// The super classes of this operand.
|
|
|
|
list<AsmOperandClass> SuperClasses = [];
|
2009-08-10 21:00:45 +00:00
|
|
|
|
|
|
|
/// The name of the method on the target specific operand to call to test
|
|
|
|
/// whether the operand is an instance of this class. If not set, this will
|
|
|
|
/// default to "isFoo", where Foo is the AsmOperandClass name. The method
|
|
|
|
/// signature should be:
|
|
|
|
/// bool isFoo() const;
|
|
|
|
string PredicateMethod = ?;
|
|
|
|
|
|
|
|
/// The name of the method on the target specific operand to call to add the
|
|
|
|
/// target specific operand to an MCInst. If not set, this will default to
|
|
|
|
/// "addFooOperands", where Foo is the AsmOperandClass name. The method
|
|
|
|
/// signature should be:
|
|
|
|
/// void addFooOperands(MCInst &Inst, unsigned N) const;
|
|
|
|
string RenderMethod = ?;
|
Implement support for custom target specific asm parsing of operands.
Motivation: Improve the parsing of not usual (different from registers or
immediates) operand forms.
This commit implements only the generic support. The ARM specific modifications
will come next.
A table like the one below is autogenerated for every instruction
containing a 'ParserMethod' in its AsmOperandClass
static const OperandMatchEntry OperandMatchTable[20] = {
/* Mnemonic, Operand List Mask, Operand Class, Features */
{ "cdp", 29 /* 0, 2, 3, 4 */, MCK_Coproc, Feature_IsThumb|Feature_HasV6 },
{ "cdp", 58 /* 1, 3, 4, 5 */, MCK_Coproc, Feature_IsARM },
A matcher function very similar (but lot more naive) to
MatchInstructionImpl scans the table. After the mnemonic match, the
features are checked and if the "to be parsed" operand index is
present in the mask, there's a real match. Then, a switch like the one
below dispatch the parsing to the custom method provided in
'ParseMethod':
case MCK_Coproc:
return TryParseCoprocessorOperandName(Operands);
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@125030 91177308-0d34-0410-b5e6-96231b3b80d8
2011-02-07 19:38:32 +00:00
|
|
|
|
|
|
|
/// The name of the method on the target specific operand to call to custom
|
|
|
|
/// handle the operand parsing. This is useful when the operands do not relate
|
|
|
|
/// to immediates or registers and are very instruction specific (as flags to
|
|
|
|
/// set in a processor register, coprocessor number, ...).
|
|
|
|
string ParserMethod = ?;
|
2009-08-10 18:41:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
def ImmAsmOperand : AsmOperandClass {
|
|
|
|
let Name = "Imm";
|
|
|
|
}
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2004-08-11 01:53:34 +00:00
|
|
|
/// Operand Types - These provide the built-in operand types that may be used
|
|
|
|
/// by a target. Targets can optionally provide their own operand types as
|
|
|
|
/// needed, though this should not be needed for RISC targets.
|
|
|
|
class Operand<ValueType ty> {
|
|
|
|
ValueType Type = ty;
|
|
|
|
string PrintMethod = "printOperand";
|
2010-11-15 05:19:05 +00:00
|
|
|
string EncoderMethod = "";
|
2011-02-18 21:51:29 +00:00
|
|
|
string DecoderMethod = "";
|
2009-06-20 07:03:18 +00:00
|
|
|
string AsmOperandLowerMethod = ?;
|
2011-07-14 21:47:18 +00:00
|
|
|
string OperandType = "OPERAND_UNKNOWN";
|
2005-11-19 07:00:10 +00:00
|
|
|
dag MIOperandInfo = (ops);
|
2009-08-09 05:18:30 +00:00
|
|
|
|
|
|
|
// ParserMatchClass - The "match class" that operands of this type fit
|
|
|
|
// in. Match classes are used to define the order in which instructions are
|
|
|
|
// match, to ensure that which instructions gets matched is deterministic.
|
2009-08-09 06:00:04 +00:00
|
|
|
//
|
2010-05-22 21:02:29 +00:00
|
|
|
// The target specific parser must be able to classify an parsed operand into
|
|
|
|
// a unique class, which does not partially overlap with any other classes. It
|
|
|
|
// can match a subset of some other class, in which case the AsmOperandClass
|
|
|
|
// should declare the other operand as one of its super classes.
|
2009-08-10 18:41:10 +00:00
|
|
|
AsmOperandClass ParserMatchClass = ImmAsmOperand;
|
2004-08-11 01:53:34 +00:00
|
|
|
}
|
|
|
|
|
2011-06-27 21:06:21 +00:00
|
|
|
class RegisterOperand<RegisterClass regclass, string pm = "printOperand"> {
|
|
|
|
// RegClass - The register class of the operand.
|
|
|
|
RegisterClass RegClass = regclass;
|
|
|
|
// PrintMethod - The target method to call to print register operands of
|
|
|
|
// this type. The method normally will just use an alt-name index to look
|
|
|
|
// up the name to print. Default to the generic printOperand().
|
|
|
|
string PrintMethod = pm;
|
|
|
|
// ParserMatchClass - The "match class" that operands of this type fit
|
|
|
|
// in. Match classes are used to define the order in which instructions are
|
|
|
|
// match, to ensure that which instructions gets matched is deterministic.
|
|
|
|
//
|
|
|
|
// The target specific parser must be able to classify an parsed operand into
|
|
|
|
// a unique class, which does not partially overlap with any other classes. It
|
|
|
|
// can match a subset of some other class, in which case the AsmOperandClass
|
|
|
|
// should declare the other operand as one of its super classes.
|
|
|
|
AsmOperandClass ParserMatchClass;
|
|
|
|
}
|
|
|
|
|
2011-07-14 21:47:18 +00:00
|
|
|
let OperandType = "OPERAND_IMMEDIATE" in {
|
2004-08-15 05:37:00 +00:00
|
|
|
def i1imm : Operand<i1>;
|
2004-08-11 01:53:34 +00:00
|
|
|
def i8imm : Operand<i8>;
|
|
|
|
def i16imm : Operand<i16>;
|
|
|
|
def i32imm : Operand<i32>;
|
|
|
|
def i64imm : Operand<i64>;
|
2003-08-03 18:18:31 +00:00
|
|
|
|
2008-02-14 07:25:46 +00:00
|
|
|
def f32imm : Operand<f32>;
|
|
|
|
def f64imm : Operand<f64>;
|
2011-07-14 21:47:18 +00:00
|
|
|
}
|
2008-02-14 07:25:46 +00:00
|
|
|
|
2007-07-05 07:09:09 +00:00
|
|
|
/// zero_reg definition - Special node to stand for the zero register.
|
|
|
|
///
|
|
|
|
def zero_reg;
|
2006-11-03 23:52:18 +00:00
|
|
|
|
|
|
|
/// PredicateOperand - This can be used to define a predicate operand for an
|
|
|
|
/// instruction. OpTypes specifies the MIOperandInfo for the operand, and
|
|
|
|
/// AlwaysVal specifies the value of this predicate when set to "always
|
2007-07-06 23:21:02 +00:00
|
|
|
/// execute".
|
2007-07-05 07:09:09 +00:00
|
|
|
class PredicateOperand<ValueType ty, dag OpTypes, dag AlwaysVal>
|
|
|
|
: Operand<ty> {
|
2006-11-03 23:52:18 +00:00
|
|
|
let MIOperandInfo = OpTypes;
|
2007-07-06 01:00:16 +00:00
|
|
|
dag DefaultOps = AlwaysVal;
|
2006-11-03 23:52:18 +00:00
|
|
|
}
|
|
|
|
|
2007-07-06 01:00:16 +00:00
|
|
|
/// OptionalDefOperand - This is used to define a optional definition operand
|
2009-07-10 05:20:19 +00:00
|
|
|
/// for an instruction. DefaultOps is the register the operand represents if
|
|
|
|
/// none is supplied, e.g. zero_reg.
|
2007-07-06 01:00:16 +00:00
|
|
|
class OptionalDefOperand<ValueType ty, dag OpTypes, dag defaultops>
|
|
|
|
: Operand<ty> {
|
|
|
|
let MIOperandInfo = OpTypes;
|
|
|
|
dag DefaultOps = defaultops;
|
2007-07-05 07:09:09 +00:00
|
|
|
}
|
|
|
|
|
2006-11-03 23:52:18 +00:00
|
|
|
|
2004-08-14 22:50:53 +00:00
|
|
|
// InstrInfo - This class should only be instantiated once to provide parameters
|
2010-02-10 16:03:48 +00:00
|
|
|
// which are global to the target machine.
|
2004-08-14 22:50:53 +00:00
|
|
|
//
|
|
|
|
class InstrInfo {
|
2004-10-14 05:53:40 +00:00
|
|
|
// Target can specify its instructions in either big or little-endian formats.
|
|
|
|
// For instance, while both Sparc and PowerPC are big-endian platforms, the
|
|
|
|
// Sparc manual specifies its instructions in the format [31..0] (big), while
|
|
|
|
// PowerPC specifies them using the format [0..31] (little).
|
|
|
|
bit isLittleEndianEncoding = 0;
|
2004-08-14 22:50:53 +00:00
|
|
|
}
|
|
|
|
|
2009-08-11 22:17:52 +00:00
|
|
|
// Standard Pseudo Instructions.
|
2010-07-02 21:44:22 +00:00
|
|
|
// This list must match TargetOpcodes.h and CodeGenTarget.cpp.
|
|
|
|
// Only these instructions are allowed in the TargetOpcode namespace.
|
2011-10-10 18:51:33 +00:00
|
|
|
let isCodeGenOnly = 1, isPseudo = 1, Namespace = "TargetOpcode" in {
|
2006-01-27 01:46:15 +00:00
|
|
|
def PHI : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins variable_ops);
|
2006-01-27 01:46:15 +00:00
|
|
|
let AsmString = "PHINODE";
|
|
|
|
}
|
|
|
|
def INLINEASM : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins variable_ops);
|
2006-01-27 01:46:15 +00:00
|
|
|
let AsmString = "";
|
2011-01-07 23:50:32 +00:00
|
|
|
let neverHasSideEffects = 1; // Note side effect is encoded in an operand.
|
2006-01-27 01:46:15 +00:00
|
|
|
}
|
2010-07-16 22:20:36 +00:00
|
|
|
def PROLOG_LABEL : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins i32imm:$id);
|
2008-07-01 00:05:16 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let hasCtrlDep = 1;
|
2009-11-12 18:36:19 +00:00
|
|
|
let isNotDuplicable = 1;
|
2008-07-01 00:05:16 +00:00
|
|
|
}
|
|
|
|
def EH_LABEL : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins i32imm:$id);
|
2008-07-01 00:05:16 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let hasCtrlDep = 1;
|
2009-11-12 18:36:19 +00:00
|
|
|
let isNotDuplicable = 1;
|
2008-07-01 00:05:16 +00:00
|
|
|
}
|
|
|
|
def GC_LABEL : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins i32imm:$id);
|
2007-01-26 14:34:52 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let hasCtrlDep = 1;
|
2009-11-12 18:36:19 +00:00
|
|
|
let isNotDuplicable = 1;
|
2007-01-26 14:34:52 +00:00
|
|
|
}
|
2009-09-28 20:32:26 +00:00
|
|
|
def KILL : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins variable_ops);
|
2008-02-02 04:07:54 +00:00
|
|
|
let AsmString = "";
|
2009-09-28 20:32:26 +00:00
|
|
|
let neverHasSideEffects = 1;
|
2008-02-02 04:07:54 +00:00
|
|
|
}
|
2007-07-26 07:48:21 +00:00
|
|
|
def EXTRACT_SUBREG : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins unknown:$supersrc, i32imm:$subidx);
|
2007-07-26 07:48:21 +00:00
|
|
|
let AsmString = "";
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1;
|
2007-07-26 07:48:21 +00:00
|
|
|
}
|
|
|
|
def INSERT_SUBREG : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins unknown:$supersrc, unknown:$subsrc, i32imm:$subidx);
|
2007-07-26 07:48:21 +00:00
|
|
|
let AsmString = "";
|
2008-01-10 07:59:24 +00:00
|
|
|
let neverHasSideEffects = 1;
|
2008-03-16 03:12:01 +00:00
|
|
|
let Constraints = "$supersrc = $dst";
|
2007-07-26 07:48:21 +00:00
|
|
|
}
|
2008-03-15 00:03:38 +00:00
|
|
|
def IMPLICIT_DEF : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins);
|
2008-03-15 00:03:38 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let neverHasSideEffects = 1;
|
2008-09-09 18:25:28 +00:00
|
|
|
let isReMaterializable = 1;
|
|
|
|
let isAsCheapAsAMove = 1;
|
2008-03-15 00:03:38 +00:00
|
|
|
}
|
2008-03-16 03:12:01 +00:00
|
|
|
def SUBREG_TO_REG : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins unknown:$implsrc, unknown:$subsrc, i32imm:$subidx);
|
2008-03-16 03:12:01 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let neverHasSideEffects = 1;
|
|
|
|
}
|
2009-04-13 21:06:25 +00:00
|
|
|
def COPY_TO_REGCLASS : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins unknown:$src, i32imm:$regclass);
|
2009-04-13 15:38:05 +00:00
|
|
|
let AsmString = "";
|
|
|
|
let neverHasSideEffects = 1;
|
|
|
|
let isAsCheapAsAMove = 1;
|
|
|
|
}
|
2010-02-09 19:54:29 +00:00
|
|
|
def DBG_VALUE : Instruction {
|
2010-03-18 20:55:31 +00:00
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins variable_ops);
|
2010-02-09 19:54:29 +00:00
|
|
|
let AsmString = "DBG_VALUE";
|
2011-01-07 21:08:26 +00:00
|
|
|
let neverHasSideEffects = 1;
|
2010-01-09 01:24:25 +00:00
|
|
|
}
|
Add a pseudo instruction REG_SEQUENCE that takes a list of registers and
sub-register indices and outputs a single super register which is formed from
a consecutive sequence of registers.
This is used as register allocation / coalescing aid and it is useful to
represent instructions that output register pairs / quads. For example,
v1024, v1025 = vload <address>
where v1024 and v1025 forms a register pair.
This really should be modelled as
v1024<3>, v1025<4> = vload <address>
but it would violate SSA property before register allocation is done.
Currently we use insert_subreg to form the super register:
v1026 = implicit_def
v1027 - insert_subreg v1026, v1024, 3
v1028 = insert_subreg v1027, v1025, 4
...
= use v1024
= use v1028
But this adds pseudo live interval overlap between v1024 and v1025.
We can now modeled it as
v1024, v1025 = vload <address>
v1026 = REG_SEQUENCE v1024, 3, v1025, 4
...
= use v1024
= use v1026
After coalescing, it will be
v1026<3>, v1025<4> = vload <address>
...
= use v1026<3>
= use v1026
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@102815 91177308-0d34-0410-b5e6-96231b3b80d8
2010-05-01 00:28:44 +00:00
|
|
|
def REG_SEQUENCE : Instruction {
|
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins variable_ops);
|
|
|
|
let AsmString = "";
|
|
|
|
let neverHasSideEffects = 1;
|
|
|
|
let isAsCheapAsAMove = 1;
|
|
|
|
}
|
2010-07-02 22:29:50 +00:00
|
|
|
def COPY : Instruction {
|
|
|
|
let OutOperandList = (outs unknown:$dst);
|
|
|
|
let InOperandList = (ins unknown:$src);
|
|
|
|
let AsmString = "";
|
|
|
|
let neverHasSideEffects = 1;
|
|
|
|
let isAsCheapAsAMove = 1;
|
|
|
|
}
|
2011-12-06 22:12:01 +00:00
|
|
|
def BUNDLE : Instruction {
|
|
|
|
let OutOperandList = (outs);
|
|
|
|
let InOperandList = (ins variable_ops);
|
|
|
|
let AsmString = "BUNDLE";
|
|
|
|
}
|
2009-08-11 22:17:52 +00:00
|
|
|
}
|
2006-01-27 01:46:15 +00:00
|
|
|
|
2009-07-29 00:02:19 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2010-05-04 00:33:13 +00:00
|
|
|
// AsmParser - This class can be implemented by targets that wish to implement
|
2009-07-29 00:02:19 +00:00
|
|
|
// .s file parsing.
|
|
|
|
//
|
2010-05-04 00:33:13 +00:00
|
|
|
// Subtargets can have multiple different assembly parsers (e.g. AT&T vs Intel
|
2009-07-29 00:02:19 +00:00
|
|
|
// syntax on X86 for example).
|
|
|
|
//
|
|
|
|
class AsmParser {
|
2009-08-07 22:44:56 +00:00
|
|
|
// AsmParserClassName - This specifies the suffix to use for the asmparser
|
|
|
|
// class. Generated AsmParser classes are always prefixed with the target
|
2009-07-29 00:02:19 +00:00
|
|
|
// name.
|
|
|
|
string AsmParserClassName = "AsmParser";
|
2010-03-18 20:05:56 +00:00
|
|
|
|
2010-10-30 13:46:39 +00:00
|
|
|
// AsmParserInstCleanup - If non-empty, this is the name of a custom member
|
|
|
|
// function of the AsmParser class to call on every matched instruction.
|
|
|
|
// This can be used to perform target specific instruction post-processing.
|
2010-03-18 20:05:56 +00:00
|
|
|
string AsmParserInstCleanup = "";
|
2012-01-09 19:13:28 +00:00
|
|
|
}
|
|
|
|
def DefaultAsmParser : AsmParser;
|
2010-05-04 00:33:13 +00:00
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AsmParserVariant - Subtargets can have multiple different assembly parsers
|
|
|
|
// (e.g. AT&T vs Intel syntax on X86 for example). This class can be
|
|
|
|
// implemented by targets to describe such variants.
|
|
|
|
//
|
|
|
|
class AsmParserVariant {
|
2009-07-29 00:02:19 +00:00
|
|
|
// Variant - AsmParsers can be of multiple different variants. Variants are
|
2010-05-04 00:33:13 +00:00
|
|
|
// used to support targets that need to parser multiple formats for the
|
2009-07-29 00:02:19 +00:00
|
|
|
// assembly language.
|
|
|
|
int Variant = 0;
|
2009-08-11 20:59:47 +00:00
|
|
|
|
|
|
|
// CommentDelimiter - If given, the delimiter string used to recognize
|
|
|
|
// comments which are hard coded in the .td assembler strings for individual
|
|
|
|
// instructions.
|
|
|
|
string CommentDelimiter = "";
|
|
|
|
|
|
|
|
// RegisterPrefix - If given, the token prefix which indicates a register
|
|
|
|
// token. This is used by the matcher to automatically recognize hard coded
|
|
|
|
// register tokens as constrained registers, instead of tokens, for the
|
|
|
|
// purposes of matching.
|
|
|
|
string RegisterPrefix = "";
|
2009-07-29 00:02:19 +00:00
|
|
|
}
|
2012-01-09 19:13:28 +00:00
|
|
|
def DefaultAsmParserVariant : AsmParserVariant;
|
2009-07-29 00:02:19 +00:00
|
|
|
|
2010-10-30 19:38:20 +00:00
|
|
|
/// AssemblerPredicate - This is a Predicate that can be used when the assembler
|
|
|
|
/// matches instructions and aliases.
|
2012-04-24 22:40:08 +00:00
|
|
|
class AssemblerPredicate<string cond, string name = ""> {
|
2010-10-30 19:38:20 +00:00
|
|
|
bit AssemblerMatcherPredicate = 1;
|
2011-07-08 01:53:10 +00:00
|
|
|
string AssemblerCondString = cond;
|
2012-04-24 22:40:08 +00:00
|
|
|
string PredicateName = name;
|
2010-10-30 19:38:20 +00:00
|
|
|
}
|
|
|
|
|
2011-12-06 23:43:54 +00:00
|
|
|
/// TokenAlias - This class allows targets to define assembler token
|
|
|
|
/// operand aliases. That is, a token literal operand which is equivalent
|
|
|
|
/// to another, canonical, token literal. For example, ARM allows:
|
|
|
|
/// vmov.u32 s4, #0 -> vmov.i32, #0
|
|
|
|
/// 'u32' is a more specific designator for the 32-bit integer type specifier
|
|
|
|
/// and is legal for any instruction which accepts 'i32' as a datatype suffix.
|
|
|
|
/// def : TokenAlias<".u32", ".i32">;
|
|
|
|
///
|
|
|
|
/// This works by marking the match class of 'From' as a subclass of the
|
|
|
|
/// match class of 'To'.
|
|
|
|
class TokenAlias<string From, string To> {
|
|
|
|
string FromToken = From;
|
|
|
|
string ToToken = To;
|
|
|
|
}
|
2009-07-29 00:02:19 +00:00
|
|
|
|
2010-10-30 17:36:36 +00:00
|
|
|
/// MnemonicAlias - This class allows targets to define assembler mnemonic
|
|
|
|
/// aliases. This should be used when all forms of one mnemonic are accepted
|
|
|
|
/// with a different mnemonic. For example, X86 allows:
|
|
|
|
/// sal %al, 1 -> shl %al, 1
|
|
|
|
/// sal %ax, %cl -> shl %ax, %cl
|
|
|
|
/// sal %eax, %cl -> shl %eax, %cl
|
|
|
|
/// etc. Though "sal" is accepted with many forms, all of them are directly
|
|
|
|
/// translated to a shl, so it can be handled with (in the case of X86, it
|
|
|
|
/// actually has one for each suffix as well):
|
|
|
|
/// def : MnemonicAlias<"sal", "shl">;
|
|
|
|
///
|
2010-10-30 19:23:13 +00:00
|
|
|
/// Mnemonic aliases are mapped before any other translation in the match phase,
|
|
|
|
/// and do allow Requires predicates, e.g.:
|
|
|
|
///
|
|
|
|
/// def : MnemonicAlias<"pushf", "pushfq">, Requires<[In64BitMode]>;
|
|
|
|
/// def : MnemonicAlias<"pushf", "pushfl">, Requires<[In32BitMode]>;
|
2010-10-30 17:36:36 +00:00
|
|
|
///
|
|
|
|
class MnemonicAlias<string From, string To> {
|
|
|
|
string FromMnemonic = From;
|
|
|
|
string ToMnemonic = To;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2010-10-30 19:23:13 +00:00
|
|
|
// Predicates - Predicates that must be true for this remapping to happen.
|
|
|
|
list<Predicate> Predicates = [];
|
2010-10-30 17:36:36 +00:00
|
|
|
}
|
|
|
|
|
2010-10-31 18:43:46 +00:00
|
|
|
/// InstAlias - This defines an alternate assembly syntax that is allowed to
|
|
|
|
/// match an instruction that has a different (more canonical) assembly
|
|
|
|
/// representation.
|
2011-04-13 23:36:21 +00:00
|
|
|
class InstAlias<string Asm, dag Result, bit Emit = 0b1> {
|
2010-10-31 18:43:46 +00:00
|
|
|
string AsmString = Asm; // The .s format to match the instruction with.
|
|
|
|
dag ResultInst = Result; // The MCInst to generate.
|
2011-04-13 23:36:21 +00:00
|
|
|
bit EmitAlias = Emit; // Emit the alias instead of what's aliased.
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2010-10-31 18:43:46 +00:00
|
|
|
// Predicates - Predicates that must be true for this to match.
|
|
|
|
list<Predicate> Predicates = [];
|
|
|
|
}
|
2010-10-30 17:36:36 +00:00
|
|
|
|
2004-08-14 22:50:53 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// AsmWriter - This class can be implemented by targets that need to customize
|
|
|
|
// the format of the .s file writer.
|
|
|
|
//
|
|
|
|
// Subtargets can have multiple different asmwriters (e.g. AT&T vs Intel syntax
|
|
|
|
// on X86 for example).
|
|
|
|
//
|
|
|
|
class AsmWriter {
|
|
|
|
// AsmWriterClassName - This specifies the suffix to use for the asmwriter
|
|
|
|
// class. Generated AsmWriter classes are always prefixed with the target
|
|
|
|
// name.
|
|
|
|
string AsmWriterClassName = "AsmPrinter";
|
|
|
|
|
2004-10-03 19:34:18 +00:00
|
|
|
// Variant - AsmWriters can be of multiple different variants. Variants are
|
|
|
|
// used to support targets that need to emit assembly code in ways that are
|
|
|
|
// mostly the same for different targets, but have minor differences in
|
|
|
|
// syntax. If the asmstring contains {|} characters in them, this integer
|
|
|
|
// will specify which alternative to use. For example "{x|y|z}" with Variant
|
|
|
|
// == 1, will expand to "y".
|
|
|
|
int Variant = 0;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
|
|
|
|
2009-08-07 23:13:38 +00:00
|
|
|
// FirstOperandColumn/OperandSpacing - If the assembler syntax uses a columnar
|
|
|
|
// layout, the asmwriter can actually generate output in this columns (in
|
|
|
|
// verbose-asm mode). These two values indicate the width of the first column
|
|
|
|
// (the "opcode" area) and the width to reserve for subsequent operands. When
|
|
|
|
// verbose asm mode is enabled, operands will be indented to respect this.
|
|
|
|
int FirstOperandColumn = -1;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2009-08-07 23:13:38 +00:00
|
|
|
// OperandSpacing - Space between operand columns.
|
|
|
|
int OperandSpacing = -1;
|
2010-09-30 01:29:54 +00:00
|
|
|
|
|
|
|
// isMCAsmWriter - Is this assembly writer for an MC emitter? This controls
|
|
|
|
// generation of the printInstruction() method. For MC printers, it takes
|
|
|
|
// an MCInstr* operand, otherwise it takes a MachineInstr*.
|
|
|
|
bit isMCAsmWriter = 0;
|
2004-08-14 22:50:53 +00:00
|
|
|
}
|
|
|
|
def DefaultAsmWriter : AsmWriter;
|
|
|
|
|
|
|
|
|
2003-08-03 18:18:31 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Target - This class contains the "global" target information
|
|
|
|
//
|
|
|
|
class Target {
|
2004-08-14 22:50:53 +00:00
|
|
|
// InstructionSet - Instruction set description for this target.
|
2003-08-03 18:18:31 +00:00
|
|
|
InstrInfo InstructionSet;
|
2004-08-14 22:50:53 +00:00
|
|
|
|
2009-07-29 00:02:19 +00:00
|
|
|
// AssemblyParsers - The AsmParser instances available for this target.
|
|
|
|
list<AsmParser> AssemblyParsers = [DefaultAsmParser];
|
|
|
|
|
2012-01-09 19:13:28 +00:00
|
|
|
/// AssemblyParserVariants - The AsmParserVariant instances available for
|
|
|
|
/// this target.
|
|
|
|
list<AsmParserVariant> AssemblyParserVariants = [DefaultAsmParserVariant];
|
|
|
|
|
2004-10-03 19:34:18 +00:00
|
|
|
// AssemblyWriters - The AsmWriter instances available for this target.
|
|
|
|
list<AsmWriter> AssemblyWriters = [DefaultAsmWriter];
|
2003-05-29 18:48:17 +00:00
|
|
|
}
|
2003-08-04 21:07:37 +00:00
|
|
|
|
2005-10-19 13:34:52 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// SubtargetFeature - A characteristic of the chip set.
|
|
|
|
//
|
2007-05-04 20:38:40 +00:00
|
|
|
class SubtargetFeature<string n, string a, string v, string d,
|
|
|
|
list<SubtargetFeature> i = []> {
|
2005-10-19 13:34:52 +00:00
|
|
|
// Name - Feature name. Used by command line (-mattr=) to determine the
|
|
|
|
// appropriate target chip.
|
|
|
|
//
|
|
|
|
string Name = n;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2005-10-26 17:28:23 +00:00
|
|
|
// Attribute - Attribute to be set by feature.
|
|
|
|
//
|
|
|
|
string Attribute = a;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2006-01-27 08:09:42 +00:00
|
|
|
// Value - Value the attribute to be set to by feature.
|
|
|
|
//
|
|
|
|
string Value = v;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2005-10-19 13:34:52 +00:00
|
|
|
// Desc - Feature description. Used by command line (-mattr=) to display help
|
|
|
|
// information.
|
|
|
|
//
|
|
|
|
string Desc = d;
|
2007-05-04 20:38:40 +00:00
|
|
|
|
|
|
|
// Implies - Features that this feature implies are present. If one of those
|
|
|
|
// features isn't set, then this one shouldn't be set either.
|
|
|
|
//
|
|
|
|
list<SubtargetFeature> Implies = i;
|
2005-10-19 13:34:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Processor chip sets - These values represent each of the chip sets supported
|
|
|
|
// by the scheduler. Each Processor definition requires corresponding
|
|
|
|
// instruction itineraries.
|
|
|
|
//
|
|
|
|
class Processor<string n, ProcessorItineraries pi, list<SubtargetFeature> f> {
|
|
|
|
// Name - Chip set name. Used by command line (-mcpu=) to determine the
|
|
|
|
// appropriate target chip.
|
|
|
|
//
|
|
|
|
string Name = n;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
2005-10-19 13:34:52 +00:00
|
|
|
// ProcItin - The scheduling information for the target processor.
|
|
|
|
//
|
|
|
|
ProcessorItineraries ProcItin = pi;
|
2011-02-10 19:56:23 +00:00
|
|
|
|
|
|
|
// Features - list of
|
2005-10-21 19:05:19 +00:00
|
|
|
list<SubtargetFeature> Features = f;
|
2005-10-19 13:34:52 +00:00
|
|
|
}
|
|
|
|
|
2003-08-04 21:07:37 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2007-02-27 06:59:52 +00:00
|
|
|
// Pull in the common support for calling conventions.
|
|
|
|
//
|
2008-11-24 07:34:46 +00:00
|
|
|
include "llvm/Target/TargetCallingConv.td"
|
2007-02-27 06:59:52 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Pull in the common support for DAG isel generation.
|
2004-08-01 03:23:34 +00:00
|
|
|
//
|
2008-11-24 07:34:46 +00:00
|
|
|
include "llvm/Target/TargetSelectionDAG.td"
|