1 /* Separate lexical analyzer for GNU C++. 2 Copyright (C) 1987-2018 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 #include "system.h" 26 #include "coretypes.h" 27 #include "cp-tree.h" 28 #include "stringpool.h" 29 #include "c-family/c-pragma.h" 30 #include "c-family/c-objc.h" 31 32 static int interface_strcmp (const char *); 33 static void init_cp_pragma (void); 34 35 static tree parse_strconst_pragma (const char *, int); 36 static void handle_pragma_vtable (cpp_reader *); 37 static void handle_pragma_unit (cpp_reader *); 38 static void handle_pragma_interface (cpp_reader *); 39 static void handle_pragma_implementation (cpp_reader *); 40 41 static void init_operators (void); 42 static void copy_lang_type (tree); 43 44 /* A constraint that can be tested at compile time. */ 45 #define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1] 46 47 /* Functions and data structures for #pragma interface. 48 49 `#pragma implementation' means that the main file being compiled 50 is considered to implement (provide) the classes that appear in 51 its main body. I.e., if this is file "foo.cc", and class `bar' 52 is defined in "foo.cc", then we say that "foo.cc implements bar". 53 54 All main input files "implement" themselves automagically. 55 56 `#pragma interface' means that unless this file (of the form "foo.h" 57 is not presently being included by file "foo.cc", the 58 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none 59 of the vtables nor any of the inline functions defined in foo.h 60 will ever be output. 61 62 There are cases when we want to link files such as "defs.h" and 63 "main.cc". In this case, we give "defs.h" a `#pragma interface', 64 and "main.cc" has `#pragma implementation "defs.h"'. */ 65 66 struct impl_files 67 { 68 const char *filename; 69 struct impl_files *next; 70 }; 71 72 static struct impl_files *impl_file_chain; 73 74 void 75 cxx_finish (void) 76 { 77 c_common_finish (); 78 } 79 80 ovl_op_info_t ovl_op_info[2][OVL_OP_MAX] = 81 { 82 { 83 {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0}, 84 {NULL_TREE, NULL, NULL, NOP_EXPR, OVL_OP_NOP_EXPR, 0}, 85 #define DEF_OPERATOR(NAME, CODE, MANGLING, FLAGS) \ 86 {NULL_TREE, NAME, MANGLING, CODE, OVL_OP_##CODE, FLAGS}, 87 #define OPERATOR_TRANSITION }, { \ 88 {NULL_TREE, NULL, NULL, ERROR_MARK, OVL_OP_ERROR_MARK, 0}, 89 #include "operators.def" 90 } 91 }; 92 unsigned char ovl_op_mapping[MAX_TREE_CODES]; 93 unsigned char ovl_op_alternate[OVL_OP_MAX]; 94 95 /* Get the name of the kind of identifier T. */ 96 97 const char * 98 get_identifier_kind_name (tree id) 99 { 100 /* Keep in sync with cp_id_kind enumeration. */ 101 static const char *const names[cik_max] = { 102 "normal", "keyword", "constructor", "destructor", 103 "simple-op", "assign-op", "conv-op", "<reserved>udlit-op" 104 }; 105 106 unsigned kind = 0; 107 kind |= IDENTIFIER_KIND_BIT_2 (id) << 2; 108 kind |= IDENTIFIER_KIND_BIT_1 (id) << 1; 109 kind |= IDENTIFIER_KIND_BIT_0 (id) << 0; 110 111 return names[kind]; 112 } 113 114 /* Set the identifier kind, which we expect to currently be zero. */ 115 116 void 117 set_identifier_kind (tree id, cp_identifier_kind kind) 118 { 119 gcc_checking_assert (!IDENTIFIER_KIND_BIT_2 (id) 120 & !IDENTIFIER_KIND_BIT_1 (id) 121 & !IDENTIFIER_KIND_BIT_0 (id)); 122 IDENTIFIER_KIND_BIT_2 (id) |= (kind >> 2) & 1; 123 IDENTIFIER_KIND_BIT_1 (id) |= (kind >> 1) & 1; 124 IDENTIFIER_KIND_BIT_0 (id) |= (kind >> 0) & 1; 125 } 126 127 /* Create and tag the internal operator name for the overloaded 128 operator PTR describes. */ 129 130 static tree 131 set_operator_ident (ovl_op_info_t *ptr) 132 { 133 char buffer[32]; 134 size_t len = snprintf (buffer, sizeof (buffer), "operator%s%s", 135 &" "[ptr->name[0] && ptr->name[0] != '_' 136 && !ISALPHA (ptr->name[0])], 137 ptr->name); 138 gcc_checking_assert (len < sizeof (buffer)); 139 140 tree ident = get_identifier_with_length (buffer, len); 141 ptr->identifier = ident; 142 143 return ident; 144 } 145 146 /* Initialize data structures that keep track of operator names. */ 147 148 static void 149 init_operators (void) 150 { 151 /* We rely on both these being zero. */ 152 gcc_checking_assert (!OVL_OP_ERROR_MARK && !ERROR_MARK); 153 154 /* This loop iterates backwards because we need to move the 155 assignment operators down to their correct slots. I.e. morally 156 equivalent to an overlapping memmove where dest > src. Slot 157 zero is for error_mark, so hae no operator. */ 158 for (unsigned ix = OVL_OP_MAX; --ix;) 159 { 160 ovl_op_info_t *op_ptr = &ovl_op_info[false][ix]; 161 162 if (op_ptr->name) 163 { 164 /* Make sure it fits in lang_decl_fn::operator_code. */ 165 gcc_checking_assert (op_ptr->ovl_op_code < (1 << 6)); 166 tree ident = set_operator_ident (op_ptr); 167 if (unsigned index = IDENTIFIER_CP_INDEX (ident)) 168 { 169 ovl_op_info_t *bin_ptr = &ovl_op_info[false][index]; 170 171 /* They should only differ in unary/binary ness. */ 172 gcc_checking_assert ((op_ptr->flags ^ bin_ptr->flags) 173 == OVL_OP_FLAG_AMBIARY); 174 bin_ptr->flags |= op_ptr->flags; 175 ovl_op_alternate[index] = ix; 176 } 177 else 178 { 179 IDENTIFIER_CP_INDEX (ident) = ix; 180 set_identifier_kind (ident, cik_simple_op); 181 } 182 } 183 if (op_ptr->tree_code) 184 { 185 gcc_checking_assert (op_ptr->ovl_op_code == ix 186 && !ovl_op_mapping[op_ptr->tree_code]); 187 ovl_op_mapping[op_ptr->tree_code] = op_ptr->ovl_op_code; 188 } 189 190 ovl_op_info_t *as_ptr = &ovl_op_info[true][ix]; 191 if (as_ptr->name) 192 { 193 /* These will be placed at the start of the array, move to 194 the correct slot and initialize. */ 195 if (as_ptr->ovl_op_code != ix) 196 { 197 ovl_op_info_t *dst_ptr = &ovl_op_info[true][as_ptr->ovl_op_code]; 198 gcc_assert (as_ptr->ovl_op_code > ix && !dst_ptr->tree_code); 199 memcpy (dst_ptr, as_ptr, sizeof (*dst_ptr)); 200 memset (as_ptr, 0, sizeof (*as_ptr)); 201 as_ptr = dst_ptr; 202 } 203 204 tree ident = set_operator_ident (as_ptr); 205 gcc_checking_assert (!IDENTIFIER_CP_INDEX (ident)); 206 IDENTIFIER_CP_INDEX (ident) = as_ptr->ovl_op_code; 207 set_identifier_kind (ident, cik_assign_op); 208 209 gcc_checking_assert (!ovl_op_mapping[as_ptr->tree_code] 210 || (ovl_op_mapping[as_ptr->tree_code] 211 == as_ptr->ovl_op_code)); 212 ovl_op_mapping[as_ptr->tree_code] = as_ptr->ovl_op_code; 213 } 214 } 215 } 216 217 /* Initialize the reserved words. */ 218 219 void 220 init_reswords (void) 221 { 222 unsigned int i; 223 tree id; 224 int mask = 0; 225 226 if (cxx_dialect < cxx11) 227 mask |= D_CXX11; 228 if (!flag_concepts) 229 mask |= D_CXX_CONCEPTS; 230 if (!flag_tm) 231 mask |= D_TRANSMEM; 232 if (flag_no_asm) 233 mask |= D_ASM | D_EXT; 234 if (flag_no_gnu_keywords) 235 mask |= D_EXT; 236 237 /* The Objective-C keywords are all context-dependent. */ 238 mask |= D_OBJC; 239 240 ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX); 241 for (i = 0; i < num_c_common_reswords; i++) 242 { 243 if (c_common_reswords[i].disable & D_CONLY) 244 continue; 245 id = get_identifier (c_common_reswords[i].word); 246 C_SET_RID_CODE (id, c_common_reswords[i].rid); 247 ridpointers [(int) c_common_reswords[i].rid] = id; 248 if (! (c_common_reswords[i].disable & mask)) 249 set_identifier_kind (id, cik_keyword); 250 } 251 252 for (i = 0; i < NUM_INT_N_ENTS; i++) 253 { 254 char name[50]; 255 sprintf (name, "__int%d", int_n_data[i].bitsize); 256 id = get_identifier (name); 257 C_SET_RID_CODE (id, RID_FIRST_INT_N + i); 258 set_identifier_kind (id, cik_keyword); 259 } 260 } 261 262 static void 263 init_cp_pragma (void) 264 { 265 c_register_pragma (0, "vtable", handle_pragma_vtable); 266 c_register_pragma (0, "unit", handle_pragma_unit); 267 c_register_pragma (0, "interface", handle_pragma_interface); 268 c_register_pragma (0, "implementation", handle_pragma_implementation); 269 c_register_pragma ("GCC", "interface", handle_pragma_interface); 270 c_register_pragma ("GCC", "implementation", handle_pragma_implementation); 271 } 272 273 /* TRUE if a code represents a statement. */ 274 275 bool statement_code_p[MAX_TREE_CODES]; 276 277 /* Initialize the C++ front end. This function is very sensitive to 278 the exact order that things are done here. It would be nice if the 279 initialization done by this routine were moved to its subroutines, 280 and the ordering dependencies clarified and reduced. */ 281 bool 282 cxx_init (void) 283 { 284 location_t saved_loc; 285 unsigned int i; 286 static const enum tree_code stmt_codes[] = { 287 CTOR_INITIALIZER, TRY_BLOCK, HANDLER, 288 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN, 289 IF_STMT, CLEANUP_STMT, FOR_STMT, 290 RANGE_FOR_STMT, WHILE_STMT, DO_STMT, 291 BREAK_STMT, CONTINUE_STMT, SWITCH_STMT, 292 EXPR_STMT 293 }; 294 295 memset (&statement_code_p, 0, sizeof (statement_code_p)); 296 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++) 297 statement_code_p[stmt_codes[i]] = true; 298 299 saved_loc = input_location; 300 input_location = BUILTINS_LOCATION; 301 302 init_reswords (); 303 init_tree (); 304 init_cp_semantics (); 305 init_operators (); 306 init_method (); 307 308 current_function_decl = NULL; 309 310 class_type_node = ridpointers[(int) RID_CLASS]; 311 312 cxx_init_decl_processing (); 313 314 if (c_common_init () == false) 315 { 316 input_location = saved_loc; 317 return false; 318 } 319 320 init_cp_pragma (); 321 322 init_repo (); 323 324 input_location = saved_loc; 325 return true; 326 } 327 328 /* Return nonzero if S is not considered part of an 329 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ 330 331 static int 332 interface_strcmp (const char* s) 333 { 334 /* Set the interface/implementation bits for this scope. */ 335 struct impl_files *ifiles; 336 const char *s1; 337 338 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) 339 { 340 const char *t1 = ifiles->filename; 341 s1 = s; 342 343 if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0) 344 continue; 345 346 while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0) 347 s1++, t1++; 348 349 /* A match. */ 350 if (*s1 == *t1) 351 return 0; 352 353 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */ 354 if (strchr (s1, '.') || strchr (t1, '.')) 355 continue; 356 357 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.') 358 continue; 359 360 /* A match. */ 361 return 0; 362 } 363 364 /* No matches. */ 365 return 1; 366 } 367 368 369 370 /* Parse a #pragma whose sole argument is a string constant. 371 If OPT is true, the argument is optional. */ 372 static tree 373 parse_strconst_pragma (const char* name, int opt) 374 { 375 tree result, x; 376 enum cpp_ttype t; 377 378 t = pragma_lex (&result); 379 if (t == CPP_STRING) 380 { 381 if (pragma_lex (&x) != CPP_EOF) 382 warning (0, "junk at end of #pragma %s", name); 383 return result; 384 } 385 386 if (t == CPP_EOF && opt) 387 return NULL_TREE; 388 389 error ("invalid #pragma %s", name); 390 return error_mark_node; 391 } 392 393 static void 394 handle_pragma_vtable (cpp_reader* /*dfile*/) 395 { 396 parse_strconst_pragma ("vtable", 0); 397 sorry ("#pragma vtable no longer supported"); 398 } 399 400 static void 401 handle_pragma_unit (cpp_reader* /*dfile*/) 402 { 403 /* Validate syntax, but don't do anything. */ 404 parse_strconst_pragma ("unit", 0); 405 } 406 407 static void 408 handle_pragma_interface (cpp_reader* /*dfile*/) 409 { 410 tree fname = parse_strconst_pragma ("interface", 1); 411 struct c_fileinfo *finfo; 412 const char *filename; 413 414 if (fname == error_mark_node) 415 return; 416 else if (fname == 0) 417 filename = lbasename (LOCATION_FILE (input_location)); 418 else 419 filename = TREE_STRING_POINTER (fname); 420 421 finfo = get_fileinfo (LOCATION_FILE (input_location)); 422 423 if (impl_file_chain == 0) 424 { 425 /* If this is zero at this point, then we are 426 auto-implementing. */ 427 if (main_input_filename == 0) 428 main_input_filename = LOCATION_FILE (input_location); 429 } 430 431 finfo->interface_only = interface_strcmp (filename); 432 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see 433 a definition in another file. */ 434 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only) 435 finfo->interface_unknown = 0; 436 } 437 438 /* Note that we have seen a #pragma implementation for the key MAIN_FILENAME. 439 We used to only allow this at toplevel, but that restriction was buggy 440 in older compilers and it seems reasonable to allow it in the headers 441 themselves, too. It only needs to precede the matching #p interface. 442 443 We don't touch finfo->interface_only or finfo->interface_unknown; 444 the user must specify a matching #p interface for this to have 445 any effect. */ 446 447 static void 448 handle_pragma_implementation (cpp_reader* /*dfile*/) 449 { 450 tree fname = parse_strconst_pragma ("implementation", 1); 451 const char *filename; 452 struct impl_files *ifiles = impl_file_chain; 453 454 if (fname == error_mark_node) 455 return; 456 457 if (fname == 0) 458 { 459 if (main_input_filename) 460 filename = main_input_filename; 461 else 462 filename = LOCATION_FILE (input_location); 463 filename = lbasename (filename); 464 } 465 else 466 { 467 filename = TREE_STRING_POINTER (fname); 468 if (cpp_included_before (parse_in, filename, input_location)) 469 warning (0, "#pragma implementation for %qs appears after " 470 "file is included", filename); 471 } 472 473 for (; ifiles; ifiles = ifiles->next) 474 { 475 if (! filename_cmp (ifiles->filename, filename)) 476 break; 477 } 478 if (ifiles == 0) 479 { 480 ifiles = XNEW (struct impl_files); 481 ifiles->filename = xstrdup (filename); 482 ifiles->next = impl_file_chain; 483 impl_file_chain = ifiles; 484 } 485 } 486 487 /* Issue an error message indicating that the lookup of NAME (an 488 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ 489 490 tree 491 unqualified_name_lookup_error (tree name, location_t loc) 492 { 493 if (loc == UNKNOWN_LOCATION) 494 loc = EXPR_LOC_OR_LOC (name, input_location); 495 496 if (IDENTIFIER_ANY_OP_P (name)) 497 error_at (loc, "%qD not defined", name); 498 else 499 { 500 if (!objc_diagnose_private_ivar (name)) 501 { 502 error_at (loc, "%qD was not declared in this scope", name); 503 suggest_alternatives_for (loc, name, true); 504 } 505 /* Prevent repeated error messages by creating a VAR_DECL with 506 this NAME in the innermost block scope. */ 507 if (local_bindings_p ()) 508 { 509 tree decl = build_decl (loc, VAR_DECL, name, error_mark_node); 510 TREE_USED (decl) = true; 511 pushdecl (decl); 512 } 513 } 514 515 return error_mark_node; 516 } 517 518 /* Like unqualified_name_lookup_error, but NAME_EXPR is an unqualified-id 519 NAME, encapsulated with its location in a CP_EXPR, used as a function. 520 Returns an appropriate expression for NAME. */ 521 522 tree 523 unqualified_fn_lookup_error (cp_expr name_expr) 524 { 525 tree name = name_expr.get_value (); 526 location_t loc = name_expr.get_location (); 527 if (loc == UNKNOWN_LOCATION) 528 loc = input_location; 529 530 if (processing_template_decl) 531 { 532 /* In a template, it is invalid to write "f()" or "f(3)" if no 533 declaration of "f" is available. Historically, G++ and most 534 other compilers accepted that usage since they deferred all name 535 lookup until instantiation time rather than doing unqualified 536 name lookup at template definition time; explain to the user what 537 is going wrong. 538 539 Note that we have the exact wording of the following message in 540 the manual (trouble.texi, node "Name lookup"), so they need to 541 be kept in synch. */ 542 permerror (loc, "there are no arguments to %qD that depend on a template " 543 "parameter, so a declaration of %qD must be available", 544 name, name); 545 546 if (!flag_permissive) 547 { 548 static bool hint; 549 if (!hint) 550 { 551 inform (loc, "(if you use %<-fpermissive%>, G++ will accept your " 552 "code, but allowing the use of an undeclared name is " 553 "deprecated)"); 554 hint = true; 555 } 556 } 557 return name; 558 } 559 560 return unqualified_name_lookup_error (name, loc); 561 } 562 563 564 /* Hasher for the conversion operator name hash table. */ 565 struct conv_type_hasher : ggc_ptr_hash<tree_node> 566 { 567 /* Hash NODE, an identifier node in the table. TYPE_UID is 568 suitable, as we're not concerned about matching canonicalness 569 here. */ 570 static hashval_t hash (tree node) 571 { 572 return (hashval_t) TYPE_UID (TREE_TYPE (node)); 573 } 574 575 /* Compare NODE, an identifier node in the table, against TYPE, an 576 incoming TYPE being looked up. */ 577 static bool equal (tree node, tree type) 578 { 579 return TREE_TYPE (node) == type; 580 } 581 }; 582 583 /* This hash table maps TYPEs to the IDENTIFIER for a conversion 584 operator to TYPE. The nodes are IDENTIFIERs whose TREE_TYPE is the 585 TYPE. */ 586 587 static GTY (()) hash_table<conv_type_hasher> *conv_type_names; 588 589 /* Return an identifier for a conversion operator to TYPE. We can get 590 from the returned identifier to the type. We store TYPE, which is 591 not necessarily the canonical type, which allows us to report the 592 form the user used in error messages. All these identifiers are 593 not in the identifier hash table, and have the same string name. 594 These IDENTIFIERS are not in the identifier hash table, and all 595 have the same IDENTIFIER_STRING. */ 596 597 tree 598 make_conv_op_name (tree type) 599 { 600 if (type == error_mark_node) 601 return error_mark_node; 602 603 if (conv_type_names == NULL) 604 conv_type_names = hash_table<conv_type_hasher>::create_ggc (31); 605 606 tree *slot = conv_type_names->find_slot_with_hash 607 (type, (hashval_t) TYPE_UID (type), INSERT); 608 tree identifier = *slot; 609 if (!identifier) 610 { 611 /* Create a raw IDENTIFIER outside of the identifier hash 612 table. */ 613 identifier = copy_node (conv_op_identifier); 614 615 /* Just in case something managed to bind. */ 616 IDENTIFIER_BINDING (identifier) = NULL; 617 618 /* Hang TYPE off the identifier so it can be found easily later 619 when performing conversions. */ 620 TREE_TYPE (identifier) = type; 621 622 *slot = identifier; 623 } 624 625 return identifier; 626 } 627 628 /* Wrapper around build_lang_decl_loc(). Should gradually move to 629 build_lang_decl_loc() and then rename build_lang_decl_loc() back to 630 build_lang_decl(). */ 631 632 tree 633 build_lang_decl (enum tree_code code, tree name, tree type) 634 { 635 return build_lang_decl_loc (input_location, code, name, type); 636 } 637 638 /* Build a decl from CODE, NAME, TYPE declared at LOC, and then add 639 DECL_LANG_SPECIFIC info to the result. */ 640 641 tree 642 build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type) 643 { 644 tree t; 645 646 t = build_decl (loc, code, name, type); 647 retrofit_lang_decl (t); 648 649 return t; 650 } 651 652 /* Maybe add a raw lang_decl to T, a decl. Return true if it needed 653 one. */ 654 655 static bool 656 maybe_add_lang_decl_raw (tree t, bool decomp_p) 657 { 658 size_t size; 659 lang_decl_selector sel; 660 661 if (decomp_p) 662 sel = lds_decomp, size = sizeof (struct lang_decl_decomp); 663 else if (TREE_CODE (t) == FUNCTION_DECL) 664 sel = lds_fn, size = sizeof (struct lang_decl_fn); 665 else if (TREE_CODE (t) == NAMESPACE_DECL) 666 sel = lds_ns, size = sizeof (struct lang_decl_ns); 667 else if (TREE_CODE (t) == PARM_DECL) 668 sel = lds_parm, size = sizeof (struct lang_decl_parm); 669 else if (LANG_DECL_HAS_MIN (t)) 670 sel = lds_min, size = sizeof (struct lang_decl_min); 671 else 672 return false; 673 674 struct lang_decl *ld 675 = (struct lang_decl *) ggc_internal_cleared_alloc (size); 676 677 ld->u.base.selector = sel; 678 DECL_LANG_SPECIFIC (t) = ld; 679 680 if (sel == lds_ns) 681 /* Who'd create a namespace, only to put nothing in it? */ 682 ld->u.ns.bindings = hash_table<named_decl_hash>::create_ggc (499); 683 684 if (GATHER_STATISTICS) 685 { 686 tree_node_counts[(int)lang_decl] += 1; 687 tree_node_sizes[(int)lang_decl] += size; 688 } 689 return true; 690 } 691 692 /* T has just had a decl_lang_specific added. Initialize its 693 linkage. */ 694 695 static void 696 set_decl_linkage (tree t) 697 { 698 if (current_lang_name == lang_name_cplusplus 699 || decl_linkage (t) == lk_none) 700 SET_DECL_LANGUAGE (t, lang_cplusplus); 701 else if (current_lang_name == lang_name_c) 702 SET_DECL_LANGUAGE (t, lang_c); 703 else 704 gcc_unreachable (); 705 } 706 707 /* T is a VAR_DECL node that needs to be a decomposition of BASE. */ 708 709 void 710 fit_decomposition_lang_decl (tree t, tree base) 711 { 712 if (struct lang_decl *orig_ld = DECL_LANG_SPECIFIC (t)) 713 { 714 if (orig_ld->u.base.selector == lds_min) 715 { 716 maybe_add_lang_decl_raw (t, true); 717 memcpy (DECL_LANG_SPECIFIC (t), orig_ld, 718 sizeof (struct lang_decl_min)); 719 /* Reset selector, which will have been bashed by the 720 memcpy. */ 721 DECL_LANG_SPECIFIC (t)->u.base.selector = lds_decomp; 722 } 723 else 724 gcc_checking_assert (orig_ld->u.base.selector == lds_decomp); 725 } 726 else 727 { 728 maybe_add_lang_decl_raw (t, true); 729 set_decl_linkage (t); 730 } 731 732 DECL_DECOMP_BASE (t) = base; 733 } 734 735 /* Add DECL_LANG_SPECIFIC info to T, if it needs one. Generally 736 every C++ decl needs one, but C builtins etc do not. */ 737 738 void 739 retrofit_lang_decl (tree t) 740 { 741 if (DECL_LANG_SPECIFIC (t)) 742 return; 743 744 if (maybe_add_lang_decl_raw (t, false)) 745 set_decl_linkage (t); 746 } 747 748 void 749 cxx_dup_lang_specific_decl (tree node) 750 { 751 int size; 752 753 if (! DECL_LANG_SPECIFIC (node)) 754 return; 755 756 switch (DECL_LANG_SPECIFIC (node)->u.base.selector) 757 { 758 case lds_min: 759 size = sizeof (struct lang_decl_min); 760 break; 761 case lds_fn: 762 size = sizeof (struct lang_decl_fn); 763 break; 764 case lds_ns: 765 size = sizeof (struct lang_decl_ns); 766 break; 767 case lds_parm: 768 size = sizeof (struct lang_decl_parm); 769 break; 770 case lds_decomp: 771 size = sizeof (struct lang_decl_decomp); 772 break; 773 default: 774 gcc_unreachable (); 775 } 776 777 struct lang_decl *ld = (struct lang_decl *) ggc_internal_alloc (size); 778 memcpy (ld, DECL_LANG_SPECIFIC (node), size); 779 DECL_LANG_SPECIFIC (node) = ld; 780 781 if (GATHER_STATISTICS) 782 { 783 tree_node_counts[(int)lang_decl] += 1; 784 tree_node_sizes[(int)lang_decl] += size; 785 } 786 } 787 788 /* Copy DECL, including any language-specific parts. */ 789 790 tree 791 copy_decl (tree decl MEM_STAT_DECL) 792 { 793 tree copy; 794 795 copy = copy_node (decl PASS_MEM_STAT); 796 cxx_dup_lang_specific_decl (copy); 797 return copy; 798 } 799 800 /* Replace the shared language-specific parts of NODE with a new copy. */ 801 802 static void 803 copy_lang_type (tree node) 804 { 805 if (! TYPE_LANG_SPECIFIC (node)) 806 return; 807 808 struct lang_type *lt 809 = (struct lang_type *) ggc_internal_alloc (sizeof (struct lang_type)); 810 811 memcpy (lt, TYPE_LANG_SPECIFIC (node), (sizeof (struct lang_type))); 812 TYPE_LANG_SPECIFIC (node) = lt; 813 814 if (GATHER_STATISTICS) 815 { 816 tree_node_counts[(int)lang_type] += 1; 817 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 818 } 819 } 820 821 /* Copy TYPE, including any language-specific parts. */ 822 823 tree 824 copy_type (tree type MEM_STAT_DECL) 825 { 826 tree copy; 827 828 copy = copy_node (type PASS_MEM_STAT); 829 copy_lang_type (copy); 830 return copy; 831 } 832 833 /* Add a raw lang_type to T, a type, should it need one. */ 834 835 static bool 836 maybe_add_lang_type_raw (tree t) 837 { 838 if (!RECORD_OR_UNION_CODE_P (TREE_CODE (t))) 839 return false; 840 841 TYPE_LANG_SPECIFIC (t) 842 = (struct lang_type *) (ggc_internal_cleared_alloc 843 (sizeof (struct lang_type))); 844 845 if (GATHER_STATISTICS) 846 { 847 tree_node_counts[(int)lang_type] += 1; 848 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 849 } 850 851 return true; 852 } 853 854 tree 855 cxx_make_type (enum tree_code code) 856 { 857 tree t = make_node (code); 858 859 if (maybe_add_lang_type_raw (t)) 860 { 861 /* Set up some flags that give proper default behavior. */ 862 struct c_fileinfo *finfo = 863 get_fileinfo (LOCATION_FILE (input_location)); 864 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown); 865 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only; 866 } 867 868 return t; 869 } 870 871 tree 872 make_class_type (enum tree_code code) 873 { 874 tree t = cxx_make_type (code); 875 SET_CLASS_TYPE_P (t, 1); 876 return t; 877 } 878 879 /* Returns true if we are currently in the main source file, or in a 880 template instantiation started from the main source file. */ 881 882 bool 883 in_main_input_context (void) 884 { 885 struct tinst_level *tl = outermost_tinst_level(); 886 887 if (tl) 888 return filename_cmp (main_input_filename, 889 LOCATION_FILE (tl->locus)) == 0; 890 else 891 return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0; 892 } 893 894 #include "gt-cp-lex.h" 895