1/* Information about fuunction binary interfaces.
2   Copyright (C) 2019-2020 Free Software Foundation, Inc.
3
4This file is part of GCC
5
6GCC is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License as published by the Free
8Software Foundation; either version 3, or (at your option) any later
9version.
10
11GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12WARRANTY; without even the implied warranty of MERCHANTABILITY or
13FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14for more details.
15
16You should have received a copy of the GNU General Public License
17along 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
32target_function_abi_info default_target_function_abi_info;
33#if SWITCHABLE_TARGET
34target_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
41void
42predefined_function_abi::initialize (unsigned int id,
43				     const_hard_reg_set full_reg_clobbers)
44{
45  m_id = id;
46  m_initialized = true;
47  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  m_full_and_partial_reg_clobbers = full_reg_clobbers;
63  for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
64    {
65      machine_mode mode = (machine_mode) i;
66      for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
67	if (targetm.hard_regno_mode_ok (regno, mode)
68	    && hard_regno_nregs (regno, mode) == 1
69	    && targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
70	  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  for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
86    {
87      machine_mode mode = (machine_mode) i;
88      m_mode_clobbers[i] = m_full_and_partial_reg_clobbers;
89      for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
90	if (targetm.hard_regno_mode_ok (regno, mode)
91	    && !overlaps_hard_reg_set_p (m_full_reg_clobbers, mode, regno)
92	    && !targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
93	  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  if (flag_checking)
100    for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
101      {
102	machine_mode mode = (machine_mode) i;
103	const_hard_reg_set all_clobbers = m_full_and_partial_reg_clobbers;
104	for (unsigned int regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
105	  if (targetm.hard_regno_mode_ok (regno, mode)
106	      && !overlaps_hard_reg_set_p (m_full_reg_clobbers, mode, regno)
107	      && targetm.hard_regno_call_part_clobbered (m_id, regno, mode))
108	    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}
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
117void
118predefined_function_abi::add_full_reg_clobber (unsigned int regno)
119{
120  if (!m_initialized)
121    return;
122
123  SET_HARD_REG_BIT (m_full_reg_clobbers, regno);
124  SET_HARD_REG_BIT (m_full_and_partial_reg_clobbers, regno);
125  for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
126    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
132HARD_REG_SET
133function_abi_aggregator::
134caller_save_regs (const function_abi &caller_abi) const
135{
136  HARD_REG_SET result;
137  CLEAR_HARD_REG_SET (result);
138  for (unsigned int abi_id = 0; abi_id < NUM_ABI_IDS; ++abi_id)
139    {
140      const predefined_function_abi &callee_abi = function_abis[abi_id];
141
142      /* Skip cases that clearly aren't problematic.  */
143      if (abi_id == caller_abi.id ()
144	  || hard_reg_set_empty_p (m_abi_clobbers[abi_id]))
145	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      CLEAR_HARD_REG_SET (extra_clobbers);
151      for (unsigned int i = 0; i < NUM_MACHINE_MODES; ++i)
152	{
153	  machine_mode mode = (machine_mode) i;
154	  extra_clobbers |= (callee_abi.mode_clobbers (mode)
155			     & ~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      result |= (extra_clobbers & m_abi_clobbers[abi_id]);
161    }
162  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
178HARD_REG_SET
179call_clobbers_in_region (unsigned int abis, const_hard_reg_set mask,
180			 machine_mode mode)
181{
182  HARD_REG_SET result;
183  CLEAR_HARD_REG_SET (result);
184  for (unsigned int id = 0; abis; abis >>= 1, ++id)
185    if (abis & 1)
186      result |= function_abis[id].mode_clobbers (mode);
187  return result & mask;
188}
189
190/* Return the predefined ABI used by functions with type TYPE.  */
191
192const predefined_function_abi &
193fntype_abi (const_tree type)
194{
195  gcc_assert (FUNC_OR_METHOD_TYPE_P (type));
196  if (targetm.calls.fntype_abi)
197    return targetm.calls.fntype_abi (type);
198  return default_function_abi;
199}
200
201/* Return the ABI of function decl FNDECL.  */
202
203function_abi
204fndecl_abi (const_tree fndecl)
205{
206  gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);
207  const predefined_function_abi &base_abi = fntype_abi (TREE_TYPE (fndecl));
208
209  if (flag_ipa_ra && decl_binds_to_current_def_p (fndecl))
210    if (cgraph_rtl_info *info = cgraph_node::rtl_info (fndecl))
211      return function_abi (base_abi, info->function_used_regs);
212
213  return base_abi;
214}
215
216/* Return the ABI of the function called by INSN.  */
217
218function_abi
219insn_callee_abi (const rtx_insn *insn)
220{
221  gcc_assert (insn && CALL_P (insn));
222
223  if (flag_ipa_ra)
224    if (tree fndecl = get_call_fndecl (insn))
225      return fndecl_abi (fndecl);
226
227  if (targetm.calls.insn_callee_abi)
228    return targetm.calls.insn_callee_abi (insn);
229
230  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
236function_abi
237expr_callee_abi (const_tree exp)
238{
239  gcc_assert (TREE_CODE (exp) == CALL_EXPR);
240
241  if (tree fndecl = get_callee_fndecl (exp))
242    return fndecl_abi (fndecl);
243
244  tree callee = CALL_EXPR_FN (exp);
245  if (callee == error_mark_node)
246    return default_function_abi;
247
248  tree type = TREE_TYPE (callee);
249  if (type == error_mark_node)
250    return default_function_abi;
251
252  gcc_assert (POINTER_TYPE_P (type));
253  return fntype_abi (TREE_TYPE (type));
254}
255