|
145
|
1 /* Information about fuunction binary interfaces.
|
|
|
2 Copyright (C) 2019-2020 Free Software Foundation, Inc.
|
|
|
3
|
|
|
4 This file is part of GCC
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it under
|
|
|
7 the terms of the GNU General Public License as published by the Free
|
|
|
8 Software Foundation; either version 3, or (at your option) any later
|
|
|
9 version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 You should have received a copy of the GNU General Public License
|
|
|
17 along with GCC; see the file COPYING3. If not see
|
|
|
18 <http://www.gnu.org/licenses/>. */
|
|
|
19
|
|
|
20 #ifndef GCC_FUNCTION_ABI_H
|
|
|
21 #define GCC_FUNCTION_ABI_H
|
|
|
22
|
|
|
23 /* Most targets use the same ABI for all functions in a translation
|
|
|
24 unit, but some targets support interoperability between several ABIs.
|
|
|
25 Each such ABI has a unique 0-based identifier, with 0 always being
|
|
|
26 the default choice of ABI.
|
|
|
27
|
|
|
28 NUM_ABI_IDS is the maximum number of such ABIs that GCC can handle at once.
|
|
|
29 A bitfield with this number of bits can represent any combinaion of the
|
|
|
30 supported ABIs. */
|
|
|
31 const size_t NUM_ABI_IDS = 8;
|
|
|
32
|
|
|
33 /* Information about one of the target's predefined ABIs. */
|
|
|
34 class predefined_function_abi
|
|
|
35 {
|
|
|
36 public:
|
|
|
37 /* A target-specific identifier for this ABI. The value must be in
|
|
|
38 the range [0, NUM_ABI_IDS - 1]. */
|
|
|
39 unsigned int id () const { return m_id; }
|
|
|
40
|
|
|
41 /* True if this ABI has been initialized. */
|
|
|
42 bool initialized_p () const { return m_initialized; }
|
|
|
43
|
|
|
44 /* Return true if a function call is allowed to alter every bit of
|
|
|
45 register REGNO, so that the register contains an arbitrary value
|
|
|
46 on return. If so, the register cannot hold any part of a value
|
|
|
47 that is live across a call. */
|
|
|
48 bool
|
|
|
49 clobbers_full_reg_p (unsigned int regno) const
|
|
|
50 {
|
|
|
51 return TEST_HARD_REG_BIT (m_full_reg_clobbers, regno);
|
|
|
52 }
|
|
|
53
|
|
|
54 /* Return true if a function call is allowed to alter some or all bits
|
|
|
55 of register REGNO.
|
|
|
56
|
|
|
57 This is true whenever clobbers_full_reg_p (REGNO) is true. It is
|
|
|
58 also true if, for example, the ABI says that a call must preserve the
|
|
|
59 low 32 or 64 bits of REGNO, but can clobber the upper bits of REGNO.
|
|
|
60 In the latter case, it is possible for REGNO to hold values that
|
|
|
61 are live across a call, provided that the value occupies only the
|
|
|
62 call-preserved part of the register. */
|
|
|
63 bool
|
|
|
64 clobbers_at_least_part_of_reg_p (unsigned int regno) const
|
|
|
65 {
|
|
|
66 return TEST_HARD_REG_BIT (m_full_and_partial_reg_clobbers, regno);
|
|
|
67 }
|
|
|
68
|
|
|
69 /* Return true if a function call is allowed to clobber at least part
|
|
|
70 of (reg:MODE REGNO). If so, it is not possible for the register
|
|
|
71 as a whole to be live across a call. */
|
|
|
72 bool
|
|
|
73 clobbers_reg_p (machine_mode mode, unsigned int regno) const
|
|
|
74 {
|
|
|
75 return overlaps_hard_reg_set_p (m_mode_clobbers[mode], mode, regno);
|
|
|
76 }
|
|
|
77
|
|
|
78 /* Return the set of registers that a function call is allowed to
|
|
|
79 alter completely, so that the registers contain arbitrary values
|
|
|
80 on return. This doesn't include registers that a call can only
|
|
|
81 partly clobber (as per TARGET_HARD_REGNO_CALL_PART_CLOBBERED).
|
|
|
82
|
|
|
83 These registers cannot hold any part of a value that is live across
|
|
|
84 a call. */
|
|
|
85 HARD_REG_SET full_reg_clobbers () const { return m_full_reg_clobbers; }
|
|
|
86
|
|
|
87 /* Return the set of registers that a function call is allowed to alter
|
|
|
88 to some degree. For example, if an ABI says that a call must preserve
|
|
|
89 the low 32 or 64 bits of a register R, but can clobber the upper bits
|
|
|
90 of R, R would be in this set but not in full_reg_clobbers ().
|
|
|
91
|
|
|
92 This set is a superset of full_reg_clobbers (). It is possible for a
|
|
|
93 register in full_and_partial_reg_clobbers () & ~full_reg_clobbers ()
|
|
|
94 to contain values that are live across a call, provided that the live
|
|
|
95 value only occupies the call-preserved part of the register. */
|
|
|
96 HARD_REG_SET
|
|
|
97 full_and_partial_reg_clobbers () const
|
|
|
98 {
|
|
|
99 return m_full_and_partial_reg_clobbers;
|
|
|
100 }
|
|
|
101
|
|
|
102 /* Return the set of registers that cannot be used to hold a value of
|
|
|
103 mode MODE across a function call. That is:
|
|
|
104
|
|
|
105 (reg:REGNO MODE)
|
|
|
106
|
|
|
107 might be clobbered by a call whenever:
|
|
|
108
|
|
|
109 overlaps_hard_reg_set (mode_clobbers (MODE), MODE, REGNO)
|
|
|
110
|
|
|
111 In allocation terms, the registers in the returned set conflict
|
|
|
112 with any value of mode MODE that is live across a call. */
|
|
|
113 HARD_REG_SET
|
|
|
114 mode_clobbers (machine_mode mode) const
|
|
|
115 {
|
|
|
116 return m_mode_clobbers[mode];
|
|
|
117 }
|
|
|
118
|
|
|
119 void initialize (unsigned int, const_hard_reg_set);
|
|
|
120 void add_full_reg_clobber (unsigned int);
|
|
|
121
|
|
|
122 private:
|
|
|
123 unsigned int m_id : NUM_ABI_IDS;
|
|
|
124 unsigned int m_initialized : 1;
|
|
|
125 HARD_REG_SET m_full_reg_clobbers;
|
|
|
126 HARD_REG_SET m_full_and_partial_reg_clobbers;
|
|
|
127 HARD_REG_SET m_mode_clobbers[NUM_MACHINE_MODES];
|
|
|
128 };
|
|
|
129
|
|
|
130 /* Describes either a predefined ABI or the ABI of a particular function.
|
|
|
131 In the latter case, the ABI might make use of extra function-specific
|
|
|
132 information, such as for -fipa-ra. */
|
|
|
133 class function_abi
|
|
|
134 {
|
|
|
135 public:
|
|
|
136 /* Initialize the structure for a general function with the given ABI. */
|
|
|
137 function_abi (const predefined_function_abi &base_abi)
|
|
|
138 : m_base_abi (&base_abi),
|
|
|
139 m_mask (base_abi.full_and_partial_reg_clobbers ()) {}
|
|
|
140
|
|
|
141 /* Initialize the structure for a function that has the given ABI and
|
|
|
142 that is known not to clobber registers outside MASK. */
|
|
|
143 function_abi (const predefined_function_abi &base_abi,
|
|
|
144 const_hard_reg_set mask)
|
|
|
145 : m_base_abi (&base_abi), m_mask (mask) {}
|
|
|
146
|
|
|
147 /* The predefined ABI from which this ABI is derived. */
|
|
|
148 const predefined_function_abi &base_abi () const { return *m_base_abi; }
|
|
|
149
|
|
|
150 /* The target-specific identifier of the predefined ABI. */
|
|
|
151 unsigned int id () const { return m_base_abi->id (); }
|
|
|
152
|
|
|
153 /* See the corresponding predefined_function_abi functions for
|
|
|
154 details about the following functions. */
|
|
|
155
|
|
|
156 HARD_REG_SET
|
|
|
157 full_reg_clobbers () const
|
|
|
158 {
|
|
|
159 return m_mask & m_base_abi->full_reg_clobbers ();
|
|
|
160 }
|
|
|
161
|
|
|
162 HARD_REG_SET
|
|
|
163 full_and_partial_reg_clobbers () const
|
|
|
164 {
|
|
|
165 return m_mask & m_base_abi->full_and_partial_reg_clobbers ();
|
|
|
166 }
|
|
|
167
|
|
|
168 HARD_REG_SET
|
|
|
169 mode_clobbers (machine_mode mode) const
|
|
|
170 {
|
|
|
171 return m_mask & m_base_abi->mode_clobbers (mode);
|
|
|
172 }
|
|
|
173
|
|
|
174 bool
|
|
|
175 clobbers_full_reg_p (unsigned int regno) const
|
|
|
176 {
|
|
|
177 return (TEST_HARD_REG_BIT (m_mask, regno)
|
|
|
178 & m_base_abi->clobbers_full_reg_p (regno));
|
|
|
179 }
|
|
|
180
|
|
|
181 bool
|
|
|
182 clobbers_at_least_part_of_reg_p (unsigned int regno) const
|
|
|
183 {
|
|
|
184 return (TEST_HARD_REG_BIT (m_mask, regno)
|
|
|
185 & m_base_abi->clobbers_at_least_part_of_reg_p (regno));
|
|
|
186 }
|
|
|
187
|
|
|
188 bool
|
|
|
189 clobbers_reg_p (machine_mode mode, unsigned int regno) const
|
|
|
190 {
|
|
|
191 return overlaps_hard_reg_set_p (mode_clobbers (mode), mode, regno);
|
|
|
192 }
|
|
|
193
|
|
|
194 bool
|
|
|
195 operator== (const function_abi &other) const
|
|
|
196 {
|
|
|
197 return m_base_abi == other.m_base_abi && m_mask == other.m_mask;
|
|
|
198 }
|
|
|
199
|
|
|
200 bool
|
|
|
201 operator!= (const function_abi &other) const
|
|
|
202 {
|
|
|
203 return !operator== (other);
|
|
|
204 }
|
|
|
205
|
|
|
206 protected:
|
|
|
207 const predefined_function_abi *m_base_abi;
|
|
|
208 HARD_REG_SET m_mask;
|
|
|
209 };
|
|
|
210
|
|
|
211 /* This class collects information about the ABIs of functions that are
|
|
|
212 called in a particular region of code. It is mostly intended to be
|
|
|
213 used as a local variable during an IR walk. */
|
|
|
214 class function_abi_aggregator
|
|
|
215 {
|
|
|
216 public:
|
|
|
217 function_abi_aggregator () : m_abi_clobbers () {}
|
|
|
218
|
|
|
219 /* Record that the code region calls a function with the given ABI. */
|
|
|
220 void
|
|
|
221 note_callee_abi (const function_abi &abi)
|
|
|
222 {
|
|
|
223 m_abi_clobbers[abi.id ()] |= abi.full_and_partial_reg_clobbers ();
|
|
|
224 }
|
|
|
225
|
|
|
226 HARD_REG_SET caller_save_regs (const function_abi &) const;
|
|
|
227
|
|
|
228 private:
|
|
|
229 HARD_REG_SET m_abi_clobbers[NUM_ABI_IDS];
|
|
|
230 };
|
|
|
231
|
|
|
232 struct target_function_abi_info
|
|
|
233 {
|
|
|
234 /* An array of all the target ABIs that are available in this
|
|
|
235 translation unit. Not all entries are used for all targets,
|
|
|
236 but the structures are relatively small, and using a fixed-size
|
|
|
237 array avoids extra indirection.
|
|
|
238
|
|
|
239 There are various ways of getting an ABI descriptor:
|
|
|
240
|
|
|
241 * fndecl_abi (FNDECL) is the ABI of function FNDECL.
|
|
|
242
|
|
|
243 * fntype_abi (FNTYPE) is the ABI of a function with type FNTYPE.
|
|
|
244
|
|
|
245 * crtl->abi is the ABI of the function that we are currently
|
|
|
246 compiling to rtl.
|
|
|
247
|
|
|
248 * insn_callee_abi (INSN) is the ABI used by the target of call insn INSN.
|
|
|
249
|
|
|
250 * eh_edge_abi is the "ABI" used when taking an EH edge from an
|
|
|
251 exception-throwing statement to an exception handler. Catching
|
|
|
252 exceptions from calls can be treated as an abnormal return from
|
|
|
253 those calls, and this ABI therefore describes the ABI of functions
|
|
|
254 on such an abnormal return. Statements that throw non-call
|
|
|
255 exceptions can be treated as being implicitly wrapped in a call
|
|
|
256 that has such an abnormal return.
|
|
|
257
|
|
|
258 At present, no target needs to support more than one EH ABI.
|
|
|
259
|
|
|
260 * function_abis[N] is the ABI with identifier N. This can be useful
|
|
|
261 when referring back to ABIs that have been collected by number in
|
|
|
262 a bitmask, such as after walking function calls in a particular
|
|
|
263 region of code.
|
|
|
264
|
|
|
265 * default_function_abi refers specifically to the target's default
|
|
|
266 choice of ABI, regardless of which (if any) functions actually
|
|
|
267 use it. This ABI and data derived from it do *not* provide
|
|
|
268 globally conservatively-correct information, so it is only
|
|
|
269 useful in very specific circumstances. */
|
|
|
270 predefined_function_abi x_function_abis[NUM_ABI_IDS];
|
|
|
271 };
|
|
|
272
|
|
|
273 extern target_function_abi_info default_target_function_abi_info;
|
|
|
274 #if SWITCHABLE_TARGET
|
|
|
275 extern target_function_abi_info *this_target_function_abi_info;
|
|
|
276 #else
|
|
|
277 #define this_target_function_abi_info (&default_target_function_abi_info)
|
|
|
278 #endif
|
|
|
279
|
|
|
280 /* See the comment above x_function_abis for when these macros should be used.
|
|
|
281 At present, eh_edge_abi is always the default ABI, but that could change
|
|
|
282 in future if a target needs it to. */
|
|
|
283 #define function_abis \
|
|
|
284 (this_target_function_abi_info->x_function_abis)
|
|
|
285 #define default_function_abi \
|
|
|
286 (this_target_function_abi_info->x_function_abis[0])
|
|
|
287 #define eh_edge_abi default_function_abi
|
|
|
288
|
|
|
289 extern HARD_REG_SET call_clobbers_in_region (unsigned int, const_hard_reg_set,
|
|
|
290 machine_mode mode);
|
|
|
291
|
|
|
292 /* Return true if (reg:MODE REGNO) might be clobbered by one of the
|
|
|
293 calls in a region described by ABIS and MASK, where:
|
|
|
294
|
|
|
295 * Bit ID of ABIS is set if the region contains a call with
|
|
|
296 function_abi identifier ID.
|
|
|
297
|
|
|
298 * MASK contains all the registers that are fully or partially
|
|
|
299 clobbered by calls in the region.
|
|
|
300
|
|
|
301 This is not quite as accurate as testing each individual call,
|
|
|
302 but it's a close and conservatively-correct approximation.
|
|
|
303 It's much better for some targets than:
|
|
|
304
|
|
|
305 overlaps_hard_reg_set_p (MASK, MODE, REGNO). */
|
|
|
306
|
|
|
307 inline bool
|
|
|
308 call_clobbered_in_region_p (unsigned int abis, const_hard_reg_set mask,
|
|
|
309 machine_mode mode, unsigned int regno)
|
|
|
310 {
|
|
|
311 HARD_REG_SET clobbers = call_clobbers_in_region (abis, mask, mode);
|
|
|
312 return overlaps_hard_reg_set_p (clobbers, mode, regno);
|
|
|
313 }
|
|
|
314
|
|
|
315 extern const predefined_function_abi &fntype_abi (const_tree);
|
|
|
316 extern function_abi fndecl_abi (const_tree);
|
|
|
317 extern function_abi insn_callee_abi (const rtx_insn *);
|
|
|
318 extern function_abi expr_callee_abi (const_tree);
|
|
|
319
|
|
|
320 #endif
|
