1 /* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987-2021 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
22 /* This file is the lexical analyzer for GNU C++. */
25 /* For use with name_hint. */
26 #define INCLUDE_UNIQUE_PTR
28 #include "coretypes.h"
30 #include "stringpool.h"
31 #include "c-family/c-pragma.h"
32 #include "c-family/c-objc.h"
33 #include "gcc-rich-location.h"
34 #include "cp-name-hint.h"
35 #include "langhooks.h"
37 static int interface_strcmp (const char *);
38 static void init_cp_pragma (void);
40 static tree
parse_strconst_pragma (const char *, int);
41 static void handle_pragma_vtable (cpp_reader
*);
42 static void handle_pragma_unit (cpp_reader
*);
43 static void handle_pragma_interface (cpp_reader
*);
44 static void handle_pragma_implementation (cpp_reader
*);
46 static void init_operators (void);
47 static void copy_lang_type (tree
);
49 /* A constraint that can be tested at compile time. */
50 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
52 /* Functions and data structures for #pragma interface.
54 `#pragma implementation' means that the main file being compiled
55 is considered to implement (provide) the classes that appear in
56 its main body. I.e., if this is file "foo.cc", and class `bar'
57 is defined in "foo.cc", then we say that "foo.cc implements bar".
59 All main input files "implement" themselves automagically.
61 `#pragma interface' means that unless this file (of the form "foo.h"
62 is not presently being included by file "foo.cc", the
63 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
64 of the vtables nor any of the inline functions defined in foo.h
67 There are cases when we want to link files such as "defs.h" and
68 "main.cc". In this case, we give "defs.h" a `#pragma interface',
69 and "main.cc" has `#pragma implementation "defs.h"'. */
74 struct impl_files
*next
;
77 static struct impl_files
*impl_file_chain
;
85 ovl_op_info_t ovl_op_info
[2][OVL_OP_MAX
] =
88 {NULL_TREE
, NULL
, NULL
, ERROR_MARK
, OVL_OP_ERROR_MARK
, 0},
89 {NULL_TREE
, NULL
, NULL
, NOP_EXPR
, OVL_OP_NOP_EXPR
, 0},
90 #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \
91 {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS},
92 #define OPERATOR_TRANSITION }, { \
93 {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
94 #include "operators.def"
97 unsigned char ovl_op_mapping
[MAX_TREE_CODES
];
98 unsigned char ovl_op_alternate
[OVL_OP_MAX
];
100 /* Get the name of the kind of identifier T. */
103 get_identifier_kind_name (tree id
)
105 /* Keep in sync with cp_id_kind enumeration. */
106 static const char *const names
[cik_max
] = {
107 "normal", "keyword", "constructor", "destructor",
108 "simple-op", "assign-op", "conv-op", "<reserved>udlit-op"
112 kind
|= IDENTIFIER_KIND_BIT_2 (id
) << 2;
113 kind
|= IDENTIFIER_KIND_BIT_1 (id
) << 1;
114 kind
|= IDENTIFIER_KIND_BIT_0 (id
) << 0;
119 /* Set the identifier kind, which we expect to currently be zero. */
122 set_identifier_kind (tree id
, cp_identifier_kind kind
)
124 gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id
)
125 & !IDENTIFIER_KIND_BIT_1 (id
)
126 & !IDENTIFIER_KIND_BIT_0 (id
));
127 IDENTIFIER_KIND_BIT_2 (id
) |= (kind
>> 2) & 1;
128 IDENTIFIER_KIND_BIT_1 (id
) |= (kind
>> 1) & 1;
129 IDENTIFIER_KIND_BIT_0 (id
) |= (kind
>> 0) & 1;
132 /* Create and tag the internal operator name for the overloaded
133 operator PTR describes. */
136 set_operator_ident (ovl_op_info_t
*ptr
)
139 size_t len
= snprintf (buffer
, sizeof (buffer
), "operator%s%s",
140 &" "[ptr
->name
[0] && ptr
->name
[0] != '_'
141 && !ISALPHA (ptr
->name
[0])],
143 gcc_checking_assert (len
< sizeof (buffer
));
145 tree ident
= get_identifier_with_length (buffer
, len
);
146 ptr
->identifier
= ident
;
151 /* Initialize data structures that keep track of operator names. */
154 init_operators (void)
156 /* We rely on both these being zero. */
157 gcc_checking_assert (!OVL_OP_ERROR_MARK
&& !ERROR_MARK
);
159 /* This loop iterates backwards because we need to move the
160 assignment operators down to their correct slots. I.e. morally
161 equivalent to an overlapping memmove where dest > src. Slot
162 zero is for error_mark, so hae no operator. */
163 for (unsigned ix
= OVL_OP_MAX
; --ix
;)
165 ovl_op_info_t
*op_ptr
= &ovl_op_info
[false][ix
];
169 tree ident
= set_operator_ident (op_ptr
);
170 if (unsigned index
= IDENTIFIER_CP_INDEX (ident
))
172 ovl_op_info_t
*bin_ptr
= &ovl_op_info
[false][index
];
174 /* They should only differ in unary/binary ness. */
175 gcc_checking_assert ((op_ptr
->flags
^ bin_ptr
->flags
)
176 == OVL_OP_FLAG_AMBIARY
);
177 bin_ptr
->flags
|= op_ptr
->flags
;
178 ovl_op_alternate
[index
] = ix
;
182 IDENTIFIER_CP_INDEX (ident
) = ix
;
183 set_identifier_kind (ident
, cik_simple_op
);
186 if (op_ptr
->tree_code
)
188 gcc_checking_assert (op_ptr
->ovl_op_code
== ix
189 && !ovl_op_mapping
[op_ptr
->tree_code
]);
190 ovl_op_mapping
[op_ptr
->tree_code
] = op_ptr
->ovl_op_code
;
193 ovl_op_info_t
*as_ptr
= &ovl_op_info
[true][ix
];
196 /* These will be placed at the start of the array, move to
197 the correct slot and initialize. */
198 if (as_ptr
->ovl_op_code
!= ix
)
200 ovl_op_info_t
*dst_ptr
= &ovl_op_info
[true][as_ptr
->ovl_op_code
];
201 gcc_assert (as_ptr
->ovl_op_code
> ix
&& !dst_ptr
->tree_code
);
202 memcpy (dst_ptr
, as_ptr
, sizeof (*dst_ptr
));
203 memset (as_ptr
, 0, sizeof (*as_ptr
));
207 tree ident
= set_operator_ident (as_ptr
);
208 gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident
));
209 IDENTIFIER_CP_INDEX (ident
) = as_ptr
->ovl_op_code
;
210 set_identifier_kind (ident
, cik_assign_op
);
212 gcc_checking_assert (!ovl_op_mapping
[as_ptr
->tree_code
]
213 || (ovl_op_mapping
[as_ptr
->tree_code
]
214 == as_ptr
->ovl_op_code
));
215 ovl_op_mapping
[as_ptr
->tree_code
] = as_ptr
->ovl_op_code
;
220 /* Initialize the reserved words. */
229 if (cxx_dialect
< cxx11
)
231 if (cxx_dialect
< cxx20
)
234 mask
|= D_CXX_CONCEPTS
;
235 if (!flag_coroutines
)
236 mask
|= D_CXX_COROUTINES
;
238 mask
|= D_CXX_MODULES
;
242 mask
|= D_CXX_CHAR8_T
;
244 mask
|= D_ASM
| D_EXT
;
245 if (flag_no_gnu_keywords
)
248 /* The Objective-C keywords are all context-dependent. */
251 ridpointers
= ggc_cleared_vec_alloc
<tree
> ((int) RID_MAX
);
252 for (i
= 0; i
< num_c_common_reswords
; i
++)
254 if (c_common_reswords
[i
].disable
& D_CONLY
)
256 id
= get_identifier (c_common_reswords
[i
].word
);
257 C_SET_RID_CODE (id
, c_common_reswords
[i
].rid
);
258 ridpointers
[(int) c_common_reswords
[i
].rid
] = id
;
259 if (! (c_common_reswords
[i
].disable
& mask
))
260 set_identifier_kind (id
, cik_keyword
);
263 for (i
= 0; i
< NUM_INT_N_ENTS
; i
++)
266 sprintf (name
, "__int%d", int_n_data
[i
].bitsize
);
267 id
= get_identifier (name
);
268 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
269 set_identifier_kind (id
, cik_keyword
);
271 sprintf (name
, "__int%d__", int_n_data
[i
].bitsize
);
272 id
= get_identifier (name
);
273 C_SET_RID_CODE (id
, RID_FIRST_INT_N
+ i
);
274 set_identifier_kind (id
, cik_keyword
);
279 init_cp_pragma (void)
281 c_register_pragma (0, "vtable", handle_pragma_vtable
);
282 c_register_pragma (0, "unit", handle_pragma_unit
);
283 c_register_pragma (0, "interface", handle_pragma_interface
);
284 c_register_pragma (0, "implementation", handle_pragma_implementation
);
285 c_register_pragma ("GCC", "interface", handle_pragma_interface
);
286 c_register_pragma ("GCC", "implementation", handle_pragma_implementation
);
289 /* TRUE if a code represents a statement. */
291 bool statement_code_p
[MAX_TREE_CODES
];
293 /* Initialize the C++ front end. This function is very sensitive to
294 the exact order that things are done here. It would be nice if the
295 initialization done by this routine were moved to its subroutines,
296 and the ordering dependencies clarified and reduced. */
300 location_t saved_loc
;
302 static const enum tree_code stmt_codes
[] = {
303 CTOR_INITIALIZER
, TRY_BLOCK
, HANDLER
,
304 EH_SPEC_BLOCK
, USING_STMT
, TAG_DEFN
,
305 IF_STMT
, CLEANUP_STMT
, FOR_STMT
,
306 RANGE_FOR_STMT
, WHILE_STMT
, DO_STMT
,
307 BREAK_STMT
, CONTINUE_STMT
, SWITCH_STMT
,
308 EXPR_STMT
, OMP_DEPOBJ
311 memset (&statement_code_p
, 0, sizeof (statement_code_p
));
312 for (i
= 0; i
< ARRAY_SIZE (stmt_codes
); i
++)
313 statement_code_p
[stmt_codes
[i
]] = true;
315 saved_loc
= input_location
;
316 input_location
= BUILTINS_LOCATION
;
320 init_cp_semantics ();
324 current_function_decl
= NULL
;
326 class_type_node
= ridpointers
[(int) RID_CLASS
];
328 cxx_init_decl_processing ();
330 if (c_common_init () == false)
332 input_location
= saved_loc
;
338 input_location
= saved_loc
;
342 /* Return nonzero if S is not considered part of an
343 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
346 interface_strcmp (const char* s
)
348 /* Set the interface/implementation bits for this scope. */
349 struct impl_files
*ifiles
;
352 for (ifiles
= impl_file_chain
; ifiles
; ifiles
= ifiles
->next
)
354 const char *t1
= ifiles
->filename
;
357 if (*s1
== 0 || filename_ncmp (s1
, t1
, 1) != 0)
360 while (*s1
!= 0 && filename_ncmp (s1
, t1
, 1) == 0)
367 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
368 if (strchr (s1
, '.') || strchr (t1
, '.'))
371 if (*s1
== '\0' || s1
[-1] != '.' || t1
[-1] != '.')
382 /* We've just read a cpp-token, figure out our next state. Hey, this
383 is a hand-coded co-routine! */
385 struct module_token_filter
395 enum state state
: 8;
401 location_t token_loc
;
403 module_state
*module
;
404 module_state
*import
;
406 module_token_filter (cpp_reader
*reader
)
407 : state (idle
), is_import (false),
408 got_export (false), got_colon (false), want_dot (false),
409 token_loc (UNKNOWN_LOCATION
),
410 reader (reader
), module (NULL
), import (NULL
)
414 /* Process the next token. Note we cannot see CPP_EOF inside a
415 pragma -- a CPP_PRAGMA_EOL always happens. */
416 uintptr_t resume (int type
, int keyword
, tree value
, location_t loc
)
423 if (type
== CPP_KEYWORD
)
431 res
= lang_hooks::PT_begin_pragma
;
438 state
= module_first
;
444 res
= lang_hooks::PT_begin_pragma
;
450 if (is_import
&& type
== CPP_HEADER_NAME
)
452 /* A header name. The preprocessor will have already
453 done include searching and canonicalization. */
458 if (type
== CPP_PADDING
|| type
== CPP_COMMENT
)
462 if (type
== CPP_COLON
&& module
)
478 /* If we ever need to pay attention to attributes for
479 header modules, more logic will be needed. */
500 /* Got name instead of [.:]. */
505 import
= get_module (value
, import
, got_colon
);
512 if (type
== CPP_PRAGMA_EOL
)
515 /* End of the directive, handle the name. */
516 if (import
&& (is_import
|| !flag_header_unit
))
518 = preprocess_module (import
, token_loc
, module
!= NULL
,
519 is_import
, got_export
, reader
))
523 is_import
= got_export
= false;
533 /* Initialize or teardown. */
536 module_token_cdtor (cpp_reader
*pfile
, uintptr_t data_
)
538 if (module_token_filter
*filter
= reinterpret_cast<module_token_filter
*> (data_
))
540 preprocessed_module (pfile
);
544 else if (modules_p ())
545 data_
= reinterpret_cast<uintptr_t > (new module_token_filter (pfile
));
551 module_token_lang (int type
, int keyword
, tree value
, location_t loc
,
554 module_token_filter
*filter
= reinterpret_cast<module_token_filter
*> (data_
);
555 return filter
->resume (type
, keyword
, value
, loc
);
559 module_token_pre (cpp_reader
*pfile
, const cpp_token
*tok
, uintptr_t data_
)
562 return module_token_cdtor (pfile
, data_
);
564 int type
= tok
->type
;
565 int keyword
= RID_MAX
;
566 tree value
= NULL_TREE
;
568 if (tok
->type
== CPP_NAME
)
570 value
= HT_IDENT_TO_GCC_IDENT (HT_NODE (tok
->val
.node
.node
));
571 if (IDENTIFIER_KEYWORD_P (value
))
573 keyword
= C_RID_CODE (value
);
577 else if (tok
->type
== CPP_HEADER_NAME
)
578 value
= build_string (tok
->val
.str
.len
, (const char *)tok
->val
.str
.text
);
580 return module_token_lang (type
, keyword
, value
, tok
->src_loc
, data_
);
583 /* Parse a #pragma whose sole argument is a string constant.
584 If OPT is true, the argument is optional. */
586 parse_strconst_pragma (const char* name
, int opt
)
591 t
= pragma_lex (&result
);
594 if (pragma_lex (&x
) != CPP_EOF
)
595 warning (0, "junk at end of %<#pragma %s%>", name
);
599 if (t
== CPP_EOF
&& opt
)
602 error ("invalid %<#pragma %s%>", name
);
603 return error_mark_node
;
607 handle_pragma_vtable (cpp_reader
* /*dfile*/)
609 parse_strconst_pragma ("vtable", 0);
610 sorry ("%<#pragma vtable%> no longer supported");
614 handle_pragma_unit (cpp_reader
* /*dfile*/)
616 /* Validate syntax, but don't do anything. */
617 parse_strconst_pragma ("unit", 0);
621 handle_pragma_interface (cpp_reader
* /*dfile*/)
623 tree fname
= parse_strconst_pragma ("interface", 1);
624 struct c_fileinfo
*finfo
;
625 const char *filename
;
627 if (fname
== error_mark_node
)
630 filename
= lbasename (LOCATION_FILE (input_location
));
632 filename
= TREE_STRING_POINTER (fname
);
634 finfo
= get_fileinfo (LOCATION_FILE (input_location
));
636 if (impl_file_chain
== 0)
638 /* If this is zero at this point, then we are
639 auto-implementing. */
640 if (main_input_filename
== 0)
641 main_input_filename
= LOCATION_FILE (input_location
);
644 finfo
->interface_only
= interface_strcmp (filename
);
645 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
646 a definition in another file. */
647 if (!MULTIPLE_SYMBOL_SPACES
|| !finfo
->interface_only
)
648 finfo
->interface_unknown
= 0;
651 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
652 We used to only allow this at toplevel, but that restriction was buggy
653 in older compilers and it seems reasonable to allow it in the headers
654 themselves, too. It only needs to precede the matching #p interface.
656 We don't touch finfo->interface_only or finfo->interface_unknown;
657 the user must specify a matching #p interface for this to have
661 handle_pragma_implementation (cpp_reader
* /*dfile*/)
663 tree fname
= parse_strconst_pragma ("implementation", 1);
664 const char *filename
;
665 struct impl_files
*ifiles
= impl_file_chain
;
667 if (fname
== error_mark_node
)
672 if (main_input_filename
)
673 filename
= main_input_filename
;
675 filename
= LOCATION_FILE (input_location
);
676 filename
= lbasename (filename
);
680 filename
= TREE_STRING_POINTER (fname
);
681 if (cpp_included_before (parse_in
, filename
, input_location
))
682 warning (0, "%<#pragma implementation%> for %qs appears after "
683 "file is included", filename
);
686 for (; ifiles
; ifiles
= ifiles
->next
)
688 if (! filename_cmp (ifiles
->filename
, filename
))
693 ifiles
= XNEW (struct impl_files
);
694 ifiles
->filename
= xstrdup (filename
);
695 ifiles
->next
= impl_file_chain
;
696 impl_file_chain
= ifiles
;
700 /* Issue an error message indicating that the lookup of NAME (an
701 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
704 unqualified_name_lookup_error (tree name
, location_t loc
)
706 if (loc
== UNKNOWN_LOCATION
)
707 loc
= cp_expr_loc_or_input_loc (name
);
709 if (IDENTIFIER_ANY_OP_P (name
))
710 error_at (loc
, "%qD not defined", name
);
713 if (!objc_diagnose_private_ivar (name
))
715 auto_diagnostic_group d
;
716 name_hint hint
= suggest_alternatives_for (loc
, name
, true);
717 if (const char *suggestion
= hint
.suggestion ())
719 gcc_rich_location
richloc (loc
);
720 richloc
.add_fixit_replace (suggestion
);
722 "%qD was not declared in this scope; did you mean %qs?",
726 error_at (loc
, "%qD was not declared in this scope", name
);
728 /* Prevent repeated error messages by creating a VAR_DECL with
729 this NAME in the innermost block scope. */
730 if (local_bindings_p ())
732 tree decl
= build_decl (loc
, VAR_DECL
, name
, error_mark_node
);
733 TREE_USED (decl
) = true;
738 return error_mark_node
;
741 /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
742 NAME, encapsulated with its location in a CP_EXPR, used as a function.
743 Returns an appropriate expression for NAME. */
746 unqualified_fn_lookup_error (cp_expr name_expr
)
748 tree name
= name_expr
.get_value ();
749 location_t loc
= name_expr
.get_location ();
750 if (loc
== UNKNOWN_LOCATION
)
751 loc
= input_location
;
753 if (TREE_CODE (name
) == TEMPLATE_ID_EXPR
)
754 name
= TREE_OPERAND (name
, 0);
756 if (processing_template_decl
)
758 /* In a template, it is invalid to write "f()" or "f(3)" if no
759 declaration of "f" is available. Historically, G++ and most
760 other compilers accepted that usage since they deferred all name
761 lookup until instantiation time rather than doing unqualified
762 name lookup at template definition time; explain to the user what
765 Note that we have the exact wording of the following message in
766 the manual (trouble.texi, node "Name lookup"), so they need to
768 permerror (loc
, "there are no arguments to %qD that depend on a template "
769 "parameter, so a declaration of %qD must be available",
772 if (!flag_permissive
)
777 inform (loc
, "(if you use %<-fpermissive%>, G++ will accept your "
778 "code, but allowing the use of an undeclared name is "
786 return unqualified_name_lookup_error (name
, loc
);
790 /* Hasher for the conversion operator name hash table. */
791 struct conv_type_hasher
: ggc_ptr_hash
<tree_node
>
793 /* Hash NODE, an identifier node in the table. TYPE_UID is
794 suitable, as we're not concerned about matching canonicalness
796 static hashval_t
hash (tree node
)
798 return (hashval_t
) TYPE_UID (TREE_TYPE (node
));
801 /* Compare NODE, an identifier node in the table, against TYPE, an
802 incoming TYPE being looked up. */
803 static bool equal (tree node
, tree type
)
805 return TREE_TYPE (node
) == type
;
809 /* This hash table maps TYPEs to the IDENTIFIER for a conversion
810 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
813 static GTY (()) hash_table
<conv_type_hasher
> *conv_type_names
;
815 /* Return an identifier for a conversion operator to TYPE. We can get
816 from the returned identifier to the type. We store TYPE, which is
817 not necessarily the canonical type, which allows us to report the
818 form the user used in error messages. All these identifiers are
819 not in the identifier hash table, and have the same string name.
820 These IDENTIFIERS are not in the identifier hash table, and all
821 have the same IDENTIFIER_STRING. */
824 make_conv_op_name (tree type
)
826 if (type
== error_mark_node
)
827 return error_mark_node
;
829 if (conv_type_names
== NULL
)
830 conv_type_names
= hash_table
<conv_type_hasher
>::create_ggc (31);
832 tree
*slot
= conv_type_names
->find_slot_with_hash
833 (type
, (hashval_t
) TYPE_UID (type
), INSERT
);
834 tree identifier
= *slot
;
837 /* Create a raw IDENTIFIER outside of the identifier hash
839 identifier
= copy_node (conv_op_identifier
);
841 /* Just in case something managed to bind. */
842 IDENTIFIER_BINDING (identifier
) = NULL
;
844 /* Hang TYPE off the identifier so it can be found easily later
845 when performing conversions. */
846 TREE_TYPE (identifier
) = type
;
854 /* Wrapper around build_lang_decl_loc(). Should gradually move to
855 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
856 build_lang_decl(). */
859 build_lang_decl (enum tree_code code
, tree name
, tree type
)
861 return build_lang_decl_loc (input_location
, code
, name
, type
);
864 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
865 DECL_LANG_SPECIFIC info to the result. */
868 build_lang_decl_loc (location_t loc
, enum tree_code code
, tree name
, tree type
)
872 t
= build_decl (loc
, code
, name
, type
);
873 retrofit_lang_decl (t
);
878 /* Maybe add a raw lang_decl to T, a decl. Return true if it needed
882 maybe_add_lang_decl_raw (tree t
, bool decomp_p
)
885 lang_decl_selector sel
;
888 sel
= lds_decomp
, size
= sizeof (struct lang_decl_decomp
);
889 else if (TREE_CODE (t
) == FUNCTION_DECL
)
890 sel
= lds_fn
, size
= sizeof (struct lang_decl_fn
);
891 else if (TREE_CODE (t
) == NAMESPACE_DECL
)
892 sel
= lds_ns
, size
= sizeof (struct lang_decl_ns
);
893 else if (TREE_CODE (t
) == PARM_DECL
)
894 sel
= lds_parm
, size
= sizeof (struct lang_decl_parm
);
895 else if (LANG_DECL_HAS_MIN (t
))
896 sel
= lds_min
, size
= sizeof (struct lang_decl_min
);
901 = (struct lang_decl
*) ggc_internal_cleared_alloc (size
);
903 ld
->u
.base
.selector
= sel
;
904 DECL_LANG_SPECIFIC (t
) = ld
;
907 /* Who'd create a namespace, only to put nothing in it? */
908 ld
->u
.ns
.bindings
= hash_table
<named_decl_hash
>::create_ggc (499);
910 if (GATHER_STATISTICS
)
912 tree_node_counts
[(int)lang_decl
] += 1;
913 tree_node_sizes
[(int)lang_decl
] += size
;
918 /* T has just had a decl_lang_specific added. Initialize its
922 set_decl_linkage (tree t
)
924 if (current_lang_name
== lang_name_cplusplus
925 || decl_linkage (t
) == lk_none
)
926 SET_DECL_LANGUAGE (t
, lang_cplusplus
);
927 else if (current_lang_name
== lang_name_c
)
928 SET_DECL_LANGUAGE (t
, lang_c
);
933 /* T is a VAR_DECL node that needs to be a decomposition of BASE. */
936 fit_decomposition_lang_decl (tree t
, tree base
)
938 if (struct lang_decl
*orig_ld
= DECL_LANG_SPECIFIC (t
))
940 if (orig_ld
->u
.base
.selector
== lds_min
)
942 maybe_add_lang_decl_raw (t
, true);
943 memcpy (DECL_LANG_SPECIFIC (t
), orig_ld
,
944 sizeof (struct lang_decl_min
));
945 /* Reset selector, which will have been bashed by the
947 DECL_LANG_SPECIFIC (t
)->u
.base
.selector
= lds_decomp
;
950 gcc_checking_assert (orig_ld
->u
.base
.selector
== lds_decomp
);
954 maybe_add_lang_decl_raw (t
, true);
955 set_decl_linkage (t
);
958 DECL_DECOMP_BASE (t
) = base
;
961 /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
962 every C++ decl needs one, but C builtins etc do not. */
965 retrofit_lang_decl (tree t
)
967 if (DECL_LANG_SPECIFIC (t
))
970 if (maybe_add_lang_decl_raw (t
, false))
971 set_decl_linkage (t
);
975 cxx_dup_lang_specific_decl (tree node
)
979 if (! DECL_LANG_SPECIFIC (node
))
982 switch (DECL_LANG_SPECIFIC (node
)->u
.base
.selector
)
985 size
= sizeof (struct lang_decl_min
);
988 size
= sizeof (struct lang_decl_fn
);
991 size
= sizeof (struct lang_decl_ns
);
994 size
= sizeof (struct lang_decl_parm
);
997 size
= sizeof (struct lang_decl_decomp
);
1003 struct lang_decl
*ld
= (struct lang_decl
*) ggc_internal_alloc (size
);
1004 memcpy (ld
, DECL_LANG_SPECIFIC (node
), size
);
1005 DECL_LANG_SPECIFIC (node
) = ld
;
1007 /* Directly clear some flags that do not apply to the copy
1008 (module_purview_p still does). */
1009 ld
->u
.base
.module_entity_p
= false;
1010 ld
->u
.base
.module_import_p
= false;
1011 ld
->u
.base
.module_attached_p
= false;
1013 if (GATHER_STATISTICS
)
1015 tree_node_counts
[(int)lang_decl
] += 1;
1016 tree_node_sizes
[(int)lang_decl
] += size
;
1020 /* Copy DECL, including any language-specific parts. */
1023 copy_decl (tree decl MEM_STAT_DECL
)
1027 copy
= copy_node (decl PASS_MEM_STAT
);
1028 cxx_dup_lang_specific_decl (copy
);
1032 /* Replace the shared language-specific parts of NODE with a new copy. */
1035 copy_lang_type (tree node
)
1037 if (! TYPE_LANG_SPECIFIC (node
))
1040 auto *lt
= (struct lang_type
*) ggc_internal_alloc (sizeof (struct lang_type
));
1042 memcpy (lt
, TYPE_LANG_SPECIFIC (node
), (sizeof (struct lang_type
)));
1043 TYPE_LANG_SPECIFIC (node
) = lt
;
1045 if (GATHER_STATISTICS
)
1047 tree_node_counts
[(int)lang_type
] += 1;
1048 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
1052 /* Copy TYPE, including any language-specific parts. */
1055 copy_type (tree type MEM_STAT_DECL
)
1059 copy
= copy_node (type PASS_MEM_STAT
);
1060 copy_lang_type (copy
);
1064 /* Add a raw lang_type to T, a type, should it need one. */
1067 maybe_add_lang_type_raw (tree t
)
1069 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t
)))
1072 auto *lt
= (struct lang_type
*) (ggc_internal_cleared_alloc
1073 (sizeof (struct lang_type
)));
1074 TYPE_LANG_SPECIFIC (t
) = lt
;
1076 if (GATHER_STATISTICS
)
1078 tree_node_counts
[(int)lang_type
] += 1;
1079 tree_node_sizes
[(int)lang_type
] += sizeof (struct lang_type
);
1086 cxx_make_type (enum tree_code code MEM_STAT_DECL
)
1088 tree t
= make_node (code PASS_MEM_STAT
);
1090 if (maybe_add_lang_type_raw (t
))
1092 /* Set up some flags that give proper default behavior. */
1093 struct c_fileinfo
*finfo
=
1094 get_fileinfo (LOCATION_FILE (input_location
));
1095 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t
, finfo
->interface_unknown
);
1096 CLASSTYPE_INTERFACE_ONLY (t
) = finfo
->interface_only
;
1099 if (code
== RECORD_TYPE
|| code
== UNION_TYPE
)
1100 TYPE_CXX_ODR_P (t
) = 1;
1105 /* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
1108 cxx_make_type_hook (enum tree_code code
)
1110 return cxx_make_type (code
);
1114 make_class_type (enum tree_code code MEM_STAT_DECL
)
1116 tree t
= cxx_make_type (code PASS_MEM_STAT
);
1117 SET_CLASS_TYPE_P (t
, 1);
1121 /* Returns true if we are currently in the main source file, or in a
1122 template instantiation started from the main source file. */
1125 in_main_input_context (void)
1127 struct tinst_level
*tl
= outermost_tinst_level();
1130 return filename_cmp (main_input_filename
,
1131 LOCATION_FILE (tl
->locus
)) == 0;
1133 return filename_cmp (main_input_filename
, LOCATION_FILE (input_location
)) == 0;
1136 #include "gt-cp-lex.h"