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 | |
5 | This file is part of GCC. |
6 | |
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) |
10 | any later version. |
11 | |
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. |
16 | |
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/>. */ |
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 | |
37 | static int interface_strcmp (const char *); |
38 | static void init_cp_traits (void); |
39 | static void init_cp_pragma (void); |
40 | |
41 | static tree parse_strconst_pragma (const char *, int); |
42 | static void handle_pragma_vtable (cpp_reader *); |
43 | static void handle_pragma_unit (cpp_reader *); |
44 | static void handle_pragma_interface (cpp_reader *); |
45 | static void handle_pragma_implementation (cpp_reader *); |
46 | |
47 | static void init_operators (void); |
48 | static 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 | |
72 | struct impl_files |
73 | { |
74 | const char *filename; |
75 | struct impl_files *next; |
76 | }; |
77 | |
78 | static struct impl_files *impl_file_chain; |
79 | |
80 | void |
81 | cxx_finish (void) |
82 | { |
83 | c_common_finish (); |
84 | } |
85 | |
86 | ovl_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 | }; |
98 | unsigned char ovl_op_mapping[MAX_TREE_CODES]; |
99 | unsigned char ovl_op_alternate[OVL_OP_MAX]; |
100 | |
101 | /* The trait table, declared in cp-tree.h. */ |
102 | const 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. */ |
111 | static_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 | |
116 | const char * |
117 | get_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 | |
135 | void |
136 | set_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 | |
149 | static tree |
150 | set_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 | |
167 | static void |
168 | init_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 | |
236 | void |
237 | init_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. */ |
301 | static void |
302 | init_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 | |
319 | static void |
320 | init_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 | |
332 | bool 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. */ |
338 | bool |
339 | cxx_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 | |
387 | static int |
388 | interface_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 | |
427 | struct 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 | : |
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 | |
577 | uintptr_t |
578 | module_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 | |
592 | uintptr_t |
593 | module_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 | |
600 | uintptr_t |
601 | module_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. */ |
627 | static tree |
628 | parse_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 | |
648 | static void |
649 | handle_pragma_vtable (cpp_reader* /*dfile*/) |
650 | { |
651 | parse_strconst_pragma (name: "vtable" , opt: 0); |
652 | sorry ("%<#pragma vtable%> no longer supported" ); |
653 | } |
654 | |
655 | static void |
656 | handle_pragma_unit (cpp_reader* /*dfile*/) |
657 | { |
658 | /* Validate syntax, but don't do anything. */ |
659 | parse_strconst_pragma (name: "unit" , opt: 0); |
660 | } |
661 | |
662 | static void |
663 | handle_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 | |
702 | static void |
703 | handle_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 | |
745 | tree |
746 | unqualified_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 | |
787 | tree |
788 | unqualified_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. */ |
833 | struct 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 | |
855 | static 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 | |
865 | tree |
866 | make_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 | |
900 | tree |
901 | build_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 | |
909 | tree |
910 | build_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 | |
923 | bool |
924 | maybe_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 | |
963 | static void |
964 | set_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 | |
977 | void |
978 | fit_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 | |
1006 | void |
1007 | retrofit_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 | |
1016 | void |
1017 | cxx_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 | |
1064 | tree |
1065 | copy_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 | |
1076 | static void |
1077 | copy_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 | |
1096 | tree |
1097 | copy_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 | |
1108 | bool |
1109 | maybe_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 | |
1127 | tree |
1128 | cxx_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 | |
1149 | tree |
1150 | cxx_make_type_hook (enum tree_code code) |
1151 | { |
1152 | return cxx_make_type (code); |
1153 | } |
1154 | |
1155 | tree |
1156 | make_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 | |
1166 | bool |
1167 | in_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 | |