Target.td revision 6b31d4ea3610b04d71e1eb38d8fc625eae7b759a
1//===- Target.td - Target Independent TableGen interface ---*- tablegen -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines the target-independent interfaces which should be 11// implemented by each target which is using a TableGen based code generator. 12// 13//===----------------------------------------------------------------------===// 14 15// Include all information about LLVM intrinsics. 16include "llvm/Intrinsics.td" 17 18//===----------------------------------------------------------------------===// 19// Register file description - These classes are used to fill in the target 20// description classes. 21 22class RegisterClass; // Forward def 23 24// SubRegIndex - Use instances of SubRegIndex to identify subregisters. 25class SubRegIndex<list<SubRegIndex> comps = []> { 26 string Namespace = ""; 27 28 // ComposedOf - A list of two SubRegIndex instances, [A, B]. 29 // This indicates that this SubRegIndex is the result of composing A and B. 30 list<SubRegIndex> ComposedOf = comps; 31} 32 33// RegAltNameIndex - The alternate name set to use for register operands of 34// this register class when printing. 35class RegAltNameIndex { 36 string Namespace = ""; 37} 38def NoRegAltName : RegAltNameIndex; 39 40// Register - You should define one instance of this class for each register 41// in the target machine. String n will become the "name" of the register. 42class Register<string n, list<string> altNames = []> { 43 string Namespace = ""; 44 string AsmName = n; 45 list<string> AltNames = altNames; 46 47 // Aliases - A list of registers that this register overlaps with. A read or 48 // modification of this register can potentially read or modify the aliased 49 // registers. 50 list<Register> Aliases = []; 51 52 // SubRegs - A list of registers that are parts of this register. Note these 53 // are "immediate" sub-registers and the registers within the list do not 54 // themselves overlap. e.g. For X86, EAX's SubRegs list contains only [AX], 55 // not [AX, AH, AL]. 56 list<Register> SubRegs = []; 57 58 // SubRegIndices - For each register in SubRegs, specify the SubRegIndex used 59 // to address it. Sub-sub-register indices are automatically inherited from 60 // SubRegs. 61 list<SubRegIndex> SubRegIndices = []; 62 63 // RegAltNameIndices - The alternate name indices which are valid for this 64 // register. 65 list<RegAltNameIndex> RegAltNameIndices = []; 66 67 // CompositeIndices - Specify subreg indices that don't correspond directly to 68 // a register in SubRegs and are not inherited. The following formats are 69 // supported: 70 // 71 // (a) Identity - Reg:a == Reg 72 // (a b) Alias - Reg:a == Reg:b 73 // (a b,c) Composite - Reg:a == (Reg:b):c 74 // 75 // This can be used to disambiguate a sub-sub-register that exists in more 76 // than one subregister and other weird stuff. 77 list<dag> CompositeIndices = []; 78 79 // DwarfNumbers - Numbers used internally by gcc/gdb to identify the register. 80 // These values can be determined by locating the <target>.h file in the 81 // directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES. The 82 // order of these names correspond to the enumeration used by gcc. A value of 83 // -1 indicates that the gcc number is undefined and -2 that register number 84 // is invalid for this mode/flavour. 85 list<int> DwarfNumbers = []; 86 87 // CostPerUse - Additional cost of instructions using this register compared 88 // to other registers in its class. The register allocator will try to 89 // minimize the number of instructions using a register with a CostPerUse. 90 // This is used by the x86-64 and ARM Thumb targets where some registers 91 // require larger instruction encodings. 92 int CostPerUse = 0; 93 94 // CoveredBySubRegs - When this bit is set, the value of this register is 95 // completely determined by the value of its sub-registers. For example, the 96 // x86 register AX is covered by its sub-registers AL and AH, but EAX is not 97 // covered by its sub-register AX. 98 bit CoveredBySubRegs = 0; 99 100 // HWEncoding - The target specific hardware encoding for this register. 101 bits<16> HWEncoding = 0; 102} 103 104// RegisterWithSubRegs - This can be used to define instances of Register which 105// need to specify sub-registers. 106// List "subregs" specifies which registers are sub-registers to this one. This 107// is used to populate the SubRegs and AliasSet fields of TargetRegisterDesc. 108// This allows the code generator to be careful not to put two values with 109// overlapping live ranges into registers which alias. 110class RegisterWithSubRegs<string n, list<Register> subregs> : Register<n> { 111 let SubRegs = subregs; 112} 113 114// RegisterClass - Now that all of the registers are defined, and aliases 115// between registers are defined, specify which registers belong to which 116// register classes. This also defines the default allocation order of 117// registers by register allocators. 118// 119class RegisterClass<string namespace, list<ValueType> regTypes, int alignment, 120 dag regList, RegAltNameIndex idx = NoRegAltName> { 121 string Namespace = namespace; 122 123 // RegType - Specify the list ValueType of the registers in this register 124 // class. Note that all registers in a register class must have the same 125 // ValueTypes. This is a list because some targets permit storing different 126 // types in same register, for example vector values with 128-bit total size, 127 // but different count/size of items, like SSE on x86. 128 // 129 list<ValueType> RegTypes = regTypes; 130 131 // Size - Specify the spill size in bits of the registers. A default value of 132 // zero lets tablgen pick an appropriate size. 133 int Size = 0; 134 135 // Alignment - Specify the alignment required of the registers when they are 136 // stored or loaded to memory. 137 // 138 int Alignment = alignment; 139 140 // CopyCost - This value is used to specify the cost of copying a value 141 // between two registers in this register class. The default value is one 142 // meaning it takes a single instruction to perform the copying. A negative 143 // value means copying is extremely expensive or impossible. 144 int CopyCost = 1; 145 146 // MemberList - Specify which registers are in this class. If the 147 // allocation_order_* method are not specified, this also defines the order of 148 // allocation used by the register allocator. 149 // 150 dag MemberList = regList; 151 152 // AltNameIndex - The alternate register name to use when printing operands 153 // of this register class. Every register in the register class must have 154 // a valid alternate name for the given index. 155 RegAltNameIndex altNameIndex = idx; 156 157 // isAllocatable - Specify that the register class can be used for virtual 158 // registers and register allocation. Some register classes are only used to 159 // model instruction operand constraints, and should have isAllocatable = 0. 160 bit isAllocatable = 1; 161 162 // AltOrders - List of alternative allocation orders. The default order is 163 // MemberList itself, and that is good enough for most targets since the 164 // register allocators automatically remove reserved registers and move 165 // callee-saved registers to the end. 166 list<dag> AltOrders = []; 167 168 // AltOrderSelect - The body of a function that selects the allocation order 169 // to use in a given machine function. The code will be inserted in a 170 // function like this: 171 // 172 // static inline unsigned f(const MachineFunction &MF) { ... } 173 // 174 // The function should return 0 to select the default order defined by 175 // MemberList, 1 to select the first AltOrders entry and so on. 176 code AltOrderSelect = [{}]; 177} 178 179// The memberList in a RegisterClass is a dag of set operations. TableGen 180// evaluates these set operations and expand them into register lists. These 181// are the most common operation, see test/TableGen/SetTheory.td for more 182// examples of what is possible: 183// 184// (add R0, R1, R2) - Set Union. Each argument can be an individual register, a 185// register class, or a sub-expression. This is also the way to simply list 186// registers. 187// 188// (sub GPR, SP) - Set difference. Subtract the last arguments from the first. 189// 190// (and GPR, CSR) - Set intersection. All registers from the first set that are 191// also in the second set. 192// 193// (sequence "R%u", 0, 15) -> [R0, R1, ..., R15]. Generate a sequence of 194// numbered registers. Takes an optional 4th operand which is a stride to use 195// when generating the sequence. 196// 197// (shl GPR, 4) - Remove the first N elements. 198// 199// (trunc GPR, 4) - Truncate after the first N elements. 200// 201// (rotl GPR, 1) - Rotate N places to the left. 202// 203// (rotr GPR, 1) - Rotate N places to the right. 204// 205// (decimate GPR, 2) - Pick every N'th element, starting with the first. 206// 207// (interleave A, B, ...) - Interleave the elements from each argument list. 208// 209// All of these operators work on ordered sets, not lists. That means 210// duplicates are removed from sub-expressions. 211 212// Set operators. The rest is defined in TargetSelectionDAG.td. 213def sequence; 214def decimate; 215def interleave; 216 217// RegisterTuples - Automatically generate super-registers by forming tuples of 218// sub-registers. This is useful for modeling register sequence constraints 219// with pseudo-registers that are larger than the architectural registers. 220// 221// The sub-register lists are zipped together: 222// 223// def EvenOdd : RegisterTuples<[sube, subo], [(add R0, R2), (add R1, R3)]>; 224// 225// Generates the same registers as: 226// 227// let SubRegIndices = [sube, subo] in { 228// def R0_R1 : RegisterWithSubRegs<"", [R0, R1]>; 229// def R2_R3 : RegisterWithSubRegs<"", [R2, R3]>; 230// } 231// 232// The generated pseudo-registers inherit super-classes and fields from their 233// first sub-register. Most fields from the Register class are inferred, and 234// the AsmName and Dwarf numbers are cleared. 235// 236// RegisterTuples instances can be used in other set operations to form 237// register classes and so on. This is the only way of using the generated 238// registers. 239class RegisterTuples<list<SubRegIndex> Indices, list<dag> Regs> { 240 // SubRegs - N lists of registers to be zipped up. Super-registers are 241 // synthesized from the first element of each SubRegs list, the second 242 // element and so on. 243 list<dag> SubRegs = Regs; 244 245 // SubRegIndices - N SubRegIndex instances. This provides the names of the 246 // sub-registers in the synthesized super-registers. 247 list<SubRegIndex> SubRegIndices = Indices; 248 249 // Compose sub-register indices like in a normal Register. 250 list<dag> CompositeIndices = []; 251} 252 253 254//===----------------------------------------------------------------------===// 255// DwarfRegNum - This class provides a mapping of the llvm register enumeration 256// to the register numbering used by gcc and gdb. These values are used by a 257// debug information writer to describe where values may be located during 258// execution. 259class DwarfRegNum<list<int> Numbers> { 260 // DwarfNumbers - Numbers used internally by gcc/gdb to identify the register. 261 // These values can be determined by locating the <target>.h file in the 262 // directory llvmgcc/gcc/config/<target>/ and looking for REGISTER_NAMES. The 263 // order of these names correspond to the enumeration used by gcc. A value of 264 // -1 indicates that the gcc number is undefined and -2 that register number 265 // is invalid for this mode/flavour. 266 list<int> DwarfNumbers = Numbers; 267} 268 269// DwarfRegAlias - This class declares that a given register uses the same dwarf 270// numbers as another one. This is useful for making it clear that the two 271// registers do have the same number. It also lets us build a mapping 272// from dwarf register number to llvm register. 273class DwarfRegAlias<Register reg> { 274 Register DwarfAlias = reg; 275} 276 277//===----------------------------------------------------------------------===// 278// Pull in the common support for scheduling 279// 280include "llvm/Target/TargetSchedule.td" 281 282class Predicate; // Forward def 283 284//===----------------------------------------------------------------------===// 285// Instruction set description - These classes correspond to the C++ classes in 286// the Target/TargetInstrInfo.h file. 287// 288class Instruction { 289 string Namespace = ""; 290 291 dag OutOperandList; // An dag containing the MI def operand list. 292 dag InOperandList; // An dag containing the MI use operand list. 293 string AsmString = ""; // The .s format to print the instruction with. 294 295 // Pattern - Set to the DAG pattern for this instruction, if we know of one, 296 // otherwise, uninitialized. 297 list<dag> Pattern; 298 299 // The follow state will eventually be inferred automatically from the 300 // instruction pattern. 301 302 list<Register> Uses = []; // Default to using no non-operand registers 303 list<Register> Defs = []; // Default to modifying no non-operand registers 304 305 // Predicates - List of predicates which will be turned into isel matching 306 // code. 307 list<Predicate> Predicates = []; 308 309 // Size - Size of encoded instruction, or zero if the size cannot be determined 310 // from the opcode. 311 int Size = 0; 312 313 // DecoderNamespace - The "namespace" in which this instruction exists, on 314 // targets like ARM which multiple ISA namespaces exist. 315 string DecoderNamespace = ""; 316 317 // Code size, for instruction selection. 318 // FIXME: What does this actually mean? 319 int CodeSize = 0; 320 321 // Added complexity passed onto matching pattern. 322 int AddedComplexity = 0; 323 324 // These bits capture information about the high-level semantics of the 325 // instruction. 326 bit isReturn = 0; // Is this instruction a return instruction? 327 bit isBranch = 0; // Is this instruction a branch instruction? 328 bit isIndirectBranch = 0; // Is this instruction an indirect branch? 329 bit isCompare = 0; // Is this instruction a comparison instruction? 330 bit isMoveImm = 0; // Is this instruction a move immediate instruction? 331 bit isBitcast = 0; // Is this instruction a bitcast instruction? 332 bit isBarrier = 0; // Can control flow fall through this instruction? 333 bit isCall = 0; // Is this instruction a call instruction? 334 bit canFoldAsLoad = 0; // Can this be folded as a simple memory operand? 335 bit mayLoad = 0; // Is it possible for this inst to read memory? 336 bit mayStore = 0; // Is it possible for this inst to write memory? 337 bit isConvertibleToThreeAddress = 0; // Can this 2-addr instruction promote? 338 bit isCommutable = 0; // Is this 3 operand instruction commutable? 339 bit isTerminator = 0; // Is this part of the terminator for a basic block? 340 bit isReMaterializable = 0; // Is this instruction re-materializable? 341 bit isPredicable = 0; // Is this instruction predicable? 342 bit hasDelaySlot = 0; // Does this instruction have an delay slot? 343 bit usesCustomInserter = 0; // Pseudo instr needing special help. 344 bit hasPostISelHook = 0; // To be *adjusted* after isel by target hook. 345 bit hasCtrlDep = 0; // Does this instruction r/w ctrl-flow chains? 346 bit isNotDuplicable = 0; // Is it unsafe to duplicate this instruction? 347 bit isAsCheapAsAMove = 0; // As cheap (or cheaper) than a move instruction. 348 bit hasExtraSrcRegAllocReq = 0; // Sources have special regalloc requirement? 349 bit hasExtraDefRegAllocReq = 0; // Defs have special regalloc requirement? 350 bit isPseudo = 0; // Is this instruction a pseudo-instruction? 351 // If so, won't have encoding information for 352 // the [MC]CodeEmitter stuff. 353 354 // Side effect flags - When set, the flags have these meanings: 355 // 356 // hasSideEffects - The instruction has side effects that are not 357 // captured by any operands of the instruction or other flags. 358 // 359 // neverHasSideEffects - Set on an instruction with no pattern if it has no 360 // side effects. 361 bit hasSideEffects = 0; 362 bit neverHasSideEffects = 0; 363 364 // Is this instruction a "real" instruction (with a distinct machine 365 // encoding), or is it a pseudo instruction used for codegen modeling 366 // purposes. 367 // FIXME: For now this is distinct from isPseudo, above, as code-gen-only 368 // instructions can (and often do) still have encoding information 369 // associated with them. Once we've migrated all of them over to true 370 // pseudo-instructions that are lowered to real instructions prior to 371 // the printer/emitter, we can remove this attribute and just use isPseudo. 372 // 373 // The intended use is: 374 // isPseudo: Does not have encoding information and should be expanded, 375 // at the latest, during lowering to MCInst. 376 // 377 // isCodeGenOnly: Does have encoding information and can go through to the 378 // CodeEmitter unchanged, but duplicates a canonical instruction 379 // definition's encoding and should be ignored when constructing the 380 // assembler match tables. 381 bit isCodeGenOnly = 0; 382 383 // Is this instruction a pseudo instruction for use by the assembler parser. 384 bit isAsmParserOnly = 0; 385 386 InstrItinClass Itinerary = NoItinerary;// Execution steps used for scheduling. 387 388 string Constraints = ""; // OperandConstraint, e.g. $src = $dst. 389 390 /// DisableEncoding - List of operand names (e.g. "$op1,$op2") that should not 391 /// be encoded into the output machineinstr. 392 string DisableEncoding = ""; 393 394 string PostEncoderMethod = ""; 395 string DecoderMethod = ""; 396 397 /// Target-specific flags. This becomes the TSFlags field in TargetInstrDesc. 398 bits<64> TSFlags = 0; 399 400 ///@name Assembler Parser Support 401 ///@{ 402 403 string AsmMatchConverter = ""; 404 405 /// TwoOperandAliasConstraint - Enable TableGen to auto-generate a 406 /// two-operand matcher inst-alias for a three operand instruction. 407 /// For example, the arm instruction "add r3, r3, r5" can be written 408 /// as "add r3, r5". The constraint is of the same form as a tied-operand 409 /// constraint. For example, "$Rn = $Rd". 410 string TwoOperandAliasConstraint = ""; 411 412 ///@} 413} 414 415/// PseudoInstExpansion - Expansion information for a pseudo-instruction. 416/// Which instruction it expands to and how the operands map from the 417/// pseudo. 418class PseudoInstExpansion<dag Result> { 419 dag ResultInst = Result; // The instruction to generate. 420 bit isPseudo = 1; 421} 422 423/// Predicates - These are extra conditionals which are turned into instruction 424/// selector matching code. Currently each predicate is just a string. 425class Predicate<string cond> { 426 string CondString = cond; 427 428 /// AssemblerMatcherPredicate - If this feature can be used by the assembler 429 /// matcher, this is true. Targets should set this by inheriting their 430 /// feature from the AssemblerPredicate class in addition to Predicate. 431 bit AssemblerMatcherPredicate = 0; 432 433 /// AssemblerCondString - Name of the subtarget feature being tested used 434 /// as alternative condition string used for assembler matcher. 435 /// e.g. "ModeThumb" is translated to "(Bits & ModeThumb) != 0". 436 /// "!ModeThumb" is translated to "(Bits & ModeThumb) == 0". 437 /// It can also list multiple features separated by ",". 438 /// e.g. "ModeThumb,FeatureThumb2" is translated to 439 /// "(Bits & ModeThumb) != 0 && (Bits & FeatureThumb2) != 0". 440 string AssemblerCondString = ""; 441 442 /// PredicateName - User-level name to use for the predicate. Mainly for use 443 /// in diagnostics such as missing feature errors in the asm matcher. 444 string PredicateName = ""; 445} 446 447/// NoHonorSignDependentRounding - This predicate is true if support for 448/// sign-dependent-rounding is not enabled. 449def NoHonorSignDependentRounding 450 : Predicate<"!TM.Options.HonorSignDependentRoundingFPMath()">; 451 452class Requires<list<Predicate> preds> { 453 list<Predicate> Predicates = preds; 454} 455 456/// ops definition - This is just a simple marker used to identify the operand 457/// list for an instruction. outs and ins are identical both syntactically and 458/// semanticallyr; they are used to define def operands and use operands to 459/// improve readibility. This should be used like this: 460/// (outs R32:$dst), (ins R32:$src1, R32:$src2) or something similar. 461def ops; 462def outs; 463def ins; 464 465/// variable_ops definition - Mark this instruction as taking a variable number 466/// of operands. 467def variable_ops; 468 469 470/// PointerLikeRegClass - Values that are designed to have pointer width are 471/// derived from this. TableGen treats the register class as having a symbolic 472/// type that it doesn't know, and resolves the actual regclass to use by using 473/// the TargetRegisterInfo::getPointerRegClass() hook at codegen time. 474class PointerLikeRegClass<int Kind> { 475 int RegClassKind = Kind; 476} 477 478 479/// ptr_rc definition - Mark this operand as being a pointer value whose 480/// register class is resolved dynamically via a callback to TargetInstrInfo. 481/// FIXME: We should probably change this to a class which contain a list of 482/// flags. But currently we have but one flag. 483def ptr_rc : PointerLikeRegClass<0>; 484 485/// unknown definition - Mark this operand as being of unknown type, causing 486/// it to be resolved by inference in the context it is used. 487def unknown; 488 489/// AsmOperandClass - Representation for the kinds of operands which the target 490/// specific parser can create and the assembly matcher may need to distinguish. 491/// 492/// Operand classes are used to define the order in which instructions are 493/// matched, to ensure that the instruction which gets matched for any 494/// particular list of operands is deterministic. 495/// 496/// The target specific parser must be able to classify a parsed operand into a 497/// unique class which does not partially overlap with any other classes. It can 498/// match a subset of some other class, in which case the super class field 499/// should be defined. 500class AsmOperandClass { 501 /// The name to use for this class, which should be usable as an enum value. 502 string Name = ?; 503 504 /// The super classes of this operand. 505 list<AsmOperandClass> SuperClasses = []; 506 507 /// The name of the method on the target specific operand to call to test 508 /// whether the operand is an instance of this class. If not set, this will 509 /// default to "isFoo", where Foo is the AsmOperandClass name. The method 510 /// signature should be: 511 /// bool isFoo() const; 512 string PredicateMethod = ?; 513 514 /// The name of the method on the target specific operand to call to add the 515 /// target specific operand to an MCInst. If not set, this will default to 516 /// "addFooOperands", where Foo is the AsmOperandClass name. The method 517 /// signature should be: 518 /// void addFooOperands(MCInst &Inst, unsigned N) const; 519 string RenderMethod = ?; 520 521 /// The name of the method on the target specific operand to call to custom 522 /// handle the operand parsing. This is useful when the operands do not relate 523 /// to immediates or registers and are very instruction specific (as flags to 524 /// set in a processor register, coprocessor number, ...). 525 string ParserMethod = ?; 526} 527 528def ImmAsmOperand : AsmOperandClass { 529 let Name = "Imm"; 530} 531 532/// Operand Types - These provide the built-in operand types that may be used 533/// by a target. Targets can optionally provide their own operand types as 534/// needed, though this should not be needed for RISC targets. 535class Operand<ValueType ty> { 536 ValueType Type = ty; 537 string PrintMethod = "printOperand"; 538 string EncoderMethod = ""; 539 string DecoderMethod = ""; 540 string AsmOperandLowerMethod = ?; 541 string OperandType = "OPERAND_UNKNOWN"; 542 dag MIOperandInfo = (ops); 543 544 // ParserMatchClass - The "match class" that operands of this type fit 545 // in. Match classes are used to define the order in which instructions are 546 // match, to ensure that which instructions gets matched is deterministic. 547 // 548 // The target specific parser must be able to classify an parsed operand into 549 // a unique class, which does not partially overlap with any other classes. It 550 // can match a subset of some other class, in which case the AsmOperandClass 551 // should declare the other operand as one of its super classes. 552 AsmOperandClass ParserMatchClass = ImmAsmOperand; 553} 554 555class RegisterOperand<RegisterClass regclass, string pm = "printOperand"> { 556 // RegClass - The register class of the operand. 557 RegisterClass RegClass = regclass; 558 // PrintMethod - The target method to call to print register operands of 559 // this type. The method normally will just use an alt-name index to look 560 // up the name to print. Default to the generic printOperand(). 561 string PrintMethod = pm; 562 // ParserMatchClass - The "match class" that operands of this type fit 563 // in. Match classes are used to define the order in which instructions are 564 // match, to ensure that which instructions gets matched is deterministic. 565 // 566 // The target specific parser must be able to classify an parsed operand into 567 // a unique class, which does not partially overlap with any other classes. It 568 // can match a subset of some other class, in which case the AsmOperandClass 569 // should declare the other operand as one of its super classes. 570 AsmOperandClass ParserMatchClass; 571} 572 573let OperandType = "OPERAND_IMMEDIATE" in { 574def i1imm : Operand<i1>; 575def i8imm : Operand<i8>; 576def i16imm : Operand<i16>; 577def i32imm : Operand<i32>; 578def i64imm : Operand<i64>; 579 580def f32imm : Operand<f32>; 581def f64imm : Operand<f64>; 582} 583 584/// zero_reg definition - Special node to stand for the zero register. 585/// 586def zero_reg; 587 588/// PredicateOperand - This can be used to define a predicate operand for an 589/// instruction. OpTypes specifies the MIOperandInfo for the operand, and 590/// AlwaysVal specifies the value of this predicate when set to "always 591/// execute". 592class PredicateOperand<ValueType ty, dag OpTypes, dag AlwaysVal> 593 : Operand<ty> { 594 let MIOperandInfo = OpTypes; 595 dag DefaultOps = AlwaysVal; 596} 597 598/// OptionalDefOperand - This is used to define a optional definition operand 599/// for an instruction. DefaultOps is the register the operand represents if 600/// none is supplied, e.g. zero_reg. 601class OptionalDefOperand<ValueType ty, dag OpTypes, dag defaultops> 602 : Operand<ty> { 603 let MIOperandInfo = OpTypes; 604 dag DefaultOps = defaultops; 605} 606 607 608// InstrInfo - This class should only be instantiated once to provide parameters 609// which are global to the target machine. 610// 611class InstrInfo { 612 // Target can specify its instructions in either big or little-endian formats. 613 // For instance, while both Sparc and PowerPC are big-endian platforms, the 614 // Sparc manual specifies its instructions in the format [31..0] (big), while 615 // PowerPC specifies them using the format [0..31] (little). 616 bit isLittleEndianEncoding = 0; 617} 618 619// Standard Pseudo Instructions. 620// This list must match TargetOpcodes.h and CodeGenTarget.cpp. 621// Only these instructions are allowed in the TargetOpcode namespace. 622let isCodeGenOnly = 1, isPseudo = 1, Namespace = "TargetOpcode" in { 623def PHI : Instruction { 624 let OutOperandList = (outs); 625 let InOperandList = (ins variable_ops); 626 let AsmString = "PHINODE"; 627} 628def INLINEASM : Instruction { 629 let OutOperandList = (outs); 630 let InOperandList = (ins variable_ops); 631 let AsmString = ""; 632 let neverHasSideEffects = 1; // Note side effect is encoded in an operand. 633} 634def PROLOG_LABEL : Instruction { 635 let OutOperandList = (outs); 636 let InOperandList = (ins i32imm:$id); 637 let AsmString = ""; 638 let hasCtrlDep = 1; 639 let isNotDuplicable = 1; 640} 641def EH_LABEL : Instruction { 642 let OutOperandList = (outs); 643 let InOperandList = (ins i32imm:$id); 644 let AsmString = ""; 645 let hasCtrlDep = 1; 646 let isNotDuplicable = 1; 647} 648def GC_LABEL : Instruction { 649 let OutOperandList = (outs); 650 let InOperandList = (ins i32imm:$id); 651 let AsmString = ""; 652 let hasCtrlDep = 1; 653 let isNotDuplicable = 1; 654} 655def KILL : Instruction { 656 let OutOperandList = (outs); 657 let InOperandList = (ins variable_ops); 658 let AsmString = ""; 659 let neverHasSideEffects = 1; 660} 661def EXTRACT_SUBREG : Instruction { 662 let OutOperandList = (outs unknown:$dst); 663 let InOperandList = (ins unknown:$supersrc, i32imm:$subidx); 664 let AsmString = ""; 665 let neverHasSideEffects = 1; 666} 667def INSERT_SUBREG : Instruction { 668 let OutOperandList = (outs unknown:$dst); 669 let InOperandList = (ins unknown:$supersrc, unknown:$subsrc, i32imm:$subidx); 670 let AsmString = ""; 671 let neverHasSideEffects = 1; 672 let Constraints = "$supersrc = $dst"; 673} 674def IMPLICIT_DEF : Instruction { 675 let OutOperandList = (outs unknown:$dst); 676 let InOperandList = (ins); 677 let AsmString = ""; 678 let neverHasSideEffects = 1; 679 let isReMaterializable = 1; 680 let isAsCheapAsAMove = 1; 681} 682def SUBREG_TO_REG : Instruction { 683 let OutOperandList = (outs unknown:$dst); 684 let InOperandList = (ins unknown:$implsrc, unknown:$subsrc, i32imm:$subidx); 685 let AsmString = ""; 686 let neverHasSideEffects = 1; 687} 688def COPY_TO_REGCLASS : Instruction { 689 let OutOperandList = (outs unknown:$dst); 690 let InOperandList = (ins unknown:$src, i32imm:$regclass); 691 let AsmString = ""; 692 let neverHasSideEffects = 1; 693 let isAsCheapAsAMove = 1; 694} 695def DBG_VALUE : Instruction { 696 let OutOperandList = (outs); 697 let InOperandList = (ins variable_ops); 698 let AsmString = "DBG_VALUE"; 699 let neverHasSideEffects = 1; 700} 701def REG_SEQUENCE : Instruction { 702 let OutOperandList = (outs unknown:$dst); 703 let InOperandList = (ins variable_ops); 704 let AsmString = ""; 705 let neverHasSideEffects = 1; 706 let isAsCheapAsAMove = 1; 707} 708def COPY : Instruction { 709 let OutOperandList = (outs unknown:$dst); 710 let InOperandList = (ins unknown:$src); 711 let AsmString = ""; 712 let neverHasSideEffects = 1; 713 let isAsCheapAsAMove = 1; 714} 715def BUNDLE : Instruction { 716 let OutOperandList = (outs); 717 let InOperandList = (ins variable_ops); 718 let AsmString = "BUNDLE"; 719} 720} 721 722//===----------------------------------------------------------------------===// 723// AsmParser - This class can be implemented by targets that wish to implement 724// .s file parsing. 725// 726// Subtargets can have multiple different assembly parsers (e.g. AT&T vs Intel 727// syntax on X86 for example). 728// 729class AsmParser { 730 // AsmParserClassName - This specifies the suffix to use for the asmparser 731 // class. Generated AsmParser classes are always prefixed with the target 732 // name. 733 string AsmParserClassName = "AsmParser"; 734 735 // AsmParserInstCleanup - If non-empty, this is the name of a custom member 736 // function of the AsmParser class to call on every matched instruction. 737 // This can be used to perform target specific instruction post-processing. 738 string AsmParserInstCleanup = ""; 739} 740def DefaultAsmParser : AsmParser; 741 742//===----------------------------------------------------------------------===// 743// AsmParserVariant - Subtargets can have multiple different assembly parsers 744// (e.g. AT&T vs Intel syntax on X86 for example). This class can be 745// implemented by targets to describe such variants. 746// 747class AsmParserVariant { 748 // Variant - AsmParsers can be of multiple different variants. Variants are 749 // used to support targets that need to parser multiple formats for the 750 // assembly language. 751 int Variant = 0; 752 753 // CommentDelimiter - If given, the delimiter string used to recognize 754 // comments which are hard coded in the .td assembler strings for individual 755 // instructions. 756 string CommentDelimiter = ""; 757 758 // RegisterPrefix - If given, the token prefix which indicates a register 759 // token. This is used by the matcher to automatically recognize hard coded 760 // register tokens as constrained registers, instead of tokens, for the 761 // purposes of matching. 762 string RegisterPrefix = ""; 763} 764def DefaultAsmParserVariant : AsmParserVariant; 765 766/// AssemblerPredicate - This is a Predicate that can be used when the assembler 767/// matches instructions and aliases. 768class AssemblerPredicate<string cond, string name = ""> { 769 bit AssemblerMatcherPredicate = 1; 770 string AssemblerCondString = cond; 771 string PredicateName = name; 772} 773 774/// TokenAlias - This class allows targets to define assembler token 775/// operand aliases. That is, a token literal operand which is equivalent 776/// to another, canonical, token literal. For example, ARM allows: 777/// vmov.u32 s4, #0 -> vmov.i32, #0 778/// 'u32' is a more specific designator for the 32-bit integer type specifier 779/// and is legal for any instruction which accepts 'i32' as a datatype suffix. 780/// def : TokenAlias<".u32", ".i32">; 781/// 782/// This works by marking the match class of 'From' as a subclass of the 783/// match class of 'To'. 784class TokenAlias<string From, string To> { 785 string FromToken = From; 786 string ToToken = To; 787} 788 789/// MnemonicAlias - This class allows targets to define assembler mnemonic 790/// aliases. This should be used when all forms of one mnemonic are accepted 791/// with a different mnemonic. For example, X86 allows: 792/// sal %al, 1 -> shl %al, 1 793/// sal %ax, %cl -> shl %ax, %cl 794/// sal %eax, %cl -> shl %eax, %cl 795/// etc. Though "sal" is accepted with many forms, all of them are directly 796/// translated to a shl, so it can be handled with (in the case of X86, it 797/// actually has one for each suffix as well): 798/// def : MnemonicAlias<"sal", "shl">; 799/// 800/// Mnemonic aliases are mapped before any other translation in the match phase, 801/// and do allow Requires predicates, e.g.: 802/// 803/// def : MnemonicAlias<"pushf", "pushfq">, Requires<[In64BitMode]>; 804/// def : MnemonicAlias<"pushf", "pushfl">, Requires<[In32BitMode]>; 805/// 806class MnemonicAlias<string From, string To> { 807 string FromMnemonic = From; 808 string ToMnemonic = To; 809 810 // Predicates - Predicates that must be true for this remapping to happen. 811 list<Predicate> Predicates = []; 812} 813 814/// InstAlias - This defines an alternate assembly syntax that is allowed to 815/// match an instruction that has a different (more canonical) assembly 816/// representation. 817class InstAlias<string Asm, dag Result, bit Emit = 0b1> { 818 string AsmString = Asm; // The .s format to match the instruction with. 819 dag ResultInst = Result; // The MCInst to generate. 820 bit EmitAlias = Emit; // Emit the alias instead of what's aliased. 821 822 // Predicates - Predicates that must be true for this to match. 823 list<Predicate> Predicates = []; 824} 825 826//===----------------------------------------------------------------------===// 827// AsmWriter - This class can be implemented by targets that need to customize 828// the format of the .s file writer. 829// 830// Subtargets can have multiple different asmwriters (e.g. AT&T vs Intel syntax 831// on X86 for example). 832// 833class AsmWriter { 834 // AsmWriterClassName - This specifies the suffix to use for the asmwriter 835 // class. Generated AsmWriter classes are always prefixed with the target 836 // name. 837 string AsmWriterClassName = "AsmPrinter"; 838 839 // Variant - AsmWriters can be of multiple different variants. Variants are 840 // used to support targets that need to emit assembly code in ways that are 841 // mostly the same for different targets, but have minor differences in 842 // syntax. If the asmstring contains {|} characters in them, this integer 843 // will specify which alternative to use. For example "{x|y|z}" with Variant 844 // == 1, will expand to "y". 845 int Variant = 0; 846 847 848 // FirstOperandColumn/OperandSpacing - If the assembler syntax uses a columnar 849 // layout, the asmwriter can actually generate output in this columns (in 850 // verbose-asm mode). These two values indicate the width of the first column 851 // (the "opcode" area) and the width to reserve for subsequent operands. When 852 // verbose asm mode is enabled, operands will be indented to respect this. 853 int FirstOperandColumn = -1; 854 855 // OperandSpacing - Space between operand columns. 856 int OperandSpacing = -1; 857 858 // isMCAsmWriter - Is this assembly writer for an MC emitter? This controls 859 // generation of the printInstruction() method. For MC printers, it takes 860 // an MCInstr* operand, otherwise it takes a MachineInstr*. 861 bit isMCAsmWriter = 0; 862} 863def DefaultAsmWriter : AsmWriter; 864 865 866//===----------------------------------------------------------------------===// 867// Target - This class contains the "global" target information 868// 869class Target { 870 // InstructionSet - Instruction set description for this target. 871 InstrInfo InstructionSet; 872 873 // AssemblyParsers - The AsmParser instances available for this target. 874 list<AsmParser> AssemblyParsers = [DefaultAsmParser]; 875 876 /// AssemblyParserVariants - The AsmParserVariant instances available for 877 /// this target. 878 list<AsmParserVariant> AssemblyParserVariants = [DefaultAsmParserVariant]; 879 880 // AssemblyWriters - The AsmWriter instances available for this target. 881 list<AsmWriter> AssemblyWriters = [DefaultAsmWriter]; 882} 883 884//===----------------------------------------------------------------------===// 885// SubtargetFeature - A characteristic of the chip set. 886// 887class SubtargetFeature<string n, string a, string v, string d, 888 list<SubtargetFeature> i = []> { 889 // Name - Feature name. Used by command line (-mattr=) to determine the 890 // appropriate target chip. 891 // 892 string Name = n; 893 894 // Attribute - Attribute to be set by feature. 895 // 896 string Attribute = a; 897 898 // Value - Value the attribute to be set to by feature. 899 // 900 string Value = v; 901 902 // Desc - Feature description. Used by command line (-mattr=) to display help 903 // information. 904 // 905 string Desc = d; 906 907 // Implies - Features that this feature implies are present. If one of those 908 // features isn't set, then this one shouldn't be set either. 909 // 910 list<SubtargetFeature> Implies = i; 911} 912 913//===----------------------------------------------------------------------===// 914// Processor chip sets - These values represent each of the chip sets supported 915// by the scheduler. Each Processor definition requires corresponding 916// instruction itineraries. 917// 918class Processor<string n, ProcessorItineraries pi, list<SubtargetFeature> f> { 919 // Name - Chip set name. Used by command line (-mcpu=) to determine the 920 // appropriate target chip. 921 // 922 string Name = n; 923 924 // ProcItin - The scheduling information for the target processor. 925 // 926 ProcessorItineraries ProcItin = pi; 927 928 // Features - list of 929 list<SubtargetFeature> Features = f; 930} 931 932//===----------------------------------------------------------------------===// 933// Pull in the common support for calling conventions. 934// 935include "llvm/Target/TargetCallingConv.td" 936 937//===----------------------------------------------------------------------===// 938// Pull in the common support for DAG isel generation. 939// 940include "llvm/Target/TargetSelectionDAG.td" 941