← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to include/llvm/Target/TargetCallingConv.td

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/llvm/Target/TargetCallingConv.td
 
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
 
 
15
class CCAction;
 
16
class CallingConv;
 
17
 
 
18
/// CCCustom - Calls a custom arg handling function.
 
19
class 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.
 
25
class 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.
 
31
class CCIfType<list<ValueType> vts, CCAction A> : CCPredicateAction<A> {
 
32
  list<ValueType> VTs = vts;
 
33
}
 
34
 
 
35
/// CCIf - If the predicate matches, apply A.
 
36
class 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.
 
42
class CCIfByVal<CCAction A> : CCIf<"ArgFlags.isByVal()", A> {
 
43
}
 
44
 
 
45
/// CCIfConsecutiveRegs - If the current argument has InConsecutiveRegs
 
46
/// parameter attribute, apply Action A.
 
47
class CCIfConsecutiveRegs<CCAction A> : CCIf<"ArgFlags.isInConsecutiveRegs()", A> {
 
48
}
 
49
 
 
50
/// CCIfCC - Match if the current calling convention is 'CC'.
 
51
class CCIfCC<string CC, CCAction A>
 
52
  : CCIf<!strconcat("State.getCallingConv() == ", CC), A> {}
 
53
 
 
54
/// CCIfInReg - If this argument is marked with the 'inreg' attribute, apply
 
55
/// the specified action.
 
56
class CCIfInReg<CCAction A> : CCIf<"ArgFlags.isInReg()", A> {}
 
57
 
 
58
/// CCIfNest - If this argument is marked with the 'nest' attribute, apply
 
59
/// the specified action.
 
60
class CCIfNest<CCAction A> : CCIf<"ArgFlags.isNest()", A> {}
 
61
 
 
62
/// CCIfSplit - If this argument is marked with the 'split' attribute, apply
 
63
/// the specified action.
 
64
class CCIfSplit<CCAction A> : CCIf<"ArgFlags.isSplit()", A> {}
 
65
 
 
66
/// CCIfSRet - If this argument is marked with the 'sret' attribute, apply
 
67
/// the specified action.
 
68
class CCIfSRet<CCAction A> : CCIf<"ArgFlags.isSRet()", A> {}
 
69
 
 
70
/// CCIfVarArg - If the current function is vararg - apply the action
 
71
class CCIfVarArg<CCAction A> : CCIf<"State.isVarArg()", A> {}
 
72
 
 
73
/// CCIfNotVarArg - If the current function is not vararg - apply the action
 
74
class CCIfNotVarArg<CCAction A> : CCIf<"!State.isVarArg()", A> {}
 
75
 
 
76
/// CCAssignToReg - This action matches if there is a register in the specified
 
77
/// list that is still available.  If so, it assigns the value to the first
 
78
/// available register and succeeds.
 
79
class CCAssignToReg<list<Register> regList> : CCAction {
 
80
  list<Register> RegList = regList;
 
81
}
 
82
 
 
83
/// CCAssignToRegWithShadow - Same as CCAssignToReg, but with list of registers
 
84
/// which became shadowed, when some register is used.
 
85
class CCAssignToRegWithShadow<list<Register> regList,
 
86
                              list<Register> shadowList> : CCAction {
 
87
  list<Register> RegList = regList;
 
88
  list<Register> ShadowRegList = shadowList;
 
89
}
 
90
 
 
91
/// CCAssignToStack - This action always matches: it assigns the value to a
 
92
/// stack slot of the specified size and alignment on the stack.  If size is
 
93
/// zero then the ABI size is used; if align is zero then the ABI alignment
 
94
/// is used - these may depend on the target or subtarget.
 
95
class CCAssignToStack<int size, int align> : CCAction {
 
96
  int Size = size;
 
97
  int Align = align;
 
98
}
 
99
 
 
100
/// CCAssignToStackWithShadow - Same as CCAssignToStack, but with a list of
 
101
/// registers to be shadowed. Note that, unlike CCAssignToRegWithShadow, this
 
102
/// shadows ALL of the registers in shadowList.
 
103
class CCAssignToStackWithShadow<int size,
 
104
                                int align,
 
105
                                list<Register> shadowList> : CCAction {
 
106
  int Size = size;
 
107
  int Align = align;
 
108
  list<Register> ShadowRegList = shadowList;
 
109
}
 
110
 
 
111
/// CCPassByVal - This action always matches: it assigns the value to a stack
 
112
/// slot to implement ByVal aggregate parameter passing. Size and alignment
 
113
/// specify the minimum size and alignment for the stack slot.
 
114
class CCPassByVal<int size, int align> : CCAction {
 
115
  int Size = size;
 
116
  int Align = align;
 
117
}
 
118
 
 
119
/// CCPromoteToType - If applied, this promotes the specified current value to
 
120
/// the specified type.
 
121
class CCPromoteToType<ValueType destTy> : CCAction {
 
122
  ValueType DestTy = destTy;
 
123
}
 
124
 
 
125
/// CCPromoteToUpperBitsInType - If applied, this promotes the specified current
 
126
/// value to the specified type and shifts the value into the upper bits.
 
127
class CCPromoteToUpperBitsInType<ValueType destTy> : CCAction {
 
128
  ValueType DestTy = destTy;
 
129
}
 
130
 
 
131
/// CCBitConvertToType - If applied, this bitconverts the specified current
 
132
/// value to the specified type.
 
133
class CCBitConvertToType<ValueType destTy> : CCAction {
 
134
  ValueType DestTy = destTy;
 
135
}
 
136
 
 
137
/// CCPassIndirect - If applied, this stores the value to stack and passes the pointer
 
138
/// as normal argument.
 
139
class CCPassIndirect<ValueType destTy> : CCAction {
 
140
  ValueType DestTy = destTy;
 
141
}
 
142
 
 
143
/// CCDelegateTo - This action invokes the specified sub-calling-convention.  It
 
144
/// is successful if the specified CC matches.
 
145
class CCDelegateTo<CallingConv cc> : CCAction {
 
146
  CallingConv CC = cc;
 
147
}
 
148
 
 
149
/// CallingConv - An instance of this is used to define each calling convention
 
150
/// that the target supports.
 
151
class CallingConv<list<CCAction> actions> {
 
152
  list<CCAction> Actions = actions;
 
153
  bit Custom = 0;
 
154
}
 
155
 
 
156
/// CustomCallingConv - An instance of this is used to declare calling
 
157
/// conventions that are implemented using a custom function of the same name.
 
158
class CustomCallingConv : CallingConv<[]> {
 
159
  let Custom = 1;
 
160
}
 
161
 
 
162
/// CalleeSavedRegs - A list of callee saved registers for a given calling
 
163
/// convention.  The order of registers is used by PrologEpilogInsertion when
 
164
/// allocation stack slots for saved registers.
 
165
///
 
166
/// For each CalleeSavedRegs def, TableGen will emit a FOO_SaveList array for
 
167
/// returning from getCalleeSavedRegs(), and a FOO_RegMask bit mask suitable for
 
168
/// returning from getCallPreservedMask().
 
169
class CalleeSavedRegs<dag saves> {
 
170
  dag SaveList = saves;
 
171
 
 
172
  // Registers that are also preserved across function calls, but should not be
 
173
  // included in the generated FOO_SaveList array. These registers will be
 
174
  // included in the FOO_RegMask bit mask. This can be used for registers that
 
175
  // are saved automatically, like the SPARC register windows.
 
176
  dag OtherPreserved;
 
177
}