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