1/* Separate lexical analyzer for GNU C++.
2 Copyright (C) 1987-2024 Free Software Foundation, Inc.
3 Hacked by Michael Tiemann (tiemann@cygnus.com)
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.
11
12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for 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
22/* This file is the lexical analyzer for GNU C++. */
23
24#include "config.h"
25/* For use with name_hint. */
26#define INCLUDE_MEMORY
27#include "system.h"
28#include "coretypes.h"
29#include "cp-tree.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"
36
37static int interface_strcmp (const char *);
38static void init_cp_traits (void);
39static void init_cp_pragma (void);
40
41static tree parse_strconst_pragma (const char *, int);
42static void handle_pragma_vtable (cpp_reader *);
43static void handle_pragma_unit (cpp_reader *);
44static void handle_pragma_interface (cpp_reader *);
45static void handle_pragma_implementation (cpp_reader *);
46
47static void init_operators (void);
48static void copy_lang_type (tree);
49
50/* A constraint that can be tested at compile time. */
51#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1]
52
53/* Functions and data structures for #pragma interface.
54
55 `#pragma implementation' means that the main file being compiled
56 is considered to implement (provide) the classes that appear in
57 its main body. I.e., if this is file "foo.cc", and class `bar'
58 is defined in "foo.cc", then we say that "foo.cc implements bar".
59
60 All main input files "implement" themselves automagically.
61
62 `#pragma interface' means that unless this file (of the form "foo.h"
63 is not presently being included by file "foo.cc", the
64 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none
65 of the vtables nor any of the inline functions defined in foo.h
66 will ever be output.
67
68 There are cases when we want to link files such as "defs.h" and
69 "main.cc". In this case, we give "defs.h" a `#pragma interface',
70 and "main.cc" has `#pragma implementation "defs.h"'. */
71
72struct impl_files
73{
74 const char *filename;
75 struct impl_files *next;
76};
77
78static struct impl_files *impl_file_chain;
79
80void
81cxx_finish (void)
82{
83 c_common_finish ();
84}
85
86ovl_op_info_t ovl_op_info[2][OVL_OP_MAX] =
87 {
88 {
89 {NULL_TREE, NULL, NULL, .tree_code: ERROR_MARK, .ovl_op_code: OVL_OP_ERROR_MARK, .flags: 0},
90 {NULL_TREE, NULL, NULL, .tree_code: NOP_EXPR, .ovl_op_code: OVL_OP_NOP_EXPR, .flags: 0},
91#define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \
92 {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS},
93#define OPERATOR_TRANSITION }, { \
94 {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0},
95#include "operators.def"
96 }
97 };
98unsigned char ovl_op_mapping[MAX_TREE_CODES];
99unsigned char ovl_op_alternate[OVL_OP_MAX];
100
101/* The trait table, declared in cp-tree.h. */
102const cp_trait cp_traits[] =
103{
104#define DEFTRAIT(TCC, CODE, NAME, ARITY) \
105 { NAME, CPTK_##CODE, ARITY, (TCC == tcc_type) },
106#include "cp-trait.def"
107#undef DEFTRAIT
108};
109/* The trait table cannot have more than 255 (addr_space_t) entries since
110 the index is retrieved through IDENTIFIER_CP_INDEX. */
111static_assert(ARRAY_SIZE (cp_traits) <= 255,
112 "cp_traits array cannot have more than 255 entries");
113
114/* Get the name of the kind of identifier T. */
115
116const char *
117get_identifier_kind_name (tree id)
118{
119 /* Keep in sync with cp_id_kind enumeration. */
120 static const char *const names[cik_max] = {
121 "normal", "keyword", "constructor", "destructor",
122 "simple-op", "assign-op", "conv-op", "<reserved>udlit-op"
123 };
124
125 unsigned kind = 0;
126 kind |= IDENTIFIER_KIND_BIT_2 (id) << 2;
127 kind |= IDENTIFIER_KIND_BIT_1 (id) << 1;
128 kind |= IDENTIFIER_KIND_BIT_0 (id) << 0;
129
130 return names[kind];
131}
132
133/* Set the identifier kind, which we expect to currently be zero. */
134
135void
136set_identifier_kind (tree id, cp_identifier_kind kind)
137{
138 gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id)
139 & !IDENTIFIER_KIND_BIT_1 (id)
140 & !IDENTIFIER_KIND_BIT_0 (id));
141 IDENTIFIER_KIND_BIT_2 (id) |= (kind >> 2) & 1;
142 IDENTIFIER_KIND_BIT_1 (id) |= (kind >> 1) & 1;
143 IDENTIFIER_KIND_BIT_0 (id) |= (kind >> 0) & 1;
144}
145
146/* Create and tag the internal operator name for the overloaded
147 operator PTR describes. */
148
149static tree
150set_operator_ident (ovl_op_info_t *ptr)
151{
152 char buffer[32];
153 size_t len = snprintf (s: buffer, maxlen: sizeof (buffer), format: "operator%s%s",
154 &" "[ptr->name[0] && ptr->name[0] != '_'
155 && !ISALPHA (ptr->name[0])],
156 ptr->name);
157 gcc_checking_assert (len < sizeof (buffer));
158
159 tree ident = get_identifier_with_length (buffer, len);
160 ptr->identifier = ident;
161
162 return ident;
163}
164
165/* Initialize data structures that keep track of operator names. */
166
167static void
168init_operators (void)
169{
170 /* We rely on both these being zero. */
171 gcc_checking_assert (!OVL_OP_ERROR_MARK && !ERROR_MARK);
172
173 /* This loop iterates backwards because we need to move the
174 assignment operators down to their correct slots. I.e. morally
175 equivalent to an overlapping memmove where dest > src. Slot
176 zero is for error_mark, so hae no operator. */
177 for (unsigned ix = OVL_OP_MAX; --ix;)
178 {
179 ovl_op_info_t *op_ptr = &ovl_op_info[false][ix];
180
181 if (op_ptr->name)
182 {
183 tree ident = set_operator_ident (op_ptr);
184 if (unsigned index = IDENTIFIER_CP_INDEX (ident))
185 {
186 ovl_op_info_t *bin_ptr = &ovl_op_info[false][index];
187
188 /* They should only differ in unary/binary ness. */
189 gcc_checking_assert ((op_ptr->flags ^ bin_ptr->flags)
190 == OVL_OP_FLAG_AMBIARY);
191 bin_ptr->flags |= op_ptr->flags;
192 ovl_op_alternate[index] = ix;
193 }
194 else
195 {
196 IDENTIFIER_CP_INDEX (ident) = ix;
197 set_identifier_kind (id: ident, kind: cik_simple_op);
198 }
199 }
200 if (op_ptr->tree_code)
201 {
202 gcc_checking_assert (op_ptr->ovl_op_code == ix
203 && !ovl_op_mapping[op_ptr->tree_code]);
204 ovl_op_mapping[op_ptr->tree_code] = op_ptr->ovl_op_code;
205 }
206
207 ovl_op_info_t *as_ptr = &ovl_op_info[true][ix];
208 if (as_ptr->name)
209 {
210 /* These will be placed at the start of the array, move to
211 the correct slot and initialize. */
212 if (as_ptr->ovl_op_code != ix)
213 {
214 ovl_op_info_t *dst_ptr = &ovl_op_info[true][as_ptr->ovl_op_code];
215 gcc_assert (as_ptr->ovl_op_code > ix && !dst_ptr->tree_code);
216 memcpy (dest: dst_ptr, src: as_ptr, n: sizeof (*dst_ptr));
217 memset (s: as_ptr, c: 0, n: sizeof (*as_ptr));
218 as_ptr = dst_ptr;
219 }
220
221 tree ident = set_operator_ident (as_ptr);
222 gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident));
223 IDENTIFIER_CP_INDEX (ident) = as_ptr->ovl_op_code;
224 set_identifier_kind (id: ident, kind: cik_assign_op);
225
226 gcc_checking_assert (!ovl_op_mapping[as_ptr->tree_code]
227 || (ovl_op_mapping[as_ptr->tree_code]
228 == as_ptr->ovl_op_code));
229 ovl_op_mapping[as_ptr->tree_code] = as_ptr->ovl_op_code;
230 }
231 }
232}
233
234/* Initialize the reserved words. */
235
236void
237init_reswords (void)
238{
239 unsigned int i;
240 tree id;
241 int mask = 0;
242
243 if (cxx_dialect < cxx11)
244 mask |= D_CXX11;
245 if (cxx_dialect < cxx20)
246 mask |= D_CXX20;
247 if (!flag_concepts)
248 mask |= D_CXX_CONCEPTS;
249 if (!flag_coroutines)
250 mask |= D_CXX_COROUTINES;
251 if (!flag_modules)
252 mask |= D_CXX_MODULES;
253 if (!flag_tm)
254 mask |= D_TRANSMEM;
255 if (!flag_char8_t)
256 mask |= D_CXX_CHAR8_T;
257 if (flag_no_asm)
258 mask |= D_ASM | D_EXT | D_EXT11;
259 if (flag_no_gnu_keywords)
260 mask |= D_EXT | D_EXT11;
261
262 /* The Objective-C keywords are all context-dependent. */
263 mask |= D_OBJC;
264
265 ridpointers = ggc_cleared_vec_alloc<tree> (c: (int) RID_MAX);
266 for (i = 0; i < num_c_common_reswords; i++)
267 {
268 if (c_common_reswords[i].disable & D_CONLY)
269 continue;
270 id = get_identifier (c_common_reswords[i].word);
271 C_SET_RID_CODE (id, c_common_reswords[i].rid);
272 ridpointers [(int) c_common_reswords[i].rid] = id;
273 if (! (c_common_reswords[i].disable & mask))
274 set_identifier_kind (id, kind: cik_keyword);
275 }
276
277 for (i = 0; i < NUM_INT_N_ENTS; i++)
278 {
279 char name[50];
280 sprintf (s: name, format: "__int%d", int_n_data[i].bitsize);
281 id = get_identifier (name);
282 C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
283 set_identifier_kind (id, kind: cik_keyword);
284
285 sprintf (s: name, format: "__int%d__", int_n_data[i].bitsize);
286 id = get_identifier (name);
287 C_SET_RID_CODE (id, RID_FIRST_INT_N + i);
288 set_identifier_kind (id, kind: cik_keyword);
289 }
290
291 if (flag_openmp)
292 {
293 id = get_identifier ("omp_all_memory");
294 C_SET_RID_CODE (id, RID_OMP_ALL_MEMORY);
295 set_identifier_kind (id, kind: cik_keyword);
296 ridpointers [RID_OMP_ALL_MEMORY] = id;
297 }
298}
299
300/* Initialize the C++ traits. */
301static void
302init_cp_traits (void)
303{
304 tree id;
305
306 for (unsigned int i = 0; i < ARRAY_SIZE (cp_traits); ++i)
307 {
308 id = get_identifier (cp_traits[i].name);
309 IDENTIFIER_CP_INDEX (id) = cp_traits[i].kind;
310 set_identifier_kind (id, kind: cik_trait);
311 }
312
313 /* An alias for __is_same. */
314 id = get_identifier ("__is_same_as");
315 IDENTIFIER_CP_INDEX (id) = CPTK_IS_SAME;
316 set_identifier_kind (id, kind: cik_trait);
317}
318
319static void
320init_cp_pragma (void)
321{
322 c_register_pragma (space: 0, name: "vtable", handler: handle_pragma_vtable);
323 c_register_pragma (space: 0, name: "unit", handler: handle_pragma_unit);
324 c_register_pragma (space: 0, name: "interface", handler: handle_pragma_interface);
325 c_register_pragma (space: 0, name: "implementation", handler: handle_pragma_implementation);
326 c_register_pragma (space: "GCC", name: "interface", handler: handle_pragma_interface);
327 c_register_pragma (space: "GCC", name: "implementation", handler: handle_pragma_implementation);
328}
329
330/* TRUE if a code represents a statement. */
331
332bool statement_code_p[MAX_TREE_CODES];
333
334/* Initialize the C++ front end. This function is very sensitive to
335 the exact order that things are done here. It would be nice if the
336 initialization done by this routine were moved to its subroutines,
337 and the ordering dependencies clarified and reduced. */
338bool
339cxx_init (void)
340{
341 location_t saved_loc;
342 unsigned int i;
343 static const enum tree_code stmt_codes[] = {
344 CTOR_INITIALIZER, TRY_BLOCK, HANDLER,
345 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN,
346 IF_STMT, CLEANUP_STMT, FOR_STMT,
347 RANGE_FOR_STMT, WHILE_STMT, DO_STMT,
348 BREAK_STMT, CONTINUE_STMT, SWITCH_STMT,
349 EXPR_STMT, OMP_DEPOBJ
350 };
351
352 memset (s: &statement_code_p, c: 0, n: sizeof (statement_code_p));
353 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++)
354 statement_code_p[stmt_codes[i]] = true;
355
356 saved_loc = input_location;
357 input_location = BUILTINS_LOCATION;
358
359 init_reswords ();
360 init_cp_traits ();
361 init_tree ();
362 init_cp_semantics ();
363 init_operators ();
364 init_method ();
365
366 current_function_decl = NULL;
367
368 class_type_node = ridpointers[(int) RID_CLASS];
369
370 cxx_init_decl_processing ();
371
372 if (c_common_init () == false)
373 {
374 input_location = saved_loc;
375 return false;
376 }
377
378 init_cp_pragma ();
379
380 input_location = saved_loc;
381 return true;
382}
383
384/* Return nonzero if S is not considered part of an
385 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */
386
387static int
388interface_strcmp (const char* s)
389{
390 /* Set the interface/implementation bits for this scope. */
391 struct impl_files *ifiles;
392 const char *s1;
393
394 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next)
395 {
396 const char *t1 = ifiles->filename;
397 s1 = s;
398
399 if (*s1 == 0 || filename_ncmp (s1, s2: t1, n: 1) != 0)
400 continue;
401
402 while (*s1 != 0 && filename_ncmp (s1, s2: t1, n: 1) == 0)
403 s1++, t1++;
404
405 /* A match. */
406 if (*s1 == *t1)
407 return 0;
408
409 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */
410 if (strchr (s: s1, c: '.') || strchr (s: t1, c: '.'))
411 continue;
412
413 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.')
414 continue;
415
416 /* A match. */
417 return 0;
418 }
419
420 /* No matches. */
421 return 1;
422}
423
424/* We've just read a cpp-token, figure out our next state. Hey, this
425 is a hand-coded co-routine! */
426
427struct module_token_filter
428{
429 enum state
430 {
431 idle,
432 module_first,
433 module_cont,
434 module_end,
435 };
436
437 enum state state : 8;
438 bool is_import : 1;
439 bool got_export : 1;
440 bool got_colon : 1;
441 bool want_dot : 1;
442
443 location_t token_loc;
444 cpp_reader *reader;
445 module_state *module;
446 module_state *import;
447
448 module_token_filter (cpp_reader *reader)
449 : state (idle), is_import (false),
450 got_export (false), got_colon (false), want_dot (false),
451 token_loc (UNKNOWN_LOCATION),
452 reader (reader), module (NULL), import (NULL)
453 {
454 };
455
456 /* Process the next token. Note we cannot see CPP_EOF inside a
457 pragma -- a CPP_PRAGMA_EOL always happens. */
458 uintptr_t resume (int type, int keyword, tree value, location_t loc)
459 {
460 unsigned res = 0;
461
462 switch (state)
463 {
464 case idle:
465 if (type == CPP_KEYWORD)
466 switch (keyword)
467 {
468 default:
469 break;
470
471 case RID__EXPORT:
472 got_export = true;
473 res = lang_hooks::PT_begin_pragma;
474 break;
475
476 case RID__IMPORT:
477 is_import = true;
478 /* FALLTHRU */
479 case RID__MODULE:
480 state = module_first;
481 want_dot = false;
482 got_colon = false;
483 token_loc = loc;
484 import = NULL;
485 if (!got_export)
486 res = lang_hooks::PT_begin_pragma;
487 break;
488 }
489 break;
490
491 case module_first:
492 if (is_import && type == CPP_HEADER_NAME)
493 {
494 /* A header name. The preprocessor will have already
495 done include searching and canonicalization. */
496 state = module_end;
497 goto header_unit;
498 }
499
500 if (type == CPP_PADDING || type == CPP_COMMENT)
501 break;
502
503 state = module_cont;
504 if (type == CPP_COLON && module)
505 {
506 got_colon = true;
507 import = module;
508 break;
509 }
510 /* FALLTHROUGH */
511
512 case module_cont:
513 switch (type)
514 {
515 case CPP_PADDING:
516 case CPP_COMMENT:
517 break;
518
519 default:
520 /* If we ever need to pay attention to attributes for
521 header modules, more logic will be needed. */
522 state = module_end;
523 break;
524
525 case CPP_COLON:
526 if (got_colon)
527 state = module_end;
528 got_colon = true;
529 /* FALLTHROUGH */
530 case CPP_DOT:
531 if (!want_dot)
532 state = module_end;
533 want_dot = false;
534 break;
535
536 case CPP_PRAGMA_EOL:
537 goto module_end;
538
539 case CPP_NAME:
540 if (want_dot)
541 {
542 /* Got name instead of [.:]. */
543 state = module_end;
544 break;
545 }
546 header_unit:
547 import = get_module (name: value, parent: import, partition: got_colon);
548 want_dot = true;
549 break;
550 }
551 break;
552
553 case module_end:
554 if (type == CPP_PRAGMA_EOL)
555 {
556 module_end:;
557 /* End of the directive, handle the name. */
558 if (import && (is_import || !flag_header_unit))
559 if (module_state *m
560 = preprocess_module (import, token_loc, in_purview: module != NULL,
561 is_import, export_p: got_export, reader))
562 if (!module)
563 module = m;
564
565 is_import = got_export = false;
566 state = idle;
567 }
568 break;
569 }
570
571 return res;
572 }
573};
574
575/* Initialize or teardown. */
576
577uintptr_t
578module_token_cdtor (cpp_reader *pfile, uintptr_t data_)
579{
580 if (module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_))
581 {
582 preprocessed_module (reader: pfile);
583 delete filter;
584 data_ = 0;
585 }
586 else if (modules_p ())
587 data_ = reinterpret_cast<uintptr_t > (new module_token_filter (pfile));
588
589 return data_;
590}
591
592uintptr_t
593module_token_lang (int type, int keyword, tree value, location_t loc,
594 uintptr_t data_)
595{
596 module_token_filter *filter = reinterpret_cast<module_token_filter *> (data_);
597 return filter->resume (type, keyword, value, loc);
598}
599
600uintptr_t
601module_token_pre (cpp_reader *pfile, const cpp_token *tok, uintptr_t data_)
602{
603 if (!tok)
604 return module_token_cdtor (pfile, data_);
605
606 int type = tok->type;
607 int keyword = RID_MAX;
608 tree value = NULL_TREE;
609
610 if (tok->type == CPP_NAME)
611 {
612 value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
613 if (IDENTIFIER_KEYWORD_P (value))
614 {
615 keyword = C_RID_CODE (value);
616 type = CPP_KEYWORD;
617 }
618 }
619 else if (tok->type == CPP_HEADER_NAME)
620 value = build_string (tok->val.str.len, (const char *)tok->val.str.text);
621
622 return module_token_lang (type, keyword, value, loc: tok->src_loc, data_);
623}
624
625/* Parse a #pragma whose sole argument is a string constant.
626 If OPT is true, the argument is optional. */
627static tree
628parse_strconst_pragma (const char* name, int opt)
629{
630 tree result, x;
631 enum cpp_ttype t;
632
633 t = pragma_lex (&result);
634 if (t == CPP_STRING)
635 {
636 if (pragma_lex (&x) != CPP_EOF)
637 warning (0, "junk at end of %<#pragma %s%>", name);
638 return result;
639 }
640
641 if (t == CPP_EOF && opt)
642 return NULL_TREE;
643
644 error ("invalid %<#pragma %s%>", name);
645 return error_mark_node;
646}
647
648static void
649handle_pragma_vtable (cpp_reader* /*dfile*/)
650{
651 parse_strconst_pragma (name: "vtable", opt: 0);
652 sorry ("%<#pragma vtable%> no longer supported");
653}
654
655static void
656handle_pragma_unit (cpp_reader* /*dfile*/)
657{
658 /* Validate syntax, but don't do anything. */
659 parse_strconst_pragma (name: "unit", opt: 0);
660}
661
662static void
663handle_pragma_interface (cpp_reader* /*dfile*/)
664{
665 tree fname = parse_strconst_pragma (name: "interface", opt: 1);
666 struct c_fileinfo *finfo;
667 const char *filename;
668
669 if (fname == error_mark_node)
670 return;
671 else if (fname == 0)
672 filename = lbasename (LOCATION_FILE (input_location));
673 else
674 filename = TREE_STRING_POINTER (fname);
675
676 finfo = get_fileinfo (LOCATION_FILE (input_location));
677
678 if (impl_file_chain == 0)
679 {
680 /* If this is zero at this point, then we are
681 auto-implementing. */
682 if (main_input_filename == 0)
683 main_input_filename = LOCATION_FILE (input_location);
684 }
685
686 finfo->interface_only = interface_strcmp (s: filename);
687 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see
688 a definition in another file. */
689 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only)
690 finfo->interface_unknown = 0;
691}
692
693/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME.
694 We used to only allow this at toplevel, but that restriction was buggy
695 in older compilers and it seems reasonable to allow it in the headers
696 themselves, too. It only needs to precede the matching #p interface.
697
698 We don't touch finfo->interface_only or finfo->interface_unknown;
699 the user must specify a matching #p interface for this to have
700 any effect. */
701
702static void
703handle_pragma_implementation (cpp_reader* /*dfile*/)
704{
705 tree fname = parse_strconst_pragma (name: "implementation", opt: 1);
706 const char *filename;
707 struct impl_files *ifiles = impl_file_chain;
708
709 if (fname == error_mark_node)
710 return;
711
712 if (fname == 0)
713 {
714 if (main_input_filename)
715 filename = main_input_filename;
716 else
717 filename = LOCATION_FILE (input_location);
718 filename = lbasename (filename);
719 }
720 else
721 {
722 filename = TREE_STRING_POINTER (fname);
723 if (cpp_included_before (parse_in, filename, input_location))
724 warning (0, "%<#pragma implementation%> for %qs appears after "
725 "file is included", filename);
726 }
727
728 for (; ifiles; ifiles = ifiles->next)
729 {
730 if (! filename_cmp (s1: ifiles->filename, s2: filename))
731 break;
732 }
733 if (ifiles == 0)
734 {
735 ifiles = XNEW (struct impl_files);
736 ifiles->filename = xstrdup (filename);
737 ifiles->next = impl_file_chain;
738 impl_file_chain = ifiles;
739 }
740}
741
742/* Issue an error message indicating that the lookup of NAME (an
743 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */
744
745tree
746unqualified_name_lookup_error (tree name, location_t loc)
747{
748 if (loc == UNKNOWN_LOCATION)
749 loc = cp_expr_loc_or_input_loc (t: name);
750
751 if (IDENTIFIER_ANY_OP_P (name))
752 error_at (loc, "%qD not defined", name);
753 else
754 {
755 if (!objc_diagnose_private_ivar (name))
756 {
757 auto_diagnostic_group d;
758 name_hint hint = suggest_alternatives_for (loc, name, true);
759 if (const char *suggestion = hint.suggestion ())
760 {
761 gcc_rich_location richloc (loc);
762 richloc.add_fixit_replace (new_content: suggestion);
763 error_at (&richloc,
764 "%qD was not declared in this scope; did you mean %qs?",
765 name, suggestion);
766 }
767 else
768 error_at (loc, "%qD was not declared in this scope", name);
769 }
770 /* Prevent repeated error messages by creating a VAR_DECL with
771 this NAME in the innermost block scope. */
772 if (local_bindings_p ())
773 {
774 tree decl = build_decl (loc, VAR_DECL, name, error_mark_node);
775 TREE_USED (decl) = true;
776 pushdecl (decl);
777 }
778 }
779
780 return error_mark_node;
781}
782
783/* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id
784 NAME, encapsulated with its location in a CP_EXPR, used as a function.
785 Returns an appropriate expression for NAME. */
786
787tree
788unqualified_fn_lookup_error (cp_expr name_expr)
789{
790 tree name = name_expr.get_value ();
791 location_t loc = name_expr.get_location ();
792 if (loc == UNKNOWN_LOCATION)
793 loc = input_location;
794
795 if (TREE_CODE (name) == TEMPLATE_ID_EXPR)
796 name = TREE_OPERAND (name, 0);
797
798 if (processing_template_decl)
799 {
800 /* In a template, it is invalid to write "f()" or "f(3)" if no
801 declaration of "f" is available. Historically, G++ and most
802 other compilers accepted that usage since they deferred all name
803 lookup until instantiation time rather than doing unqualified
804 name lookup at template definition time; explain to the user what
805 is going wrong.
806
807 Note that we have the exact wording of the following message in
808 the manual (trouble.texi, node "Name lookup"), so they need to
809 be kept in synch. */
810 permerror (loc, "there are no arguments to %qD that depend on a template "
811 "parameter, so a declaration of %qD must be available",
812 name, name);
813
814 if (!flag_permissive)
815 {
816 static bool hint;
817 if (!hint)
818 {
819 inform (loc, "(if you use %<-fpermissive%>, G++ will accept your "
820 "code, but allowing the use of an undeclared name is "
821 "deprecated)");
822 hint = true;
823 }
824 }
825 return name;
826 }
827
828 return unqualified_name_lookup_error (name, loc);
829}
830
831
832/* Hasher for the conversion operator name hash table. */
833struct conv_type_hasher : ggc_ptr_hash<tree_node>
834{
835 /* Hash NODE, an identifier node in the table. TYPE_UID is
836 suitable, as we're not concerned about matching canonicalness
837 here. */
838 static hashval_t hash (tree node)
839 {
840 return (hashval_t) TYPE_UID (TREE_TYPE (node));
841 }
842
843 /* Compare NODE, an identifier node in the table, against TYPE, an
844 incoming TYPE being looked up. */
845 static bool equal (tree node, tree type)
846 {
847 return TREE_TYPE (node) == type;
848 }
849};
850
851/* This hash table maps TYPEs to the IDENTIFIER for a conversion
852 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the
853 TYPE. */
854
855static GTY (()) hash_table<conv_type_hasher> *conv_type_names;
856
857/* Return an identifier for a conversion operator to TYPE. We can get
858 from the returned identifier to the type. We store TYPE, which is
859 not necessarily the canonical type, which allows us to report the
860 form the user used in error messages. All these identifiers are
861 not in the identifier hash table, and have the same string name.
862 These IDENTIFIERS are not in the identifier hash table, and all
863 have the same IDENTIFIER_STRING. */
864
865tree
866make_conv_op_name (tree type)
867{
868 if (type == error_mark_node)
869 return error_mark_node;
870
871 if (conv_type_names == NULL)
872 conv_type_names = hash_table<conv_type_hasher>::create_ggc (n: 31);
873
874 tree *slot = conv_type_names->find_slot_with_hash
875 (comparable: type, hash: (hashval_t) TYPE_UID (type), insert: INSERT);
876 tree identifier = *slot;
877 if (!identifier)
878 {
879 /* Create a raw IDENTIFIER outside of the identifier hash
880 table. */
881 identifier = copy_node (conv_op_identifier);
882
883 /* Just in case something managed to bind. */
884 IDENTIFIER_BINDING (identifier) = NULL;
885
886 /* Hang TYPE off the identifier so it can be found easily later
887 when performing conversions. */
888 TREE_TYPE (identifier) = type;
889
890 *slot = identifier;
891 }
892
893 return identifier;
894}
895
896/* Wrapper around build_lang_decl_loc(). Should gradually move to
897 build_lang_decl_loc() and then rename build_lang_decl_loc() back to
898 build_lang_decl(). */
899
900tree
901build_lang_decl (enum tree_code code, tree name, tree type)
902{
903 return build_lang_decl_loc (input_location, code, name, type);
904}
905
906/* Build a decl from CODE, NAME, TYPE declared at LOC, and then add
907 DECL_LANG_SPECIFIC info to the result. */
908
909tree
910build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type)
911{
912 tree t;
913
914 t = build_decl (loc, code, name, type);
915 retrofit_lang_decl (t);
916
917 return t;
918}
919
920/* Maybe add a raw lang_decl to T, a decl. Return true if it needed
921 one. */
922
923bool
924maybe_add_lang_decl_raw (tree t, bool decomp_p)
925{
926 size_t size;
927 lang_decl_selector sel;
928
929 if (decomp_p)
930 sel = lds_decomp, size = sizeof (struct lang_decl_decomp);
931 else if (TREE_CODE (t) == FUNCTION_DECL)
932 sel = lds_fn, size = sizeof (struct lang_decl_fn);
933 else if (TREE_CODE (t) == NAMESPACE_DECL)
934 sel = lds_ns, size = sizeof (struct lang_decl_ns);
935 else if (TREE_CODE (t) == PARM_DECL)
936 sel = lds_parm, size = sizeof (struct lang_decl_parm);
937 else if (LANG_DECL_HAS_MIN (t))
938 sel = lds_min, size = sizeof (struct lang_decl_min);
939 else
940 return false;
941
942 struct lang_decl *ld
943 = (struct lang_decl *) ggc_internal_cleared_alloc (s: size);
944
945 ld->u.base.selector = sel;
946 DECL_LANG_SPECIFIC (t) = ld;
947
948 if (sel == lds_ns)
949 /* Who'd create a namespace, only to put nothing in it? */
950 ld->u.ns.bindings = hash_table<named_decl_hash>::create_ggc (n: 499);
951
952 if (GATHER_STATISTICS)
953 {
954 tree_node_counts[(int)lang_decl] += 1;
955 tree_node_sizes[(int)lang_decl] += size;
956 }
957 return true;
958}
959
960/* T has just had a decl_lang_specific added. Initialize its
961 linkage. */
962
963static void
964set_decl_linkage (tree t)
965{
966 if (current_lang_name == lang_name_cplusplus
967 || decl_linkage (t) == lk_none)
968 SET_DECL_LANGUAGE (t, lang_cplusplus);
969 else if (current_lang_name == lang_name_c)
970 SET_DECL_LANGUAGE (t, lang_c);
971 else
972 gcc_unreachable ();
973}
974
975/* T is a VAR_DECL node that needs to be a decomposition of BASE. */
976
977void
978fit_decomposition_lang_decl (tree t, tree base)
979{
980 if (struct lang_decl *orig_ld = DECL_LANG_SPECIFIC (t))
981 {
982 if (orig_ld->u.base.selector == lds_min)
983 {
984 maybe_add_lang_decl_raw (t, decomp_p: true);
985 memcpy (DECL_LANG_SPECIFIC (t), src: orig_ld,
986 n: sizeof (struct lang_decl_min));
987 /* Reset selector, which will have been bashed by the
988 memcpy. */
989 DECL_LANG_SPECIFIC (t)->u.base.selector = lds_decomp;
990 }
991 else
992 gcc_checking_assert (orig_ld->u.base.selector == lds_decomp);
993 }
994 else
995 {
996 maybe_add_lang_decl_raw (t, decomp_p: true);
997 set_decl_linkage (t);
998 }
999
1000 DECL_DECOMP_BASE (t) = base;
1001}
1002
1003/* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally
1004 every C++ decl needs one, but C builtins etc do not. */
1005
1006void
1007retrofit_lang_decl (tree t)
1008{
1009 if (DECL_LANG_SPECIFIC (t))
1010 return;
1011
1012 if (maybe_add_lang_decl_raw (t, decomp_p: false))
1013 set_decl_linkage (t);
1014}
1015
1016void
1017cxx_dup_lang_specific_decl (tree node)
1018{
1019 int size;
1020
1021 if (! DECL_LANG_SPECIFIC (node))
1022 return;
1023
1024 switch (DECL_LANG_SPECIFIC (node)->u.base.selector)
1025 {
1026 case lds_min:
1027 size = sizeof (struct lang_decl_min);
1028 break;
1029 case lds_fn:
1030 size = sizeof (struct lang_decl_fn);
1031 break;
1032 case lds_ns:
1033 size = sizeof (struct lang_decl_ns);
1034 break;
1035 case lds_parm:
1036 size = sizeof (struct lang_decl_parm);
1037 break;
1038 case lds_decomp:
1039 size = sizeof (struct lang_decl_decomp);
1040 break;
1041 default:
1042 gcc_unreachable ();
1043 }
1044
1045 struct lang_decl *ld = (struct lang_decl *) ggc_internal_alloc (s: size);
1046 memcpy (dest: ld, DECL_LANG_SPECIFIC (node), n: size);
1047 DECL_LANG_SPECIFIC (node) = ld;
1048
1049 /* Directly clear some flags that do not apply to the copy
1050 (module_purview_p still does). */
1051 ld->u.base.module_entity_p = false;
1052 ld->u.base.module_import_p = false;
1053 ld->u.base.module_keyed_decls_p = false;
1054
1055 if (GATHER_STATISTICS)
1056 {
1057 tree_node_counts[(int)lang_decl] += 1;
1058 tree_node_sizes[(int)lang_decl] += size;
1059 }
1060}
1061
1062/* Copy DECL, including any language-specific parts. */
1063
1064tree
1065copy_decl (tree decl MEM_STAT_DECL)
1066{
1067 tree copy;
1068
1069 copy = copy_node (decl PASS_MEM_STAT);
1070 cxx_dup_lang_specific_decl (node: copy);
1071 return copy;
1072}
1073
1074/* Replace the shared language-specific parts of NODE with a new copy. */
1075
1076static void
1077copy_lang_type (tree node)
1078{
1079 if (! TYPE_LANG_SPECIFIC (node))
1080 return;
1081
1082 auto *lt = (struct lang_type *) ggc_internal_alloc (s: sizeof (struct lang_type));
1083
1084 memcpy (dest: lt, TYPE_LANG_SPECIFIC (node), n: (sizeof (struct lang_type)));
1085 TYPE_LANG_SPECIFIC (node) = lt;
1086
1087 if (GATHER_STATISTICS)
1088 {
1089 tree_node_counts[(int)lang_type] += 1;
1090 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1091 }
1092}
1093
1094/* Copy TYPE, including any language-specific parts. */
1095
1096tree
1097copy_type (tree type MEM_STAT_DECL)
1098{
1099 tree copy;
1100
1101 copy = copy_node (type PASS_MEM_STAT);
1102 copy_lang_type (node: copy);
1103 return copy;
1104}
1105
1106/* Add a raw lang_type to T, a type, should it need one. */
1107
1108bool
1109maybe_add_lang_type_raw (tree t)
1110{
1111 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t)))
1112 return false;
1113
1114 auto *lt = (struct lang_type *) (ggc_internal_cleared_alloc
1115 (s: sizeof (struct lang_type)));
1116 TYPE_LANG_SPECIFIC (t) = lt;
1117
1118 if (GATHER_STATISTICS)
1119 {
1120 tree_node_counts[(int)lang_type] += 1;
1121 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type);
1122 }
1123
1124 return true;
1125}
1126
1127tree
1128cxx_make_type (enum tree_code code MEM_STAT_DECL)
1129{
1130 tree t = make_node (code PASS_MEM_STAT);
1131
1132 if (maybe_add_lang_type_raw (t))
1133 {
1134 /* Set up some flags that give proper default behavior. */
1135 struct c_fileinfo *finfo =
1136 get_fileinfo (LOCATION_FILE (input_location));
1137 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown);
1138 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only;
1139 }
1140
1141 if (code == RECORD_TYPE || code == UNION_TYPE)
1142 TYPE_CXX_ODR_P (t) = 1;
1143
1144 return t;
1145}
1146
1147/* A wrapper without the memory stats for LANG_HOOKS_MAKE_TYPE. */
1148
1149tree
1150cxx_make_type_hook (enum tree_code code)
1151{
1152 return cxx_make_type (code);
1153}
1154
1155tree
1156make_class_type (enum tree_code code MEM_STAT_DECL)
1157{
1158 tree t = cxx_make_type (code PASS_MEM_STAT);
1159 SET_CLASS_TYPE_P (t, 1);
1160 return t;
1161}
1162
1163/* Returns true if we are currently in the main source file, or in a
1164 template instantiation started from the main source file. */
1165
1166bool
1167in_main_input_context (void)
1168{
1169 struct tinst_level *tl = outermost_tinst_level();
1170
1171 if (tl)
1172 return filename_cmp (main_input_filename,
1173 LOCATION_FILE (tl->locus)) == 0;
1174 else
1175 return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0;
1176}
1177
1178#include "gt-cp-lex.h"
1179

source code of gcc/cp/lex.cc