TargetCallingConv.td revision 027fdbe3ba6762b9867c6f891d64f76b7d6a4557
1//===- TargetCallingConv.td - Target Calling Conventions ---*- 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 with which targets 11// describe their calling conventions. 12// 13//===----------------------------------------------------------------------===// 14 15class CCAction; 16class CallingConv; 17 18/// CCPredicateAction - Instances of this class check some predicate, then 19/// delegate to another action if the predicate is true. 20class CCPredicateAction<CCAction A> : CCAction { 21 CCAction SubAction = A; 22} 23 24/// CCIfType - If the current argument is one of the specified types, apply 25/// Action A. 26class CCIfType<list<ValueType> vts, CCAction A> : CCPredicateAction<A> { 27 list<ValueType> VTs = vts; 28} 29 30/// CCIf - If the predicate matches, apply A. 31class CCIf<string predicate, CCAction A> : CCPredicateAction<A> { 32 string Predicate = predicate; 33} 34 35/// CCIfByVal - If the current argument has ByVal parameter attribute, apply 36/// Action A. 37class CCIfByVal<CCAction A> : CCIf<"ArgFlags.isByVal()", A> { 38} 39 40/// CCIfCC - Match of the current calling convention is 'CC'. 41class CCIfCC<string CC, CCAction A> 42 : CCIf<!strconcat("State.getCallingConv() == ", CC), A> {} 43 44/// CCIfInReg - If this argument is marked with the 'inreg' attribute, apply 45/// the specified action. 46class CCIfInReg<CCAction A> : CCIf<"ArgFlags.isInReg()", A> {} 47 48/// CCIfNest - If this argument is marked with the 'nest' attribute, apply 49/// the specified action. 50class CCIfNest<CCAction A> : CCIf<"ArgFlags.isNest()", A> {} 51 52/// CCIfNotVarArg - If the current function is not vararg - apply the action 53class CCIfNotVarArg<CCAction A> : CCIf<"!State.isVarArg()", A> {} 54 55/// CCAssignToReg - This action matches if there is a register in the specified 56/// list that is still available. If so, it assigns the value to the first 57/// available register and succeeds. 58class CCAssignToReg<list<Register> regList> : CCAction { 59 list<Register> RegList = regList; 60} 61 62/// CCAssignToRegWithShadow - Same as CCAssignToReg, but with list of registers 63/// which became shadowed, when some register is used. 64class CCAssignToRegWithShadow<list<Register> regList, 65 list<Register> shadowList> : CCAction { 66 list<Register> RegList = regList; 67 list<Register> ShadowRegList = shadowList; 68} 69 70/// CCAssignToStack - This action always matches: it assigns the value to a 71/// stack slot of the specified size and alignment on the stack. If size is 72/// zero then the ABI size is used; if align is zero then the ABI alignment 73/// is used - these may depend on the target or subtarget. 74class CCAssignToStack<int size, int align> : CCAction { 75 int Size = size; 76 int Align = align; 77} 78 79/// CCPassByVal - This action always matches: it assigns the value to a stack 80/// slot to implement ByVal aggregate parameter passing. Size and alignment 81/// specify the minimum size and alignment for the stack slot. 82class CCPassByVal<int size, int align> : CCAction { 83 int Size = size; 84 int Align = align; 85} 86 87/// CCPromoteToType - If applied, this promotes the specified current value to 88/// the specified type. 89class CCPromoteToType<ValueType destTy> : CCAction { 90 ValueType DestTy = destTy; 91} 92 93/// CCDelegateTo - This action invokes the specified sub-calling-convention. It 94/// is successful if the specified CC matches. 95class CCDelegateTo<CallingConv cc> : CCAction { 96 CallingConv CC = cc; 97} 98 99/// CallingConv - An instance of this is used to define each calling convention 100/// that the target supports. 101class CallingConv<list<CCAction> actions> { 102 list<CCAction> Actions = actions; 103} 104