Branch data Line data Source code
1 : : /* Information about fuunction binary interfaces.
2 : : Copyright (C) 2019-2025 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 : : #include "config.h"
21 : : #include "system.h"
22 : : #include "coretypes.h"
23 : : #include "backend.h"
24 : : #include "target.h"
25 : : #include "rtl.h"
26 : : #include "tree.h"
27 : : #include "regs.h"
28 : : #include "function-abi.h"
29 : : #include "varasm.h"
30 : : #include "cgraph.h"
31 : :
32 : : target_function_abi_info default_target_function_abi_info;
33 : : #if SWITCHABLE_TARGET
34 : : target_function_abi_info *this_target_function_abi_info
35 : : = &default_target_function_abi_info;
36 : : #endif
37 : :
38 : : /* Initialize a predefined function ABI with the given values of
39 : : ID and FULL_REG_CLOBBERS. */
40 : :
41 : : void
42 : 885337 : predefined_function_abi::initialize (unsigned int id,
43 : : const_hard_reg_set full_reg_clobbers)
44 : : {
45 : 885337 : m_id = id;
46 : 885337 : m_initialized = true;
47 : 885337 : m_full_reg_clobbers = full_reg_clobbers;
48 : :
49 : : /* Set up the value of m_full_and_partial_reg_clobbers.
50 : :
51 : : If the ABI specifies that part of a hard register R is call-clobbered,
52 : : we should be able to find a single-register mode M for which
53 : : targetm.hard_regno_call_part_clobbered (m_id, R, M) is true.
54 : : In other words, it shouldn't be the case that R can hold all
55 : : single-register modes across a call, but can't hold part of
56 : : a multi-register mode.
57 : :
58 : : If that assumption doesn't hold for a future target, we would need
59 : : to change the interface of TARGET_HARD_REGNO_CALL_PART_CLOBBERED so
60 : : that it tells us which registers in a multi-register value are
61 : : actually clobbered. */
62 : 885337 : m_full_and_partial_reg_clobbers = full_reg_clobbers;
63 : 115979147 : for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
64 : : {
65 : : machine_mode mode = (machine_mode) i;
66 : 10703724330 : for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
67 : 10588630520 : if (targetm.hard_regno_mode_ok (regno, mode)
68 : 1953209110 : && hard_regno_nregs (regno, mode) == 1
69 : 12228631266 : && targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
70 : 153828320 : SET_HARD_REG_BIT (m_full_and_partial_reg_clobbers, regno);
71 : : }
72 : :
73 : : /* For each mode MODE, work out which registers are unable to hold
74 : : any part of a MODE value across a call, i.e. those for which no
75 : : overlapping call-preserved (reg:MODE REGNO) exists.
76 : :
77 : : We assume that this can be flipped around to say that a call
78 : : preserves (reg:MODE REGNO) unless the register overlaps this set.
79 : : The usual reason for this being true is that if (reg:MODE REGNO)
80 : : contains a part-clobbered register, that register would be
81 : : part-clobbered regardless of which part of MODE it holds.
82 : : For example, if (reg:M 2) occupies two registers and if the
83 : : register 3 portion of it is part-clobbered, (reg:M 3) is usually
84 : : either invalid or also part-clobbered. */
85 : 115979147 : for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
86 : : {
87 : 115093810 : machine_mode mode = (machine_mode) i;
88 : 115093810 : m_mode_clobbers[i] = m_full_and_partial_reg_clobbers;
89 : 10703724330 : for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
90 : 10588630520 : if (targetm.hard_regno_mode_ok (regno, mode)
91 : 1953209110 : && !overlaps_hard_reg_set_p (m_full_reg_clobbers, mode, regno)
92 : 10855275570 : && !targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
93 : 265464170 : remove_from_hard_reg_set (&m_mode_clobbers[i], mode, regno);
94 : : }
95 : :
96 : : /* Check that the assumptions above actually hold, i.e. that testing
97 : : for single-register modes makes sense, and that overlap tests for
98 : : mode_clobbers work as expected. */
99 : 885337 : if (flag_checking)
100 : 115976658 : for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
101 : : {
102 : 115091340 : machine_mode mode = (machine_mode) i;
103 : 115091340 : const_hard_reg_set all_clobbers = m_full_and_partial_reg_clobbers;
104 : 10703494620 : for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
105 : 10588403280 : if (targetm.hard_regno_mode_ok (regno, mode)
106 : 1953171965 : && !overlaps_hard_reg_set_p (m_full_reg_clobbers, mode, regno)
107 : 10855043067 : && targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
108 : 1180880 : gcc_assert (overlaps_hard_reg_set_p (all_clobbers, mode, regno)
109 : : && overlaps_hard_reg_set_p (m_mode_clobbers[i],
110 : : mode, regno));
111 : : }
112 : 885337 : }
113 : :
114 : : /* If the ABI has been initialized, add REGNO to the set of registers
115 : : that can be completely altered by a call. */
116 : :
117 : : void
118 : 696 : predefined_function_abi::add_full_reg_clobber (unsigned int regno)
119 : : {
120 : 696 : if (!m_initialized)
121 : : return;
122 : :
123 : 87 : SET_HARD_REG_BIT (m_full_reg_clobbers, regno);
124 : 87 : SET_HARD_REG_BIT (m_full_and_partial_reg_clobbers, regno);
125 : 11397 : for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
126 : 11310 : SET_HARD_REG_BIT (m_mode_clobbers[i], regno);
127 : : }
128 : :
129 : : /* Return the set of registers that the caller of the recorded functions must
130 : : save in order to honor the requirements of CALLER_ABI. */
131 : :
132 : : HARD_REG_SET
133 : 1427236 : function_abi_aggregator::
134 : : caller_save_regs (const function_abi &caller_abi) const
135 : : {
136 : 1427236 : HARD_REG_SET result;
137 : 1427236 : CLEAR_HARD_REG_SET (result);
138 : 12845124 : for (unsigned int abi_id = 0; abi_id < NUM_ABI_IDS; ++abi_id)
139 : : {
140 : 11417888 : const predefined_function_abi &callee_abi = function_abis[abi_id];
141 : :
142 : : /* Skip cases that clearly aren't problematic. */
143 : 11417888 : if (abi_id == caller_abi.id ()
144 : 21408540 : || hard_reg_set_empty_p (m_abi_clobbers[abi_id]))
145 : 11417860 : continue;
146 : :
147 : : /* Collect the set of registers that can be "more clobbered" by
148 : : CALLEE_ABI than by CALLER_ABI. */
149 : : HARD_REG_SET extra_clobbers;
150 : 3668 : CLEAR_HARD_REG_SET (extra_clobbers);
151 : 3668 : for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
152 : : {
153 : 3640 : machine_mode mode = (machine_mode) i;
154 : 7280 : extra_clobbers |= (callee_abi.mode_clobbers (mode)
155 : 7280 : & ~caller_abi.mode_clobbers (mode));
156 : : }
157 : :
158 : : /* Restrict it to the set of registers that we actually saw
159 : : clobbers for (e.g. taking -fipa-ra into account). */
160 : 56 : result |= (extra_clobbers & m_abi_clobbers[abi_id]);
161 : : }
162 : 1427236 : return result;
163 : : }
164 : :
165 : : /* Return the set of registers that cannot be used to hold a value of
166 : : mode MODE across the calls in a region described by ABIS and MASK, where:
167 : :
168 : : * Bit ID of ABIS is set if the region contains a call with
169 : : function_abi identifier ID.
170 : :
171 : : * MASK contains all the registers that are fully or partially
172 : : clobbered by calls in the region.
173 : :
174 : : This is not quite as accurate as testing each individual call,
175 : : but it's a close and conservatively-correct approximation.
176 : : It's much better for some targets than just using MASK. */
177 : :
178 : : HARD_REG_SET
179 : 69452134 : call_clobbers_in_region (unsigned int abis, const_hard_reg_set mask,
180 : : machine_mode mode)
181 : : {
182 : 69452134 : HARD_REG_SET result;
183 : 69452134 : CLEAR_HARD_REG_SET (result);
184 : 119447537 : for (unsigned int id = 0; abis; abis >>= 1, ++id)
185 : 49995403 : if (abis & 1)
186 : 99983642 : result |= function_abis[id].mode_clobbers (mode);
187 : 69452134 : return result & mask;
188 : : }
189 : :
190 : : /* Return the predefined ABI used by functions with type TYPE. */
191 : :
192 : : const predefined_function_abi &
193 : 354934236 : fntype_abi (const_tree type)
194 : : {
195 : 354934236 : gcc_assert (FUNC_OR_METHOD_TYPE_P (type));
196 : 354934236 : if (targetm.calls.fntype_abi)
197 : 0 : return targetm.calls.fntype_abi (type);
198 : 354934236 : return default_function_abi;
199 : : }
200 : :
201 : : /* Return the ABI of function decl FNDECL. */
202 : :
203 : : function_abi
204 : 265895913 : fndecl_abi (const_tree fndecl)
205 : : {
206 : 265895913 : gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);
207 : 265895913 : const predefined_function_abi &base_abi = fntype_abi (TREE_TYPE (fndecl));
208 : :
209 : 265895913 : if (flag_ipa_ra && decl_binds_to_current_def_p (fndecl))
210 : 47858191 : if (cgraph_rtl_info *info = cgraph_node::rtl_info (fndecl))
211 : 43658233 : return function_abi (base_abi, info->function_used_regs);
212 : :
213 : 222237680 : return base_abi;
214 : : }
215 : :
216 : : /* Return the ABI of the function called by INSN. */
217 : :
218 : : function_abi
219 : 509896226 : insn_callee_abi (const rtx_insn *insn)
220 : : {
221 : 509896226 : gcc_assert (insn && CALL_P (insn));
222 : :
223 : 509896226 : if (flag_ipa_ra)
224 : 277459020 : if (tree fndecl = get_call_fndecl (insn))
225 : 264462436 : return fndecl_abi (fndecl);
226 : :
227 : 245433790 : if (targetm.calls.insn_callee_abi)
228 : 245433790 : return targetm.calls.insn_callee_abi (insn);
229 : :
230 : 0 : return default_function_abi;
231 : : }
232 : :
233 : : /* Return the ABI of the function called by CALL_EXPR EXP. Return the
234 : : default ABI for erroneous calls. */
235 : :
236 : : function_abi
237 : 0 : expr_callee_abi (const_tree exp)
238 : : {
239 : 0 : gcc_assert (TREE_CODE (exp) == CALL_EXPR);
240 : :
241 : 0 : if (tree fndecl = get_callee_fndecl (exp))
242 : 0 : return fndecl_abi (fndecl);
243 : :
244 : 0 : tree callee = CALL_EXPR_FN (exp);
245 : 0 : if (callee == error_mark_node)
246 : 0 : return default_function_abi;
247 : :
248 : 0 : tree type = TREE_TYPE (callee);
249 : 0 : if (type == error_mark_node)
250 : 0 : return default_function_abi;
251 : :
252 : 0 : gcc_assert (POINTER_TYPE_P (type));
253 : 0 : return fntype_abi (TREE_TYPE (type));
254 : : }
|