1/* Some code common to C++ and ObjC++ front ends.
2   Copyright (C) 2004-2022 Free Software Foundation, Inc.
3   Contributed by Ziemowit Laski  <zlaski@apple.com>
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING3.  If not see
19<http://www.gnu.org/licenses/>.  */
20
21#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "cp-tree.h"
25#include "cp-objcp-common.h"
26#include "dwarf2.h"
27#include "stringpool.h"
28
29/* Special routine to get the alias set for C++.  */
30
31alias_set_type
32cxx_get_alias_set (tree t)
33{
34  if (IS_FAKE_BASE_TYPE (t))
35    /* The base variant of a type must be in the same alias set as the
36       complete type.  */
37    return get_alias_set (TYPE_CONTEXT (t));
38
39  /* Punt on PMFs until we canonicalize functions properly.  */
40  if (TYPE_PTRMEMFUNC_P (t)
41      || (INDIRECT_TYPE_P (t)
42	  && TYPE_PTRMEMFUNC_P (TREE_TYPE (t))))
43    return 0;
44
45  return c_common_get_alias_set (t);
46}
47
48/* Called from check_global_declaration.  */
49
50bool
51cxx_warn_unused_global_decl (const_tree decl)
52{
53  if (TREE_CODE (decl) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (decl))
54    return false;
55  if (DECL_IN_SYSTEM_HEADER (decl))
56    return false;
57
58  return true;
59}
60
61/* Langhook for tree_size: determine size of our 'x' and 'c' nodes.  */
62size_t
63cp_tree_size (enum tree_code code)
64{
65  gcc_checking_assert (code >= NUM_TREE_CODES);
66  switch (code)
67    {
68    case PTRMEM_CST:		return sizeof (ptrmem_cst);
69    case BASELINK:		return sizeof (tree_baselink);
70    case TEMPLATE_PARM_INDEX:	return sizeof (template_parm_index);
71    case DEFERRED_PARSE:	return sizeof (tree_deferred_parse);
72    case DEFERRED_NOEXCEPT:	return sizeof (tree_deferred_noexcept);
73    case OVERLOAD:		return sizeof (tree_overload);
74    case STATIC_ASSERT:         return sizeof (tree_static_assert);
75#if 0
76      /* This would match cp_common_init_ts, but breaks GC because
77	 tree_node_structure_for_code returns TS_TYPE_NON_COMMON for all
78	 types.  */
79    case UNBOUND_CLASS_TEMPLATE:
80    case TYPE_ARGUMENT_PACK:	return sizeof (tree_type_common);
81#endif
82    case ARGUMENT_PACK_SELECT:	return sizeof (tree_argument_pack_select);
83    case TRAIT_EXPR:		return sizeof (tree_trait_expr);
84    case LAMBDA_EXPR:           return sizeof (tree_lambda_expr);
85    case TEMPLATE_INFO:         return sizeof (tree_template_info);
86    case CONSTRAINT_INFO:       return sizeof (tree_constraint_info);
87    case USERDEF_LITERAL:	return sizeof (tree_userdef_literal);
88    case TEMPLATE_DECL:		return sizeof (tree_template_decl);
89    default:
90      switch (TREE_CODE_CLASS (code))
91	{
92	case tcc_declaration:	return sizeof (tree_decl_non_common);
93	case tcc_type:		return sizeof (tree_type_non_common);
94	default: gcc_unreachable ();
95	}
96    }
97  /* NOTREACHED */
98}
99
100/* Returns true if T is a variably modified type, in the sense of C99.
101   FN is as passed to variably_modified_p.
102   This routine needs only check cases that cannot be handled by the
103   language-independent logic in tree.cc.  */
104
105bool
106cp_var_mod_type_p (tree type, tree fn)
107{
108  /* If TYPE is a pointer-to-member, it is variably modified if either
109     the class or the member are variably modified.  */
110  if (TYPE_PTRMEM_P (type))
111    return (variably_modified_type_p (TYPE_PTRMEM_CLASS_TYPE (type), fn)
112	    || variably_modified_type_p (TYPE_PTRMEM_POINTED_TO_TYPE (type),
113					 fn));
114
115  /* All other types are not variably modified.  */
116  return false;
117}
118
119/* This compares two types for equivalence ("compatible" in C-based languages).
120   This routine should only return 1 if it is sure.  It should not be used
121   in contexts where erroneously returning 0 causes problems.  */
122
123int
124cxx_types_compatible_p (tree x, tree y)
125{
126  return same_type_ignoring_top_level_qualifiers_p (x, y);
127}
128
129static GTY((cache)) type_tree_cache_map *debug_type_map;
130
131/* Return a type to use in the debug info instead of TYPE, or NULL_TREE to
132   keep TYPE.  */
133
134tree
135cp_get_debug_type (const_tree type)
136{
137  tree dtype = NULL_TREE;
138
139  if (TYPE_PTRMEMFUNC_P (type) && !typedef_variant_p (type))
140    dtype = build_offset_type (TYPE_PTRMEMFUNC_OBJECT_TYPE (type),
141			       TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (type)));
142
143  /* We cannot simply return the debug type here because the function uses
144     the type canonicalization hashtable, which is GC-ed, so its behavior
145     depends on the actual collection points.  Since we are building these
146     types on the fly for the debug info only, they would not be attached
147     to any GC root and always be swept, so we would make the contents of
148     the debug info depend on the collection points.  */
149  if (dtype)
150    {
151      tree ktype = CONST_CAST_TREE (type);
152      if (tree *slot = hash_map_safe_get (debug_type_map, ktype))
153	return *slot;
154      hash_map_safe_put<hm_ggc> (debug_type_map, ktype, dtype);
155    }
156
157  return dtype;
158}
159
160/* Return -1 if dwarf ATTR shouldn't be added for DECL, or the attribute
161   value otherwise.  */
162int
163cp_decl_dwarf_attribute (const_tree decl, int attr)
164{
165  if (decl == NULL_TREE)
166    return -1;
167
168  switch (attr)
169    {
170    case DW_AT_explicit:
171      if (TREE_CODE (decl) == FUNCTION_DECL
172	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
173	  && DECL_NONCONVERTING_P (decl))
174	return 1;
175      break;
176
177    case DW_AT_deleted:
178      if (TREE_CODE (decl) == FUNCTION_DECL
179	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
180	  && DECL_DELETED_FN (decl))
181	return 1;
182      break;
183
184    case DW_AT_defaulted:
185      if (TREE_CODE (decl) == FUNCTION_DECL
186	  && DECL_LANG_SPECIFIC (STRIP_TEMPLATE (decl))
187	  && DECL_DEFAULTED_FN (decl))
188	{
189	  if (DECL_DEFAULTED_IN_CLASS_P (decl))
190	    return DW_DEFAULTED_in_class;
191
192	  if (DECL_DEFAULTED_OUTSIDE_CLASS_P (decl))
193	    return DW_DEFAULTED_out_of_class;
194	}
195      break;
196
197    case DW_AT_const_expr:
198      if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_DECLARED_CONSTEXPR_P (decl))
199	return 1;
200      break;
201
202    case DW_AT_reference:
203      if (TREE_CODE (decl) == FUNCTION_DECL
204	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
205	  && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
206	  && !FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
207	return 1;
208      break;
209
210    case DW_AT_rvalue_reference:
211      if (TREE_CODE (decl) == FUNCTION_DECL
212	  && DECL_NONSTATIC_MEMBER_FUNCTION_P (decl)
213	  && FUNCTION_REF_QUALIFIED (TREE_TYPE (decl))
214	  && FUNCTION_RVALUE_QUALIFIED (TREE_TYPE (decl)))
215	return 1;
216      break;
217
218    case DW_AT_inline:
219      if (VAR_P (decl) && DECL_INLINE_VAR_P (decl))
220	{
221	  if (DECL_VAR_DECLARED_INLINE_P (decl))
222	    return DW_INL_declared_inlined;
223	  else
224	    return DW_INL_inlined;
225	}
226      break;
227
228    case DW_AT_export_symbols:
229      if (TREE_CODE (decl) == NAMESPACE_DECL
230	  && (DECL_NAMESPACE_INLINE_P (decl)
231	      || (DECL_NAME (decl) == NULL_TREE && dwarf_version >= 5)))
232	return 1;
233      break;
234
235    default:
236      break;
237    }
238
239  return -1;
240}
241
242/* Return -1 if dwarf ATTR shouldn't be added for TYPE, or the attribute
243   value otherwise.  */
244int
245cp_type_dwarf_attribute (const_tree type, int attr)
246{
247  if (type == NULL_TREE)
248    return -1;
249
250  switch (attr)
251    {
252    case DW_AT_reference:
253      if (FUNC_OR_METHOD_TYPE_P (type)
254	  && FUNCTION_REF_QUALIFIED (type)
255	  && !FUNCTION_RVALUE_QUALIFIED (type))
256	return 1;
257      break;
258
259    case DW_AT_rvalue_reference:
260      if (FUNC_OR_METHOD_TYPE_P (type)
261	  && FUNCTION_REF_QUALIFIED (type)
262	  && FUNCTION_RVALUE_QUALIFIED (type))
263	return 1;
264      break;
265
266    default:
267      break;
268    }
269
270  return -1;
271}
272
273/* Return the unit size of TYPE without reusable tail padding.  */
274
275tree
276cp_unit_size_without_reusable_padding (tree type)
277{
278  if (CLASS_TYPE_P (type))
279    return CLASSTYPE_SIZE_UNIT (type);
280  return TYPE_SIZE_UNIT (type);
281}
282
283/* Returns type corresponding to FIELD's type when FIELD is a C++ base class
284   i.e., type without virtual base classes or tail padding.  Returns
285   NULL_TREE otherwise.  */
286
287tree
288cp_classtype_as_base (const_tree field)
289{
290  if (DECL_FIELD_IS_BASE (field))
291    {
292      tree type = TREE_TYPE (field);
293      if (TYPE_LANG_SPECIFIC (type))
294	return CLASSTYPE_AS_BASE (type);
295    }
296  return NULL_TREE;
297}
298
299/* Stubs to keep c-opts.cc happy.  */
300void
301push_file_scope (void)
302{
303}
304
305void
306pop_file_scope (void)
307{
308}
309
310/* c-pragma.cc needs to query whether a decl has extern "C" linkage.  */
311bool
312has_c_linkage (const_tree decl)
313{
314  return DECL_EXTERN_C_P (decl);
315}
316
317/* Return true if stmt can fall through.  Used by block_may_fallthru
318   default case.  */
319
320bool
321cxx_block_may_fallthru (const_tree stmt)
322{
323  switch (TREE_CODE (stmt))
324    {
325    case EXPR_STMT:
326      return block_may_fallthru (EXPR_STMT_EXPR (stmt));
327
328    case THROW_EXPR:
329      return false;
330
331    case IF_STMT:
332      if (IF_STMT_CONSTEXPR_P (stmt))
333	{
334	  if (integer_nonzerop (IF_COND (stmt)))
335	    return block_may_fallthru (THEN_CLAUSE (stmt));
336	  if (integer_zerop (IF_COND (stmt)))
337	    return block_may_fallthru (ELSE_CLAUSE (stmt));
338	}
339      if (block_may_fallthru (THEN_CLAUSE (stmt)))
340	return true;
341      return block_may_fallthru (ELSE_CLAUSE (stmt));
342
343    case CLEANUP_STMT:
344      /* Just handle the try/finally cases.  */
345      if (!CLEANUP_EH_ONLY (stmt))
346	{
347	  return (block_may_fallthru (CLEANUP_BODY (stmt))
348		  && block_may_fallthru (CLEANUP_EXPR (stmt)));
349	}
350      return true;
351
352    default:
353      return c_block_may_fallthru (stmt);
354    }
355}
356
357/* Return the list of decls in the global namespace.  */
358
359tree
360cp_get_global_decls ()
361{
362  return NAMESPACE_LEVEL (global_namespace)->names;
363}
364
365/* Push DECL into the current (namespace) scope.  */
366
367tree
368cp_pushdecl (tree decl)
369{
370  DECL_CONTEXT (decl) = FROB_CONTEXT (current_namespace);
371  return pushdecl (decl);
372}
373
374/* Get the global value binding of NAME.  Called directly from
375   c-common.cc, not via a hook. */
376
377tree
378identifier_global_value (tree name)
379{
380  return get_global_binding (name);
381}
382
383/* Similarly, but return struct/class/union NAME instead.  */
384
385tree
386identifier_global_tag (tree name)
387{
388  tree ret = lookup_qualified_name (global_namespace, name, LOOK_want::TYPE,
389				    /*complain*/false);
390  if (ret == error_mark_node)
391    return NULL_TREE;
392  return ret;
393}
394
395/* Returns true if NAME refers to a built-in function or function-like
396   operator.  */
397
398bool
399names_builtin_p (const char *name)
400{
401  tree id = get_identifier (name);
402  if (tree binding = get_global_binding (id))
403    {
404      if (TREE_CODE (binding) == FUNCTION_DECL
405	  && DECL_IS_UNDECLARED_BUILTIN (binding))
406	return true;
407
408      /* Handle the case when an overload for a  built-in name exists.  */
409      if (TREE_CODE (binding) != OVERLOAD)
410	return false;
411
412      for (ovl_iterator it (binding); it; ++it)
413	{
414	  tree decl = *it;
415	  if (DECL_IS_UNDECLARED_BUILTIN (decl))
416	    return true;
417	}
418    }
419
420  /* Also detect common reserved C++ words that aren't strictly built-in
421     functions.  */
422  switch (C_RID_CODE (id))
423    {
424    case RID_ADDRESSOF:
425    case RID_BUILTIN_CONVERTVECTOR:
426    case RID_BUILTIN_HAS_ATTRIBUTE:
427    case RID_BUILTIN_SHUFFLE:
428    case RID_BUILTIN_SHUFFLEVECTOR:
429    case RID_BUILTIN_LAUNDER:
430    case RID_BUILTIN_ASSOC_BARRIER:
431    case RID_BUILTIN_BIT_CAST:
432    case RID_OFFSETOF:
433    case RID_HAS_NOTHROW_ASSIGN:
434    case RID_HAS_NOTHROW_CONSTRUCTOR:
435    case RID_HAS_NOTHROW_COPY:
436    case RID_HAS_TRIVIAL_ASSIGN:
437    case RID_HAS_TRIVIAL_CONSTRUCTOR:
438    case RID_HAS_TRIVIAL_COPY:
439    case RID_HAS_TRIVIAL_DESTRUCTOR:
440    case RID_HAS_UNIQUE_OBJ_REPRESENTATIONS:
441    case RID_HAS_VIRTUAL_DESTRUCTOR:
442    case RID_IS_ABSTRACT:
443    case RID_IS_AGGREGATE:
444    case RID_IS_BASE_OF:
445    case RID_IS_CLASS:
446    case RID_IS_EMPTY:
447    case RID_IS_ENUM:
448    case RID_IS_FINAL:
449    case RID_IS_LAYOUT_COMPATIBLE:
450    case RID_IS_LITERAL_TYPE:
451    case RID_IS_POINTER_INTERCONVERTIBLE_BASE_OF:
452    case RID_IS_POD:
453    case RID_IS_POLYMORPHIC:
454    case RID_IS_SAME_AS:
455    case RID_IS_STD_LAYOUT:
456    case RID_IS_TRIVIAL:
457    case RID_IS_TRIVIALLY_ASSIGNABLE:
458    case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
459    case RID_IS_TRIVIALLY_COPYABLE:
460    case RID_IS_UNION:
461    case RID_IS_ASSIGNABLE:
462    case RID_IS_CONSTRUCTIBLE:
463    case RID_IS_NOTHROW_ASSIGNABLE:
464    case RID_IS_NOTHROW_CONSTRUCTIBLE:
465    case RID_UNDERLYING_TYPE:
466      return true;
467    default:
468      break;
469    }
470
471  return false;
472}
473
474/* Register c++-specific dumps.  */
475
476void
477cp_register_dumps (gcc::dump_manager *dumps)
478{
479  class_dump_id = dumps->dump_register
480    (".class", "lang-class", "lang-class", DK_lang, OPTGROUP_NONE, false);
481
482  module_dump_id = dumps->dump_register
483    (".module", "lang-module", "lang-module", DK_lang, OPTGROUP_NONE, false);
484
485  raw_dump_id = dumps->dump_register
486    (".raw", "lang-raw", "lang-raw", DK_lang, OPTGROUP_NONE, false);
487}
488
489void
490cp_common_init_ts (void)
491{
492  /* With type.  */
493  MARK_TS_TYPED (PTRMEM_CST);
494  MARK_TS_TYPED (LAMBDA_EXPR);
495  MARK_TS_TYPED (TYPE_ARGUMENT_PACK);
496
497  /* Random new trees.  */
498  MARK_TS_COMMON (BASELINK);
499  MARK_TS_COMMON (OVERLOAD);
500  MARK_TS_COMMON (TEMPLATE_PARM_INDEX);
501
502  /* New decls.  */
503  MARK_TS_DECL_COMMON (TEMPLATE_DECL);
504  MARK_TS_DECL_COMMON (WILDCARD_DECL);
505  MARK_TS_DECL_COMMON (CONCEPT_DECL);
506
507  MARK_TS_DECL_NON_COMMON (USING_DECL);
508
509  /* New Types.  */
510  MARK_TS_TYPE_COMMON (UNBOUND_CLASS_TEMPLATE);
511  MARK_TS_TYPE_COMMON (TYPE_ARGUMENT_PACK);
512  MARK_TS_TYPE_COMMON (DEPENDENT_OPERATOR_TYPE);
513
514  MARK_TS_TYPE_NON_COMMON (DECLTYPE_TYPE);
515  MARK_TS_TYPE_NON_COMMON (TYPENAME_TYPE);
516  MARK_TS_TYPE_NON_COMMON (TYPEOF_TYPE);
517  MARK_TS_TYPE_NON_COMMON (UNDERLYING_TYPE);
518  MARK_TS_TYPE_NON_COMMON (BOUND_TEMPLATE_TEMPLATE_PARM);
519  MARK_TS_TYPE_NON_COMMON (TEMPLATE_TEMPLATE_PARM);
520  MARK_TS_TYPE_NON_COMMON (TEMPLATE_TYPE_PARM);
521  MARK_TS_TYPE_NON_COMMON (TYPE_PACK_EXPANSION);
522
523  /* Statements.  */
524  MARK_TS_EXP (CLEANUP_STMT);
525  MARK_TS_EXP (EH_SPEC_BLOCK);
526  MARK_TS_EXP (HANDLER);
527  MARK_TS_EXP (IF_STMT);
528  MARK_TS_EXP (OMP_DEPOBJ);
529  MARK_TS_EXP (RANGE_FOR_STMT);
530  MARK_TS_EXP (TRY_BLOCK);
531  MARK_TS_EXP (USING_STMT);
532
533  /* Random expressions.  */
534  MARK_TS_EXP (ADDRESSOF_EXPR);
535  MARK_TS_EXP (AGGR_INIT_EXPR);
536  MARK_TS_EXP (ALIGNOF_EXPR);
537  MARK_TS_EXP (ARROW_EXPR);
538  MARK_TS_EXP (AT_ENCODE_EXPR);
539  MARK_TS_EXP (BIT_CAST_EXPR);
540  MARK_TS_EXP (CAST_EXPR);
541  MARK_TS_EXP (CONST_CAST_EXPR);
542  MARK_TS_EXP (CTOR_INITIALIZER);
543  MARK_TS_EXP (DELETE_EXPR);
544  MARK_TS_EXP (DOTSTAR_EXPR);
545  MARK_TS_EXP (DYNAMIC_CAST_EXPR);
546  MARK_TS_EXP (EMPTY_CLASS_EXPR);
547  MARK_TS_EXP (EXPR_STMT);
548  MARK_TS_EXP (IMPLICIT_CONV_EXPR);
549  MARK_TS_EXP (MEMBER_REF);
550  MARK_TS_EXP (MODOP_EXPR);
551  MARK_TS_EXP (MUST_NOT_THROW_EXPR);
552  MARK_TS_EXP (NEW_EXPR);
553  MARK_TS_EXP (NOEXCEPT_EXPR);
554  MARK_TS_EXP (NON_DEPENDENT_EXPR);
555  MARK_TS_EXP (OFFSETOF_EXPR);
556  MARK_TS_EXP (OFFSET_REF);
557  MARK_TS_EXP (PSEUDO_DTOR_EXPR);
558  MARK_TS_EXP (REINTERPRET_CAST_EXPR);
559  MARK_TS_EXP (SCOPE_REF);
560  MARK_TS_EXP (STATIC_CAST_EXPR);
561  MARK_TS_EXP (STMT_EXPR);
562  MARK_TS_EXP (TAG_DEFN);
563  MARK_TS_EXP (TEMPLATE_ID_EXPR);
564  MARK_TS_EXP (THROW_EXPR);
565  MARK_TS_EXP (TRAIT_EXPR);
566  MARK_TS_EXP (TYPEID_EXPR);
567  MARK_TS_EXP (TYPE_EXPR);
568  MARK_TS_EXP (UNARY_PLUS_EXPR);
569  MARK_TS_EXP (VEC_DELETE_EXPR);
570  MARK_TS_EXP (VEC_INIT_EXPR);
571  MARK_TS_EXP (VEC_NEW_EXPR);
572  MARK_TS_EXP (SPACESHIP_EXPR);
573
574  /* Fold expressions.  */
575  MARK_TS_EXP (BINARY_LEFT_FOLD_EXPR);
576  MARK_TS_EXP (BINARY_RIGHT_FOLD_EXPR);
577  MARK_TS_EXP (EXPR_PACK_EXPANSION);
578  MARK_TS_EXP (NONTYPE_ARGUMENT_PACK);
579  MARK_TS_EXP (UNARY_LEFT_FOLD_EXPR);
580  MARK_TS_EXP (UNARY_RIGHT_FOLD_EXPR);
581
582  /* Constraints.  */
583  MARK_TS_EXP (CHECK_CONSTR);
584  MARK_TS_EXP (COMPOUND_REQ);
585  MARK_TS_EXP (CONJ_CONSTR);
586  MARK_TS_EXP (DISJ_CONSTR);
587  MARK_TS_EXP (ATOMIC_CONSTR);
588  MARK_TS_EXP (NESTED_REQ);
589  MARK_TS_EXP (REQUIRES_EXPR);
590  MARK_TS_EXP (SIMPLE_REQ);
591  MARK_TS_EXP (TYPE_REQ);
592
593  MARK_TS_EXP (CO_AWAIT_EXPR);
594  MARK_TS_EXP (CO_YIELD_EXPR);
595  MARK_TS_EXP (CO_RETURN_EXPR);
596
597  c_common_init_ts ();
598}
599
600/* Handle C++-specficic options here.  Punt to c_common otherwise.  */
601
602bool
603cp_handle_option (size_t scode, const char *arg, HOST_WIDE_INT value,
604		  int kind, location_t loc,
605		  const struct cl_option_handlers *handlers)
606{
607  if (handle_module_option (unsigned (scode), arg, value))
608    return true;
609  return c_common_handle_option (scode, arg, value, kind, loc, handlers);
610}
611
612#include "gt-cp-cp-objcp-common.h"
613