1 /* Library interface to C++ front end. 2 Copyright (C) 2014-2018 Free Software Foundation, Inc. 3 4 This file is part of GCC. As it interacts with GDB through libcc1, 5 they all become a single program as regards the GNU GPL's requirements. 6 7 GCC is free software; you can redistribute it and/or modify it under 8 the terms of the GNU General Public License as published by the Free 9 Software Foundation; either version 3, or (at your option) any later 10 version. 11 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 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 #include <cc1plugin-config.h> 22 23 #undef PACKAGE_NAME 24 #undef PACKAGE_STRING 25 #undef PACKAGE_TARNAME 26 #undef PACKAGE_VERSION 27 28 #include "../gcc/config.h" 29 30 #undef PACKAGE_NAME 31 #undef PACKAGE_STRING 32 #undef PACKAGE_TARNAME 33 #undef PACKAGE_VERSION 34 35 #include "gcc-plugin.h" 36 #include "system.h" 37 #include "coretypes.h" 38 #include "stringpool.h" 39 40 #include "gcc-interface.h" 41 #include "hash-set.h" 42 #include "machmode.h" 43 #include "vec.h" 44 #include "double-int.h" 45 #include "input.h" 46 #include "alias.h" 47 #include "symtab.h" 48 #include "options.h" 49 #include "wide-int.h" 50 #include "inchash.h" 51 #include "tree.h" 52 #include "fold-const.h" 53 #include "stor-layout.h" 54 #include "cp-tree.h" 55 #include "toplev.h" 56 #include "timevar.h" 57 #include "hash-table.h" 58 #include "tm.h" 59 #include "c-family/c-pragma.h" 60 // #include "c-lang.h" 61 #include "diagnostic.h" 62 #include "langhooks.h" 63 #include "langhooks-def.h" 64 #include "decl.h" 65 #include "function.h" 66 #undef cfun // we want to assign to it, and function.h won't let us 67 68 #include "callbacks.hh" 69 #include "connection.hh" 70 #include "marshall-cp.hh" 71 #include "rpc.hh" 72 73 #ifdef __GNUC__ 74 #pragma GCC visibility push(default) 75 #endif 76 int plugin_is_GPL_compatible; 77 #ifdef __GNUC__ 78 #pragma GCC visibility pop 79 #endif 80 81 82 83 static int ATTRIBUTE_UNUSED 84 check_symbol_mask[GCC_CP_SYMBOL_MASK >= GCC_CP_SYMBOL_END ? 1 : -1]; 85 86 // This is put into the lang hooks when the plugin starts. 87 88 static void 89 plugin_print_error_function (diagnostic_context *context, const char *file, 90 diagnostic_info *diagnostic) 91 { 92 if (current_function_decl != NULL_TREE 93 && DECL_NAME (current_function_decl) != NULL_TREE 94 && strcmp (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), 95 GCC_FE_WRAPPER_FUNCTION) == 0) 96 return; 97 lhd_print_error_function (context, file, diagnostic); 98 } 99 100 101 102 static unsigned long long 103 convert_out (tree t) 104 { 105 return (unsigned long long) (uintptr_t) t; 106 } 107 108 static tree 109 convert_in (unsigned long long v) 110 { 111 return (tree) (uintptr_t) v; 112 } 113 114 115 116 struct decl_addr_value 117 { 118 tree decl; 119 tree address; 120 }; 121 122 struct decl_addr_hasher : free_ptr_hash<decl_addr_value> 123 { 124 static inline hashval_t hash (const decl_addr_value *); 125 static inline bool equal (const decl_addr_value *, const decl_addr_value *); 126 }; 127 128 inline hashval_t 129 decl_addr_hasher::hash (const decl_addr_value *e) 130 { 131 return DECL_UID (e->decl); 132 } 133 134 inline bool 135 decl_addr_hasher::equal (const decl_addr_value *p1, const decl_addr_value *p2) 136 { 137 return p1->decl == p2->decl; 138 } 139 140 141 142 struct string_hasher : nofree_ptr_hash<const char> 143 { 144 static inline hashval_t hash (const char *s) 145 { 146 return htab_hash_string (s); 147 } 148 149 static inline bool equal (const char *p1, const char *p2) 150 { 151 return strcmp (p1, p2) == 0; 152 } 153 }; 154 155 156 157 struct plugin_context : public cc1_plugin::connection 158 { 159 plugin_context (int fd); 160 161 // Map decls to addresses. 162 hash_table<decl_addr_hasher> address_map; 163 164 // A collection of trees that are preserved for the GC. 165 hash_table< nofree_ptr_hash<tree_node> > preserved; 166 167 // File name cache. 168 hash_table<string_hasher> file_names; 169 170 // Perform GC marking. 171 void mark (); 172 173 // Preserve a tree during the plugin's operation. 174 tree preserve (tree t) 175 { 176 tree_node **slot = preserved.find_slot (t, INSERT); 177 *slot = t; 178 return t; 179 } 180 181 source_location get_source_location (const char *filename, 182 unsigned int line_number) 183 { 184 if (filename == NULL) 185 return UNKNOWN_LOCATION; 186 187 filename = intern_filename (filename); 188 linemap_add (line_table, LC_ENTER, false, filename, line_number); 189 source_location loc = linemap_line_start (line_table, line_number, 0); 190 linemap_add (line_table, LC_LEAVE, false, NULL, 0); 191 return loc; 192 } 193 194 private: 195 196 // Add a file name to FILE_NAMES and return the canonical copy. 197 const char *intern_filename (const char *filename) 198 { 199 const char **slot = file_names.find_slot (filename, INSERT); 200 if (*slot == NULL) 201 { 202 /* The file name must live as long as the line map, which 203 effectively means as long as this compilation. So, we copy 204 the string here but never free it. */ 205 *slot = xstrdup (filename); 206 } 207 return *slot; 208 } 209 }; 210 211 static plugin_context *current_context; 212 213 214 215 plugin_context::plugin_context (int fd) 216 : cc1_plugin::connection (fd), 217 address_map (30), 218 preserved (30), 219 file_names (30) 220 { 221 } 222 223 void 224 plugin_context::mark () 225 { 226 for (hash_table<decl_addr_hasher>::iterator it = address_map.begin (); 227 it != address_map.end (); 228 ++it) 229 { 230 ggc_mark ((*it)->decl); 231 ggc_mark ((*it)->address); 232 } 233 234 for (hash_table< nofree_ptr_hash<tree_node> >::iterator 235 it = preserved.begin (); it != preserved.end (); ++it) 236 ggc_mark (&*it); 237 } 238 239 static void 240 plugin_binding_oracle (enum cp_oracle_request kind, tree identifier) 241 { 242 enum gcc_cp_oracle_request request; 243 244 gcc_assert (current_context != NULL); 245 246 switch (kind) 247 { 248 case CP_ORACLE_IDENTIFIER: 249 request = GCC_CP_ORACLE_IDENTIFIER; 250 break; 251 default: 252 abort (); 253 } 254 255 int ignore; 256 cc1_plugin::call (current_context, "binding_oracle", &ignore, 257 request, IDENTIFIER_POINTER (identifier)); 258 } 259 260 static int push_count; 261 262 /* at_function_scope_p () tests cfun, indicating we're actually 263 compiling the function, but we don't even set it when pretending to 264 enter a function scope. We use this distinction to tell these two 265 cases apart: we don't want to define e.g. class names in the user 266 expression function's scope, when they're local to the original 267 function, because they'd get the wrong linkage name. */ 268 269 static bool 270 at_fake_function_scope_p () 271 { 272 return (!cfun || cfun->decl != current_function_decl) 273 && current_scope () == current_function_decl; 274 } 275 276 static void 277 push_fake_function (tree fndecl, scope_kind kind = sk_function_parms) 278 { 279 current_function_decl = fndecl; 280 begin_scope (kind, fndecl); 281 ++function_depth; 282 begin_scope (sk_block, NULL); 283 } 284 285 static void 286 pop_scope () 287 { 288 if (toplevel_bindings_p () && current_namespace == global_namespace) 289 pop_from_top_level (); 290 else if (at_namespace_scope_p ()) 291 pop_namespace (); 292 else if (at_class_scope_p ()) 293 popclass (); 294 else 295 { 296 gcc_assert (at_fake_function_scope_p ()); 297 gcc_assert (!at_function_scope_p ()); 298 gcc_assert (current_binding_level->kind == sk_block 299 && current_binding_level->this_entity == NULL); 300 leave_scope (); 301 --function_depth; 302 gcc_assert (current_binding_level->this_entity 303 == current_function_decl); 304 leave_scope (); 305 current_function_decl = NULL; 306 for (cp_binding_level *scope = current_binding_level; 307 scope; scope = scope->level_chain) 308 if (scope->kind == sk_function_parms) 309 { 310 current_function_decl = scope->this_entity; 311 break; 312 } 313 } 314 } 315 316 static void 317 supplement_binding (cxx_binding *binding, tree decl) 318 { 319 /* FIXME: this is pretty much a copy of supplement_binding_1 in 320 ../gcc/cp/name-lookup.c; the few replaced/removed bits are marked 321 with "// _1:". */ 322 tree bval = binding->value; 323 bool ok = true; 324 tree target_bval = strip_using_decl (bval); 325 tree target_decl = strip_using_decl (decl); 326 327 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl) 328 && target_decl != target_bval 329 && (TREE_CODE (target_bval) != TYPE_DECL 330 /* We allow pushing an enum multiple times in a class 331 template in order to handle late matching of underlying 332 type on an opaque-enum-declaration followed by an 333 enum-specifier. */ 334 || (processing_template_decl 335 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE 336 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE 337 && (dependent_type_p (ENUM_UNDERLYING_TYPE 338 (TREE_TYPE (target_decl))) 339 || dependent_type_p (ENUM_UNDERLYING_TYPE 340 (TREE_TYPE (target_bval))))))) 341 /* The new name is the type name. */ 342 binding->type = decl; 343 else if (/* TARGET_BVAL is null when push_class_level_binding moves 344 an inherited type-binding out of the way to make room 345 for a new value binding. */ 346 !target_bval 347 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name 348 has been used in a non-class scope prior declaration. 349 In that case, we should have already issued a 350 diagnostic; for graceful error recovery purpose, pretend 351 this was the intended declaration for that name. */ 352 || target_bval == error_mark_node 353 /* If TARGET_BVAL is anticipated but has not yet been 354 declared, pretend it is not there at all. */ 355 || (TREE_CODE (target_bval) == FUNCTION_DECL 356 && DECL_ANTICIPATED (target_bval) 357 && !DECL_HIDDEN_FRIEND_P (target_bval))) 358 binding->value = decl; 359 else if (TREE_CODE (target_bval) == TYPE_DECL 360 && DECL_ARTIFICIAL (target_bval) 361 && target_decl != target_bval 362 && (TREE_CODE (target_decl) != TYPE_DECL 363 || same_type_p (TREE_TYPE (target_decl), 364 TREE_TYPE (target_bval)))) 365 { 366 /* The old binding was a type name. It was placed in 367 VALUE field because it was thought, at the point it was 368 declared, to be the only entity with such a name. Move the 369 type name into the type slot; it is now hidden by the new 370 binding. */ 371 binding->type = bval; 372 binding->value = decl; 373 binding->value_is_inherited = false; 374 } 375 else if (TREE_CODE (target_bval) == TYPE_DECL 376 && TREE_CODE (target_decl) == TYPE_DECL 377 && DECL_NAME (target_decl) == DECL_NAME (target_bval) 378 && binding->scope->kind != sk_class 379 && (same_type_p (TREE_TYPE (target_decl), TREE_TYPE (target_bval)) 380 /* If either type involves template parameters, we must 381 wait until instantiation. */ 382 || uses_template_parms (TREE_TYPE (target_decl)) 383 || uses_template_parms (TREE_TYPE (target_bval)))) 384 /* We have two typedef-names, both naming the same type to have 385 the same name. In general, this is OK because of: 386 387 [dcl.typedef] 388 389 In a given scope, a typedef specifier can be used to redefine 390 the name of any type declared in that scope to refer to the 391 type to which it already refers. 392 393 However, in class scopes, this rule does not apply due to the 394 stricter language in [class.mem] prohibiting redeclarations of 395 members. */ 396 ok = false; 397 /* There can be two block-scope declarations of the same variable, 398 so long as they are `extern' declarations. However, there cannot 399 be two declarations of the same static data member: 400 401 [class.mem] 402 403 A member shall not be declared twice in the 404 member-specification. */ 405 else if (VAR_P (target_decl) 406 && VAR_P (target_bval) 407 && DECL_EXTERNAL (target_decl) && DECL_EXTERNAL (target_bval) 408 && !DECL_CLASS_SCOPE_P (target_decl)) 409 { 410 duplicate_decls (decl, binding->value, /*newdecl_is_friend=*/false); 411 ok = false; 412 } 413 else if (TREE_CODE (decl) == NAMESPACE_DECL 414 && TREE_CODE (bval) == NAMESPACE_DECL 415 && DECL_NAMESPACE_ALIAS (decl) 416 && DECL_NAMESPACE_ALIAS (bval) 417 && ORIGINAL_NAMESPACE (bval) == ORIGINAL_NAMESPACE (decl)) 418 /* [namespace.alias] 419 420 In a declarative region, a namespace-alias-definition can be 421 used to redefine a namespace-alias declared in that declarative 422 region to refer only to the namespace to which it already 423 refers. */ 424 ok = false; 425 else 426 { 427 // _1: diagnose_name_conflict (decl, bval); 428 ok = false; 429 } 430 431 gcc_assert (ok); // _1: return ok; 432 } 433 434 static void 435 reactivate_decl (tree decl, cp_binding_level *b) 436 { 437 bool in_function_p = TREE_CODE (b->this_entity) == FUNCTION_DECL; 438 gcc_assert (in_function_p 439 || (b == current_binding_level 440 && !at_class_scope_p ())); 441 442 tree id = DECL_NAME (decl); 443 tree type = NULL_TREE; 444 if (TREE_CODE (decl) == TYPE_DECL) 445 type = TREE_TYPE (decl); 446 447 if (type && TYPE_NAME (type) == decl 448 && (RECORD_OR_UNION_CODE_P (TREE_CODE (type)) 449 || TREE_CODE (type) == ENUMERAL_TYPE)) 450 { 451 gcc_assert (in_function_p && DECL_CONTEXT (decl) == b->this_entity); 452 type = TREE_TYPE (decl); 453 } 454 else 455 { 456 gcc_assert (DECL_CONTEXT (decl) == b->this_entity 457 || DECL_CONTEXT (decl) == global_namespace 458 || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL); 459 type = NULL_TREE; 460 } 461 462 /* Adjust IDENTIFIER_BINDING to what it would have been if we were 463 at binding level B. Save the binding chain up to that point in 464 [binding, *chainp), and take note of the outermost bindings found 465 before B. */ 466 cxx_binding *binding = IDENTIFIER_BINDING (id), **chainp = NULL; 467 tree *shadowing_type_p = NULL; 468 if (binding) 469 { 470 cp_binding_level *bc = current_binding_level; 471 for (cxx_binding *prev_binding = binding; 472 prev_binding; prev_binding = prev_binding->previous) 473 { 474 while (bc != b && bc != prev_binding->scope) 475 bc = bc->level_chain; 476 if (bc == b) 477 { 478 if (!chainp) 479 binding = NULL; 480 break; 481 } 482 chainp = &prev_binding->previous; 483 if (type) 484 for (tree tshadow = prev_binding->scope->type_shadowed; 485 tshadow; tshadow = TREE_CHAIN (tshadow)) 486 if (TREE_PURPOSE (tshadow) == id) 487 { 488 shadowing_type_p = &TREE_VALUE (tshadow); 489 break; 490 } 491 } 492 } 493 if (chainp) 494 { 495 IDENTIFIER_BINDING (id) = *chainp; 496 *chainp = NULL; 497 } 498 499 /* Like push_local_binding, supplement or add a binding to the 500 desired level. */ 501 if (IDENTIFIER_BINDING (id) && IDENTIFIER_BINDING (id)->scope == b) 502 supplement_binding (IDENTIFIER_BINDING (id), decl); 503 else 504 push_binding (id, decl, b); 505 506 /* Now restore the binding chain we'd temporarily removed. */ 507 if (chainp) 508 { 509 *chainp = IDENTIFIER_BINDING (id); 510 IDENTIFIER_BINDING (id) = binding; 511 512 if (type) 513 { 514 /* Insert the new type binding in the shadowing_type_p 515 TREE_VALUE chain. */ 516 tree shadowed_type = NULL_TREE; 517 if (shadowing_type_p) 518 { 519 shadowed_type = *shadowing_type_p; 520 *shadowing_type_p = type; 521 } 522 523 b->type_shadowed = tree_cons (id, shadowed_type, b->type_shadowed); 524 TREE_TYPE (b->type_shadowed) = type; 525 } 526 } 527 else if (type) 528 { 529 /* Our new binding is the active one, so shadow the earlier 530 binding. */ 531 b->type_shadowed = tree_cons (id, REAL_IDENTIFIER_TYPE_VALUE (id), 532 b->type_shadowed); 533 TREE_TYPE (b->type_shadowed) = type; 534 SET_IDENTIFIER_TYPE_VALUE (id, type); 535 } 536 537 /* Record that we have a binding for ID, like add_decl_to_level. */ 538 tree node = build_tree_list (NULL_TREE, decl); 539 TREE_CHAIN (node) = b->names; 540 b->names = node; 541 } 542 543 static void 544 plugin_pragma_push_user_expression (cpp_reader *) 545 { 546 if (push_count++) 547 return; 548 549 gcc_assert (!current_class_ptr); 550 gcc_assert (!current_class_ref); 551 552 gcc_assert (!cp_binding_oracle); 553 cp_binding_oracle = plugin_binding_oracle; 554 555 /* Make the function containing the user expression a global 556 friend, so as to bypass access controls in it. */ 557 if (at_function_scope_p ()) 558 set_global_friend (current_function_decl); 559 560 gcc_assert (at_function_scope_p ()); 561 function *save_cfun = cfun; 562 cp_binding_level *orig_binding_level = current_binding_level; 563 { 564 int success; 565 cc1_plugin::call (current_context, "enter_scope", &success); 566 } 567 gcc_assert (at_fake_function_scope_p () || at_function_scope_p ()); 568 569 function *unchanged_cfun = cfun; 570 tree changed_func_decl = current_function_decl; 571 572 gcc_assert (current_class_type == DECL_CONTEXT (current_function_decl) 573 || !(RECORD_OR_UNION_CODE_P 574 (TREE_CODE (DECL_CONTEXT (current_function_decl))))); 575 push_fake_function (save_cfun->decl, sk_block); 576 current_class_type = NULL_TREE; 577 if (unchanged_cfun) 578 { 579 /* If we get here, GDB did NOT change the context. */ 580 gcc_assert (cfun == save_cfun); 581 gcc_assert (at_function_scope_p ()); 582 gcc_assert (orig_binding_level 583 == current_binding_level->level_chain->level_chain); 584 } 585 else 586 { 587 cfun = save_cfun; 588 gcc_assert (at_function_scope_p ()); 589 590 cp_binding_level *b = current_binding_level->level_chain; 591 gcc_assert (b->this_entity == cfun->decl); 592 593 /* Reactivate local names from the previous context. Use 594 IDENTIFIER_MARKED to avoid reactivating shadowed names. */ 595 for (cp_binding_level *level = orig_binding_level;;) 596 { 597 for (tree name = level->names; 598 name; name = TREE_CHAIN (name)) 599 { 600 tree decl = name; 601 if (TREE_CODE (decl) == TREE_LIST) 602 decl = TREE_VALUE (decl); 603 if (IDENTIFIER_MARKED (DECL_NAME (decl))) 604 continue; 605 IDENTIFIER_MARKED (DECL_NAME (decl)) = 1; 606 reactivate_decl (decl, b); 607 } 608 if (level->kind == sk_function_parms 609 && level->this_entity == cfun->decl) 610 break; 611 gcc_assert (!level->this_entity); 612 level = level->level_chain; 613 } 614 615 /* Now, clear the markers. */ 616 for (tree name = b->names; name; name = TREE_CHAIN (name)) 617 { 618 tree decl = name; 619 if (TREE_CODE (decl) == TREE_LIST) 620 decl = TREE_VALUE (decl); 621 gcc_assert (IDENTIFIER_MARKED (DECL_NAME (decl))); 622 IDENTIFIER_MARKED (DECL_NAME (decl)) = 0; 623 } 624 } 625 626 if (unchanged_cfun || DECL_NONSTATIC_MEMBER_FUNCTION_P (changed_func_decl)) 627 { 628 /* Check whether the oracle supplies us with a "this", and if 629 so, arrange for data members and this itself to be 630 usable. */ 631 tree this_val = lookup_name (get_identifier ("this")); 632 current_class_ref = !this_val ? NULL_TREE 633 : cp_build_indirect_ref (this_val, RO_NULL, tf_warning_or_error); 634 current_class_ptr = this_val; 635 } 636 } 637 638 static void 639 plugin_pragma_pop_user_expression (cpp_reader *) 640 { 641 if (--push_count) 642 return; 643 644 gcc_assert (cp_binding_oracle); 645 646 gcc_assert (at_function_scope_p ()); 647 function *save_cfun = cfun; 648 current_class_ptr = NULL_TREE; 649 current_class_ref = NULL_TREE; 650 651 cfun = NULL; 652 pop_scope (); 653 if (RECORD_OR_UNION_CODE_P (TREE_CODE (DECL_CONTEXT (current_function_decl)))) 654 current_class_type = DECL_CONTEXT (current_function_decl); 655 { 656 int success; 657 cc1_plugin::call (current_context, "leave_scope", &success); 658 } 659 if (!cfun) 660 cfun = save_cfun; 661 else 662 gcc_assert (cfun == save_cfun); 663 664 cp_binding_oracle = NULL; 665 gcc_assert (at_function_scope_p ()); 666 } 667 668 static void 669 plugin_init_extra_pragmas (void *, void *) 670 { 671 c_register_pragma ("GCC", "push_user_expression", plugin_pragma_push_user_expression); 672 c_register_pragma ("GCC", "pop_user_expression", plugin_pragma_pop_user_expression); 673 /* FIXME: this one should go once we get GDB to use push and pop. */ 674 c_register_pragma ("GCC", "user_expression", plugin_pragma_push_user_expression); 675 } 676 677 678 679 static decl_addr_value 680 build_decl_addr_value (tree decl, gcc_address address) 681 { 682 decl_addr_value value = { 683 decl, 684 build_int_cst_type (ptr_type_node, address) 685 }; 686 return value; 687 } 688 689 static decl_addr_value * 690 record_decl_address (plugin_context *ctx, decl_addr_value value) 691 { 692 decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT); 693 gcc_assert (*slot == NULL); 694 *slot 695 = static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value))); 696 **slot = value; 697 /* We don't want GCC to warn about e.g. static functions 698 without a code definition. */ 699 TREE_NO_WARNING (value.decl) = 1; 700 return *slot; 701 } 702 703 // Maybe rewrite a decl to its address. 704 static tree 705 address_rewriter (tree *in, int *walk_subtrees, void *arg) 706 { 707 plugin_context *ctx = (plugin_context *) arg; 708 709 if (!DECL_P (*in) 710 || TREE_CODE (*in) == NAMESPACE_DECL 711 || DECL_NAME (*in) == NULL_TREE) 712 return NULL_TREE; 713 714 decl_addr_value value; 715 value.decl = *in; 716 decl_addr_value *found_value = ctx->address_map.find (&value); 717 if (found_value != NULL) 718 ; 719 else if (HAS_DECL_ASSEMBLER_NAME_P (*in)) 720 { 721 gcc_address address; 722 723 if (!cc1_plugin::call (ctx, "address_oracle", &address, 724 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (*in)))) 725 return NULL_TREE; 726 if (address == 0) 727 return NULL_TREE; 728 729 // Insert the decl into the address map in case it is referenced 730 // again. 731 value = build_decl_addr_value (value.decl, address); 732 found_value = record_decl_address (ctx, value); 733 } 734 else 735 return NULL_TREE; 736 737 if (found_value->address != error_mark_node) 738 { 739 // We have an address for the decl, so rewrite the tree. 740 tree ptr_type = build_pointer_type (TREE_TYPE (*in)); 741 *in = fold_build1 (INDIRECT_REF, TREE_TYPE (*in), 742 fold_build1 (CONVERT_EXPR, ptr_type, 743 found_value->address)); 744 } 745 746 *walk_subtrees = 0; 747 748 return NULL_TREE; 749 } 750 751 // When generating code for gdb, we want to be able to use absolute 752 // addresses to refer to otherwise external objects that gdb knows 753 // about. gdb passes in these addresses when building decls, and then 754 // before gimplification we go through the trees, rewriting uses to 755 // the equivalent of "*(TYPE *) ADDR". 756 static void 757 rewrite_decls_to_addresses (void *function_in, void *) 758 { 759 tree function = (tree) function_in; 760 761 // Do nothing if we're not in gdb. 762 if (current_context == NULL) 763 return; 764 765 walk_tree (&DECL_SAVED_TREE (function), address_rewriter, current_context, 766 NULL); 767 } 768 769 770 771 static inline tree 772 safe_push_template_decl (tree decl) 773 { 774 void (*save_oracle) (enum cp_oracle_request, tree identifier); 775 776 save_oracle = cp_binding_oracle; 777 cp_binding_oracle = NULL; 778 779 tree ret = push_template_decl (decl); 780 781 cp_binding_oracle = save_oracle; 782 783 return ret; 784 } 785 786 static inline tree 787 safe_pushtag (tree name, tree type, tag_scope scope) 788 { 789 void (*save_oracle) (enum cp_oracle_request, tree identifier); 790 791 save_oracle = cp_binding_oracle; 792 cp_binding_oracle = NULL; 793 794 tree ret = pushtag (name, type, scope); 795 796 cp_binding_oracle = save_oracle; 797 798 return ret; 799 } 800 801 static inline tree 802 safe_pushdecl_maybe_friend (tree decl, bool is_friend) 803 { 804 void (*save_oracle) (enum cp_oracle_request, tree identifier); 805 806 save_oracle = cp_binding_oracle; 807 cp_binding_oracle = NULL; 808 809 tree ret = pushdecl (decl, is_friend); 810 811 cp_binding_oracle = save_oracle; 812 813 return ret; 814 } 815 816 817 818 int 819 plugin_push_namespace (cc1_plugin::connection *, 820 const char *name) 821 { 822 if (name && !*name) 823 push_to_top_level (); 824 else 825 push_namespace (name ? get_identifier (name) : NULL); 826 827 return 1; 828 } 829 830 int 831 plugin_push_class (cc1_plugin::connection *, 832 gcc_type type_in) 833 { 834 tree type = convert_in (type_in); 835 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type))); 836 gcc_assert (TYPE_CONTEXT (type) == FROB_CONTEXT (current_scope ())); 837 838 pushclass (type); 839 840 return 1; 841 } 842 843 int 844 plugin_push_function (cc1_plugin::connection *, 845 gcc_decl function_decl_in) 846 { 847 tree fndecl = convert_in (function_decl_in); 848 gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL); 849 gcc_assert (DECL_CONTEXT (fndecl) == FROB_CONTEXT (current_scope ())); 850 851 push_fake_function (fndecl); 852 853 return 1; 854 } 855 856 int 857 plugin_pop_binding_level (cc1_plugin::connection *) 858 { 859 pop_scope (); 860 return 1; 861 } 862 863 int 864 plugin_reactivate_decl (cc1_plugin::connection *, 865 gcc_decl decl_in, 866 gcc_decl scope_in) 867 { 868 tree decl = convert_in (decl_in); 869 tree scope = convert_in (scope_in); 870 gcc_assert (TREE_CODE (decl) == VAR_DECL 871 || TREE_CODE (decl) == FUNCTION_DECL 872 || TREE_CODE (decl) == TYPE_DECL); 873 cp_binding_level *b; 874 if (scope) 875 { 876 gcc_assert (TREE_CODE (scope) == FUNCTION_DECL); 877 for (b = current_binding_level; 878 b->this_entity != scope; 879 b = b->level_chain) 880 gcc_assert (b->this_entity != global_namespace); 881 } 882 else 883 { 884 gcc_assert (!at_class_scope_p ()); 885 b = current_binding_level; 886 } 887 888 reactivate_decl (decl, b); 889 return 1; 890 } 891 892 static tree 893 get_current_scope () 894 { 895 tree decl; 896 897 if (at_namespace_scope_p ()) 898 decl = current_namespace; 899 else if (at_class_scope_p ()) 900 decl = TYPE_NAME (current_class_type); 901 else if (at_fake_function_scope_p () || at_function_scope_p ()) 902 decl = current_function_decl; 903 else 904 gcc_unreachable (); 905 906 return decl; 907 } 908 909 gcc_decl 910 plugin_get_current_binding_level_decl (cc1_plugin::connection *) 911 { 912 tree decl = get_current_scope (); 913 914 return convert_out (decl); 915 } 916 917 int 918 plugin_make_namespace_inline (cc1_plugin::connection *) 919 { 920 tree inline_ns = current_namespace; 921 922 gcc_assert (toplevel_bindings_p ()); 923 gcc_assert (inline_ns != global_namespace); 924 925 tree parent_ns = CP_DECL_CONTEXT (inline_ns); 926 927 if (DECL_NAMESPACE_INLINE_P (inline_ns)) 928 return 0; 929 930 DECL_NAMESPACE_INLINE_P (inline_ns) = true; 931 vec_safe_push (DECL_NAMESPACE_INLINEES (parent_ns), inline_ns); 932 933 return 1; 934 } 935 936 int 937 plugin_add_using_namespace (cc1_plugin::connection *, 938 gcc_decl used_ns_in) 939 { 940 tree used_ns = convert_in (used_ns_in); 941 942 gcc_assert (TREE_CODE (used_ns) == NAMESPACE_DECL); 943 944 finish_namespace_using_directive (used_ns, NULL_TREE); 945 946 return 1; 947 } 948 949 int 950 plugin_add_namespace_alias (cc1_plugin::connection *, 951 const char *id, 952 gcc_decl target_in) 953 { 954 tree name = get_identifier (id); 955 tree target = convert_in (target_in); 956 957 do_namespace_alias (name, target); 958 959 return 1; 960 } 961 962 static inline void 963 set_access_flags (tree decl, enum gcc_cp_symbol_kind flags) 964 { 965 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !DECL_CLASS_SCOPE_P (decl)); 966 967 switch (flags & GCC_CP_ACCESS_MASK) 968 { 969 case GCC_CP_ACCESS_PRIVATE: 970 TREE_PRIVATE (decl) = true; 971 current_access_specifier = access_private_node; 972 break; 973 974 case GCC_CP_ACCESS_PROTECTED: 975 TREE_PROTECTED (decl) = true; 976 current_access_specifier = access_protected_node; 977 break; 978 979 case GCC_CP_ACCESS_PUBLIC: 980 current_access_specifier = access_public_node; 981 break; 982 983 default: 984 break; 985 } 986 } 987 988 int 989 plugin_add_using_decl (cc1_plugin::connection *, 990 enum gcc_cp_symbol_kind flags, 991 gcc_decl target_in) 992 { 993 tree target = convert_in (target_in); 994 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_USING); 995 gcc_assert (!(flags & GCC_CP_FLAG_MASK)); 996 enum gcc_cp_symbol_kind acc_flags; 997 acc_flags = (enum gcc_cp_symbol_kind) (flags & GCC_CP_ACCESS_MASK); 998 999 gcc_assert (!template_parm_scope_p ()); 1000 1001 bool class_member_p = at_class_scope_p (); 1002 gcc_assert (!(acc_flags & GCC_CP_ACCESS_MASK) == !class_member_p); 1003 1004 tree identifier = DECL_NAME (target); 1005 tree tcontext = DECL_CONTEXT (target); 1006 1007 if (UNSCOPED_ENUM_P (tcontext)) 1008 tcontext = CP_TYPE_CONTEXT (tcontext); 1009 1010 if (class_member_p) 1011 { 1012 tree decl = do_class_using_decl (tcontext, identifier); 1013 1014 set_access_flags (decl, flags); 1015 1016 finish_member_declaration (decl); 1017 } 1018 else 1019 { 1020 /* We can't be at local scope. */ 1021 gcc_assert (at_namespace_scope_p ()); 1022 finish_namespace_using_decl (target, tcontext, identifier); 1023 } 1024 1025 return 1; 1026 } 1027 1028 static tree 1029 build_named_class_type (enum tree_code code, 1030 tree id, 1031 source_location loc) 1032 { 1033 /* See at_fake_function_scope_p. */ 1034 gcc_assert (!at_function_scope_p ()); 1035 tree type = make_class_type (code); 1036 tree type_decl = build_decl (loc, TYPE_DECL, id, type); 1037 TYPE_NAME (type) = type_decl; 1038 TYPE_STUB_DECL (type) = type_decl; 1039 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (type); 1040 1041 return type_decl; 1042 } 1043 1044 /* Abuse an unused field of the dummy template parms entry to hold the 1045 parm list. */ 1046 #define TP_PARM_LIST TREE_TYPE (current_template_parms) 1047 1048 gcc_decl 1049 plugin_build_decl (cc1_plugin::connection *self, 1050 const char *name, 1051 enum gcc_cp_symbol_kind sym_kind, 1052 gcc_type sym_type_in, 1053 const char *substitution_name, 1054 gcc_address address, 1055 const char *filename, 1056 unsigned int line_number) 1057 { 1058 plugin_context *ctx = static_cast<plugin_context *> (self); 1059 gcc_assert (!name || !strchr (name, ':')); // FIXME: this can go eventually. 1060 1061 enum tree_code code; 1062 tree decl; 1063 tree sym_type = convert_in (sym_type_in); 1064 enum gcc_cp_symbol_kind sym_flags; 1065 sym_flags = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_FLAG_MASK); 1066 enum gcc_cp_symbol_kind acc_flags; 1067 acc_flags = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_ACCESS_MASK); 1068 sym_kind = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_SYMBOL_MASK); 1069 1070 switch (sym_kind) 1071 { 1072 case GCC_CP_SYMBOL_FUNCTION: 1073 code = FUNCTION_DECL; 1074 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_FUNCTION)); 1075 break; 1076 1077 case GCC_CP_SYMBOL_VARIABLE: 1078 code = VAR_DECL; 1079 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_VARIABLE)); 1080 break; 1081 1082 case GCC_CP_SYMBOL_TYPEDEF: 1083 code = TYPE_DECL; 1084 gcc_assert (!sym_flags); 1085 break; 1086 1087 case GCC_CP_SYMBOL_CLASS: 1088 code = RECORD_TYPE; 1089 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_CLASS)); 1090 gcc_assert (!sym_type); 1091 break; 1092 1093 case GCC_CP_SYMBOL_UNION: 1094 code = UNION_TYPE; 1095 gcc_assert (!sym_flags); 1096 gcc_assert (!sym_type); 1097 break; 1098 1099 default: 1100 gcc_unreachable (); 1101 } 1102 1103 bool template_decl_p = template_parm_scope_p (); 1104 1105 if (template_decl_p) 1106 { 1107 gcc_assert (code == FUNCTION_DECL || code == RECORD_TYPE 1108 || code == TYPE_DECL); 1109 1110 /* Finish the template parm list that started this template parm. */ 1111 end_template_parm_list (TP_PARM_LIST); 1112 1113 gcc_assert (!address); 1114 gcc_assert (!substitution_name); 1115 } 1116 1117 source_location loc = ctx->get_source_location (filename, line_number); 1118 bool class_member_p = at_class_scope_p (); 1119 bool ctor = false, dtor = false, assop = false; 1120 tree_code opcode = ERROR_MARK; 1121 1122 gcc_assert (!(acc_flags & GCC_CP_ACCESS_MASK) == !class_member_p); 1123 1124 tree identifier; 1125 if (code != FUNCTION_DECL 1126 || !(sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION)) 1127 { 1128 if (name) 1129 identifier = get_identifier (name); 1130 else 1131 { 1132 gcc_assert (RECORD_OR_UNION_CODE_P (code)); 1133 identifier = make_anon_name (); 1134 } 1135 } 1136 1137 if (code == FUNCTION_DECL) 1138 { 1139 if (sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION) 1140 { 1141 #define CHARS2(f,s) (((unsigned char)f << CHAR_BIT) | (unsigned char)s) 1142 switch (CHARS2 (name[0], name[1])) 1143 { 1144 case CHARS2 ('C', 0x0): // ctor base declaration 1145 case CHARS2 ('C', ' '): 1146 case CHARS2 ('C', '1'): 1147 case CHARS2 ('C', '2'): 1148 case CHARS2 ('C', '4'): 1149 ctor = true; 1150 cdtor: 1151 gcc_assert (!address); 1152 gcc_assert (!substitution_name); 1153 identifier = DECL_NAME (TYPE_NAME (current_class_type)); 1154 break; 1155 case CHARS2 ('D', 0x0): // dtor base declaration 1156 case CHARS2 ('D', ' '): 1157 case CHARS2 ('D', '0'): 1158 case CHARS2 ('D', '1'): 1159 case CHARS2 ('D', '2'): 1160 case CHARS2 ('D', '4'): 1161 gcc_assert (!template_decl_p); 1162 dtor = true; 1163 goto cdtor; 1164 case CHARS2 ('n', 'w'): // operator new 1165 opcode = NEW_EXPR; 1166 break; 1167 case CHARS2 ('n', 'a'): // operator new[] 1168 opcode = VEC_NEW_EXPR; 1169 break; 1170 case CHARS2 ('d', 'l'): // operator delete 1171 opcode = DELETE_EXPR; 1172 break; 1173 case CHARS2 ('d', 'a'): // operator delete[] 1174 opcode = VEC_DELETE_EXPR; 1175 break; 1176 case CHARS2 ('p', 's'): // operator + (unary) 1177 opcode = PLUS_EXPR; 1178 break; 1179 case CHARS2 ('n', 'g'): // operator - (unary) 1180 opcode = MINUS_EXPR; 1181 break; 1182 case CHARS2 ('a', 'd'): // operator & (unary) 1183 opcode = BIT_AND_EXPR; 1184 break; 1185 case CHARS2 ('d', 'e'): // operator * (unary) 1186 opcode = MULT_EXPR; 1187 break; 1188 case CHARS2 ('c', 'o'): // operator ~ 1189 opcode = BIT_NOT_EXPR; 1190 break; 1191 case CHARS2 ('p', 'l'): // operator + 1192 opcode = PLUS_EXPR; 1193 break; 1194 case CHARS2 ('m', 'i'): // operator - 1195 opcode = MINUS_EXPR; 1196 break; 1197 case CHARS2 ('m', 'l'): // operator * 1198 opcode = MULT_EXPR; 1199 break; 1200 case CHARS2 ('d', 'v'): // operator / 1201 opcode = TRUNC_DIV_EXPR; 1202 break; 1203 case CHARS2 ('r', 'm'): // operator % 1204 opcode = TRUNC_MOD_EXPR; 1205 break; 1206 case CHARS2 ('a', 'n'): // operator & 1207 opcode = BIT_AND_EXPR; 1208 break; 1209 case CHARS2 ('o', 'r'): // operator | 1210 opcode = BIT_IOR_EXPR; 1211 break; 1212 case CHARS2 ('e', 'o'): // operator ^ 1213 opcode = BIT_XOR_EXPR; 1214 break; 1215 case CHARS2 ('a', 'S'): // operator = 1216 opcode = NOP_EXPR; 1217 assop = true; 1218 break; 1219 case CHARS2 ('p', 'L'): // operator += 1220 opcode = PLUS_EXPR; 1221 assop = true; 1222 break; 1223 case CHARS2 ('m', 'I'): // operator -= 1224 opcode = MINUS_EXPR; 1225 assop = true; 1226 break; 1227 case CHARS2 ('m', 'L'): // operator *= 1228 opcode = MULT_EXPR; 1229 assop = true; 1230 break; 1231 case CHARS2 ('d', 'V'): // operator /= 1232 opcode = TRUNC_DIV_EXPR; 1233 assop = true; 1234 break; 1235 case CHARS2 ('r', 'M'): // operator %= 1236 opcode = TRUNC_MOD_EXPR; 1237 assop = true; 1238 break; 1239 case CHARS2 ('a', 'N'): // operator &= 1240 opcode = BIT_AND_EXPR; 1241 assop = true; 1242 break; 1243 case CHARS2 ('o', 'R'): // operator |= 1244 opcode = BIT_IOR_EXPR; 1245 assop = true; 1246 break; 1247 case CHARS2 ('e', 'O'): // operator ^= 1248 opcode = BIT_XOR_EXPR; 1249 assop = true; 1250 break; 1251 case CHARS2 ('l', 's'): // operator << 1252 opcode = LSHIFT_EXPR; 1253 break; 1254 case CHARS2 ('r', 's'): // operator >> 1255 opcode = RSHIFT_EXPR; 1256 break; 1257 case CHARS2 ('l', 'S'): // operator <<= 1258 opcode = LSHIFT_EXPR; 1259 assop = true; 1260 break; 1261 case CHARS2 ('r', 'S'): // operator >>= 1262 opcode = RSHIFT_EXPR; 1263 assop = true; 1264 break; 1265 case CHARS2 ('e', 'q'): // operator == 1266 opcode = EQ_EXPR; 1267 break; 1268 case CHARS2 ('n', 'e'): // operator != 1269 opcode = NE_EXPR; 1270 break; 1271 case CHARS2 ('l', 't'): // operator < 1272 opcode = LT_EXPR; 1273 break; 1274 case CHARS2 ('g', 't'): // operator > 1275 opcode = GT_EXPR; 1276 break; 1277 case CHARS2 ('l', 'e'): // operator <= 1278 opcode = LE_EXPR; 1279 break; 1280 case CHARS2 ('g', 'e'): // operator >= 1281 opcode = GE_EXPR; 1282 break; 1283 case CHARS2 ('n', 't'): // operator ! 1284 opcode = TRUTH_NOT_EXPR; 1285 break; 1286 case CHARS2 ('a', 'a'): // operator && 1287 opcode = TRUTH_ANDIF_EXPR; 1288 break; 1289 case CHARS2 ('o', 'o'): // operator || 1290 opcode = TRUTH_ORIF_EXPR; 1291 break; 1292 case CHARS2 ('p', 'p'): // operator ++ 1293 opcode = POSTINCREMENT_EXPR; 1294 break; 1295 case CHARS2 ('m', 'm'): // operator -- 1296 /* This stands for either one as an operator name, and 1297 "pp" and "mm" stand for POST??CREMENT, but for some 1298 reason the parser uses this opcode name for 1299 operator--; let's follow their practice. */ 1300 opcode = PREDECREMENT_EXPR; 1301 break; 1302 case CHARS2 ('c', 'm'): // operator , 1303 opcode = COMPOUND_EXPR; 1304 break; 1305 case CHARS2 ('p', 'm'): // operator ->* 1306 opcode = MEMBER_REF; 1307 break; 1308 case CHARS2 ('p', 't'): // operator -> 1309 opcode = COMPONENT_REF; 1310 break; 1311 case CHARS2 ('c', 'l'): // operator () 1312 opcode = CALL_EXPR; 1313 break; 1314 case CHARS2 ('i', 'x'): // operator [] 1315 opcode = ARRAY_REF; 1316 break; 1317 case CHARS2 ('c', 'v'): // operator <T> (conversion operator) 1318 identifier = make_conv_op_name (TREE_TYPE (sym_type)); 1319 break; 1320 // C++11-only: 1321 case CHARS2 ('l', 'i'): // operator "" <id> 1322 { 1323 char *id = (char *)name + 2; 1324 bool freeid = false; 1325 if (*id >= '0' && *id <= '9') 1326 { 1327 unsigned len = 0; 1328 do 1329 { 1330 len *= 10; 1331 len += id[0] - '0'; 1332 id++; 1333 } 1334 while (*id && *id >= '0' && *id <= '9'); 1335 id = xstrndup (id, len); 1336 freeid = true; 1337 } 1338 identifier = cp_literal_operator_id (id); 1339 if (freeid) 1340 free (id); 1341 } 1342 break; 1343 case CHARS2 ('q', 'u'): // ternary operator, not overloadable. 1344 default: 1345 gcc_unreachable (); 1346 } 1347 1348 if (opcode != ERROR_MARK) 1349 identifier = ovl_op_identifier (assop, opcode); 1350 } 1351 decl = build_lang_decl_loc (loc, code, identifier, sym_type); 1352 /* FIXME: current_lang_name is lang_name_c while compiling an 1353 extern "C" function, and we haven't switched to a global 1354 context at this point, and this breaks function 1355 overloading. */ 1356 SET_DECL_LANGUAGE (decl, lang_cplusplus); 1357 if (TREE_CODE (sym_type) == METHOD_TYPE) 1358 DECL_ARGUMENTS (decl) = build_this_parm (decl, current_class_type, 1359 cp_type_quals (sym_type)); 1360 for (tree arg = TREE_CODE (sym_type) == METHOD_TYPE 1361 ? TREE_CHAIN (TYPE_ARG_TYPES (sym_type)) 1362 : TYPE_ARG_TYPES (sym_type); 1363 arg && arg != void_list_node; 1364 arg = TREE_CHAIN (arg)) 1365 { 1366 tree parm = cp_build_parm_decl (decl, NULL_TREE, TREE_VALUE (arg)); 1367 DECL_CHAIN (parm) = DECL_ARGUMENTS (decl); 1368 DECL_ARGUMENTS (decl) = parm; 1369 } 1370 DECL_ARGUMENTS (decl) = nreverse (DECL_ARGUMENTS (decl)); 1371 if (class_member_p) 1372 { 1373 if (TREE_CODE (sym_type) == FUNCTION_TYPE) 1374 DECL_STATIC_FUNCTION_P (decl) = 1; 1375 if (sym_flags & GCC_CP_FLAG_VIRTUAL_FUNCTION) 1376 { 1377 DECL_VIRTUAL_P (decl) = 1; 1378 if (sym_flags & GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION) 1379 DECL_PURE_VIRTUAL_P (decl) = 1; 1380 if (sym_flags & GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION) 1381 DECL_FINAL_P (decl) = 1; 1382 } 1383 else 1384 gcc_assert (!(sym_flags & (GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION 1385 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION))); 1386 } 1387 else 1388 { 1389 gcc_assert (!(sym_flags & (GCC_CP_FLAG_VIRTUAL_FUNCTION 1390 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION 1391 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION))); 1392 gcc_assert (!ctor && !dtor && !assop); 1393 } 1394 if (sym_flags & GCC_CP_FLAG_EXPLICIT_FUNCTION) 1395 DECL_NONCONVERTING_P (decl) = 1; 1396 if (sym_flags & GCC_CP_FLAG_DEFAULTED_FUNCTION) 1397 { 1398 DECL_INITIAL (decl) = ridpointers[(int)RID_DEFAULT]; 1399 DECL_DEFAULTED_FN (decl) = 1; 1400 } 1401 if (sym_flags & GCC_CP_FLAG_DELETED_FUNCTION) 1402 { 1403 // DECL_INITIAL (decl) = ridpointers[(int)RID_DELETE]; 1404 DECL_DELETED_FN (decl) = 1; 1405 DECL_DECLARED_INLINE_P (decl) = 1; 1406 DECL_INITIAL (decl) = error_mark_node; 1407 } 1408 1409 if (ctor) 1410 DECL_CXX_CONSTRUCTOR_P (decl) = 1; 1411 else if (dtor) 1412 DECL_CXX_DESTRUCTOR_P (decl) = 1; 1413 else if ((sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION) 1414 && opcode != ERROR_MARK) 1415 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op_mapping[opcode]; 1416 } 1417 else if (RECORD_OR_UNION_CODE_P (code)) 1418 { 1419 decl = build_named_class_type (code, identifier, loc); 1420 tree type = TREE_TYPE (decl); 1421 1422 if (code == RECORD_TYPE 1423 && !(sym_flags & GCC_CP_FLAG_CLASS_IS_STRUCT)) 1424 CLASSTYPE_DECLARED_CLASS (type) = true; 1425 } 1426 else if (class_member_p) 1427 { 1428 decl = build_lang_decl_loc (loc, code, identifier, sym_type); 1429 1430 if (TREE_CODE (decl) == VAR_DECL) 1431 { 1432 DECL_THIS_STATIC (decl) = 1; 1433 // The remainder of this block does the same as: 1434 // set_linkage_for_static_data_member (decl); 1435 TREE_PUBLIC (decl) = 1; 1436 TREE_STATIC (decl) = 1; 1437 DECL_INTERFACE_KNOWN (decl) = 1; 1438 1439 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE 1440 gcc_assert (!(sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE)); 1441 1442 if (sym_flags & GCC_CP_FLAG_CONSTEXPR_VARIABLE) 1443 DECL_DECLARED_CONSTEXPR_P (decl) = true; 1444 } 1445 } 1446 else 1447 { 1448 decl = build_decl (loc, code, identifier, sym_type); 1449 1450 if (TREE_CODE (decl) == VAR_DECL) 1451 { 1452 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE 1453 gcc_assert (!(sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE)); 1454 1455 if (sym_flags & GCC_CP_FLAG_CONSTEXPR_VARIABLE) 1456 DECL_DECLARED_CONSTEXPR_P (decl) = true; 1457 } 1458 } 1459 TREE_USED (decl) = 1; 1460 TREE_ADDRESSABLE (decl) = 1; 1461 1462 if (class_member_p) 1463 DECL_CONTEXT (decl) = FROB_CONTEXT (current_class_type); 1464 else if (at_namespace_scope_p ()) 1465 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ()); 1466 1467 set_access_flags (decl, acc_flags); 1468 1469 /* If this is the typedef that names an otherwise anonymous type, 1470 propagate the typedef name to the type. In normal compilation, 1471 this is done in grokdeclarator. */ 1472 if (sym_kind == GCC_CP_SYMBOL_TYPEDEF 1473 && !template_decl_p 1474 && DECL_CONTEXT (decl) == TYPE_CONTEXT (sym_type) 1475 && TYPE_UNNAMED_P (sym_type)) 1476 name_unnamed_type (sym_type, decl); 1477 1478 if (sym_kind != GCC_CP_SYMBOL_TYPEDEF 1479 && sym_kind != GCC_CP_SYMBOL_CLASS 1480 && sym_kind != GCC_CP_SYMBOL_UNION 1481 && !template_decl_p && !ctor && !dtor) 1482 { 1483 decl_addr_value value; 1484 1485 DECL_EXTERNAL (decl) = 1; 1486 value.decl = decl; 1487 if (substitution_name != NULL) 1488 { 1489 // If the translator gave us a name without a binding, 1490 // we can just substitute error_mark_node, since we know the 1491 // translator will be reporting an error anyhow. 1492 value.address 1493 = lookup_name (get_identifier (substitution_name)); 1494 if (value.address == NULL_TREE) 1495 value.address = error_mark_node; 1496 } 1497 else if (address) 1498 value.address = build_int_cst_type (ptr_type_node, address); 1499 else 1500 value.address = NULL; 1501 if (value.address) 1502 record_decl_address (ctx, value); 1503 } 1504 1505 if (class_member_p && code == FUNCTION_DECL) 1506 { 1507 if (ctor || dtor) 1508 maybe_retrofit_in_chrg (decl); 1509 1510 grok_special_member_properties (decl); 1511 } 1512 1513 if (template_decl_p) 1514 { 1515 if (RECORD_OR_UNION_CODE_P (code)) 1516 safe_pushtag (identifier, TREE_TYPE (decl), ts_current); 1517 else 1518 decl = safe_push_template_decl (decl); 1519 1520 tree tdecl = NULL_TREE; 1521 if (class_member_p) 1522 tdecl = finish_member_template_decl (decl); 1523 1524 end_template_decl (); 1525 1526 /* We only support one level of templates, because we only 1527 support declaring generics; actual definitions are only of 1528 specializations. */ 1529 gcc_assert (!template_parm_scope_p ()); 1530 1531 if (class_member_p) 1532 finish_member_declaration (tdecl); 1533 } 1534 else if (RECORD_OR_UNION_CODE_P (code)) 1535 safe_pushtag (identifier, TREE_TYPE (decl), ts_current); 1536 else if (class_member_p) 1537 finish_member_declaration (decl); 1538 else 1539 decl = safe_pushdecl_maybe_friend (decl, false); 1540 1541 if ((ctor || dtor) 1542 /* Don't crash after a duplicate declaration of a cdtor. */ 1543 && TYPE_FIELDS (current_class_type) == decl) 1544 { 1545 /* ctors and dtors clones are chained after DECL. 1546 However, we create the clones before TYPE_METHODS is 1547 reversed. We test for cloned methods after reversal, 1548 however, and the test requires the clones to follow 1549 DECL. So, we reverse the chain of clones now, so 1550 that it will come out in the right order after 1551 reversal. */ 1552 tree save = DECL_CHAIN (decl); 1553 DECL_CHAIN (decl) = NULL_TREE; 1554 clone_function_decl (decl, /*update_methods=*/true); 1555 gcc_assert (TYPE_FIELDS (current_class_type) == decl); 1556 TYPE_FIELDS (current_class_type) 1557 = nreverse (TYPE_FIELDS (current_class_type)); 1558 DECL_CHAIN (decl) = save; 1559 } 1560 1561 rest_of_decl_compilation (decl, toplevel_bindings_p (), 0); 1562 1563 return convert_out (ctx->preserve (decl)); 1564 } 1565 1566 gcc_decl 1567 plugin_define_cdtor_clone (cc1_plugin::connection *self, 1568 const char *name, 1569 gcc_decl cdtor_in, 1570 gcc_address address) 1571 { 1572 plugin_context *ctx = static_cast<plugin_context *> (self); 1573 tree decl = convert_in (cdtor_in); 1574 bool ctor = false; 1575 bool dtor = false; 1576 tree identifier; 1577 1578 switch (CHARS2 (name[0], name[1])) 1579 { 1580 case CHARS2 ('C', '1'): // in-charge constructor 1581 identifier = complete_ctor_identifier; 1582 ctor = true; 1583 break; 1584 case CHARS2 ('C', '2'): // not-in-charge constructor 1585 identifier = base_ctor_identifier; 1586 ctor = true; 1587 break; 1588 case CHARS2 ('C', '4'): 1589 identifier = ctor_identifier; // unified constructor 1590 ctor = true; 1591 break; 1592 case CHARS2 ('D', '0'): // deleting destructor 1593 identifier = deleting_dtor_identifier; 1594 dtor = true; 1595 break; 1596 case CHARS2 ('D', '1'): // in-charge destructor 1597 identifier = complete_dtor_identifier; 1598 dtor = true; 1599 break; 1600 case CHARS2 ('D', '2'): // not-in-charge destructor 1601 identifier = base_dtor_identifier; 1602 dtor = true; 1603 break; 1604 case CHARS2 ('D', '4'): 1605 identifier = dtor_identifier; // unified destructor 1606 dtor = true; 1607 break; 1608 1609 default: 1610 gcc_unreachable (); 1611 } 1612 1613 gcc_assert (!ctor != !dtor); 1614 gcc_assert (ctor 1615 ? (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl) 1616 && DECL_NAME (decl) == ctor_identifier) 1617 : (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl) 1618 && DECL_NAME (decl) == dtor_identifier)); 1619 1620 while (decl && DECL_NAME (decl) != identifier) 1621 { 1622 decl = DECL_CHAIN (decl); 1623 if (decl && !DECL_CLONED_FUNCTION_P (decl)) 1624 decl = NULL_TREE; 1625 } 1626 gcc_assert (decl); 1627 1628 record_decl_address (ctx, build_decl_addr_value (decl, address)); 1629 1630 return convert_out (decl); 1631 } 1632 1633 int 1634 plugin_add_friend (cc1_plugin::connection * /* self */, 1635 gcc_decl decl_in, 1636 gcc_type type_in) 1637 { 1638 tree decl = convert_in (decl_in); 1639 tree type = convert_in (type_in); 1640 1641 gcc_assert (type || at_class_scope_p ()); 1642 1643 if (!type) 1644 type = current_class_type; 1645 else 1646 gcc_assert (TREE_CODE (type) == RECORD_TYPE); 1647 1648 if (TYPE_P (decl)) 1649 make_friend_class (type, TREE_TYPE (decl), true); 1650 else 1651 { 1652 DECL_FRIEND_P (decl) = true; 1653 add_friend (type, decl, true); 1654 } 1655 1656 return 1; 1657 } 1658 1659 gcc_type 1660 plugin_build_pointer_type (cc1_plugin::connection *, 1661 gcc_type base_type) 1662 { 1663 // No need to preserve a pointer type as the base type is preserved. 1664 return convert_out (build_pointer_type (convert_in (base_type))); 1665 } 1666 1667 gcc_type 1668 plugin_build_reference_type (cc1_plugin::connection *, 1669 gcc_type base_type_in, 1670 enum gcc_cp_ref_qualifiers rquals) 1671 { 1672 bool rval; 1673 1674 switch (rquals) 1675 { 1676 case GCC_CP_REF_QUAL_LVALUE: 1677 rval = false; 1678 break; 1679 case GCC_CP_REF_QUAL_RVALUE: 1680 rval = true; 1681 break; 1682 case GCC_CP_REF_QUAL_NONE: 1683 default: 1684 gcc_unreachable (); 1685 } 1686 1687 tree rtype = cp_build_reference_type (convert_in (base_type_in), rval); 1688 1689 return convert_out (rtype); 1690 } 1691 1692 static tree 1693 start_class_def (tree type, 1694 const gcc_vbase_array *base_classes) 1695 { 1696 tree bases = NULL; 1697 if (base_classes) 1698 { 1699 for (int i = 0; i < base_classes->n_elements; i++) 1700 { 1701 tree access; 1702 1703 gcc_assert ((base_classes->flags[i] & GCC_CP_SYMBOL_MASK) 1704 == GCC_CP_SYMBOL_BASECLASS); 1705 1706 switch (base_classes->flags[i] & GCC_CP_ACCESS_MASK) 1707 { 1708 case GCC_CP_ACCESS_PRIVATE: 1709 access = ridpointers[(int)RID_PRIVATE]; 1710 break; 1711 1712 case GCC_CP_ACCESS_PROTECTED: 1713 access = ridpointers[(int)RID_PROTECTED]; 1714 break; 1715 1716 case GCC_CP_ACCESS_PUBLIC: 1717 access = ridpointers[(int)RID_PUBLIC]; 1718 break; 1719 1720 default: 1721 gcc_unreachable (); 1722 } 1723 1724 tree base = finish_base_specifier 1725 (convert_in (base_classes->elements[i]), access, 1726 (base_classes->flags[i] & GCC_CP_FLAG_BASECLASS_VIRTUAL) != 0); 1727 TREE_CHAIN (base) = bases; 1728 bases = base; 1729 } 1730 bases = nreverse (bases); 1731 } 1732 xref_basetypes (type, bases); 1733 begin_class_definition (type); 1734 return type; 1735 } 1736 1737 gcc_type 1738 plugin_start_class_type (cc1_plugin::connection *self, 1739 gcc_decl typedecl_in, 1740 const gcc_vbase_array *base_classes, 1741 const char *filename, 1742 unsigned int line_number) 1743 { 1744 plugin_context *ctx = static_cast<plugin_context *> (self); 1745 source_location loc = ctx->get_source_location (filename, line_number); 1746 tree typedecl = convert_in (typedecl_in); 1747 tree type = TREE_TYPE (typedecl); 1748 1749 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type))); 1750 gcc_assert (!COMPLETE_TYPE_P (type)); 1751 1752 DECL_SOURCE_LOCATION (typedecl) = loc; 1753 1754 tree result = start_class_def (type, base_classes); 1755 1756 return convert_out (ctx->preserve (result)); 1757 } 1758 1759 gcc_type 1760 plugin_start_closure_class_type (cc1_plugin::connection *self, 1761 int discriminator, 1762 gcc_decl extra_scope_in, 1763 enum gcc_cp_symbol_kind flags, 1764 const char *filename, 1765 unsigned int line_number) 1766 { 1767 plugin_context *ctx = static_cast<plugin_context *> (self); 1768 tree extra_scope = convert_in (extra_scope_in); 1769 1770 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_LAMBDA_CLOSURE); 1771 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK))) == 0); 1772 1773 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !at_class_scope_p ()); 1774 1775 /* See at_fake_function_scope_p. */ 1776 gcc_assert (!at_function_scope_p ()); 1777 1778 if (extra_scope) 1779 { 1780 if (TREE_CODE (extra_scope) == PARM_DECL) 1781 { 1782 gcc_assert (at_fake_function_scope_p ()); 1783 /* Check that the given extra_scope is one of the parameters of 1784 the current function. */ 1785 for (tree parm = DECL_ARGUMENTS (current_function_decl); 1786 ; parm = DECL_CHAIN (parm)) 1787 { 1788 gcc_assert (parm); 1789 if (parm == extra_scope) 1790 break; 1791 } 1792 } 1793 else if (TREE_CODE (extra_scope) == FIELD_DECL) 1794 { 1795 gcc_assert (at_class_scope_p ()); 1796 gcc_assert (DECL_CONTEXT (extra_scope) == current_class_type); 1797 } 1798 else 1799 /* FIXME: does this ever really occur? */ 1800 gcc_assert (TREE_CODE (extra_scope) == VAR_DECL); 1801 } 1802 1803 tree lambda_expr = build_lambda_expr (); 1804 1805 LAMBDA_EXPR_LOCATION (lambda_expr) = ctx->get_source_location (filename, 1806 line_number); 1807 1808 tree type = begin_lambda_type (lambda_expr); 1809 1810 /* Instead of calling record_lambda_scope, do this: */ 1811 LAMBDA_EXPR_EXTRA_SCOPE (lambda_expr) = extra_scope; 1812 LAMBDA_EXPR_DISCRIMINATOR (lambda_expr) = discriminator; 1813 1814 tree decl = TYPE_NAME (type); 1815 determine_visibility (decl); 1816 set_access_flags (decl, flags); 1817 1818 return convert_out (ctx->preserve (type)); 1819 } 1820 1821 gcc_expr 1822 plugin_build_lambda_expr (cc1_plugin::connection *self, 1823 gcc_type closure_type_in) 1824 { 1825 plugin_context *ctx = static_cast<plugin_context *> (self); 1826 tree closure_type = convert_in (closure_type_in); 1827 1828 gcc_assert (LAMBDA_TYPE_P (closure_type)); 1829 1830 tree lambda_expr = CLASSTYPE_LAMBDA_EXPR (closure_type); 1831 1832 tree lambda_object = build_lambda_object (lambda_expr); 1833 1834 return convert_out (ctx->preserve (lambda_object)); 1835 } 1836 1837 gcc_decl 1838 plugin_build_field (cc1_plugin::connection *, 1839 const char *field_name, 1840 gcc_type field_type_in, 1841 enum gcc_cp_symbol_kind flags, 1842 unsigned long bitsize, 1843 unsigned long bitpos) 1844 { 1845 tree record_or_union_type = current_class_type; 1846 tree field_type = convert_in (field_type_in); 1847 1848 gcc_assert (at_class_scope_p ()); 1849 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type))); 1850 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_FIELD); 1851 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK 1852 | GCC_CP_FLAG_MASK_FIELD))) == 0); 1853 gcc_assert ((flags & GCC_CP_ACCESS_MASK)); 1854 1855 /* Note that gdb does not preserve the location of field decls, so 1856 we can't provide a decent location here. */ 1857 tree decl = build_decl (BUILTINS_LOCATION, FIELD_DECL, 1858 get_identifier (field_name), field_type); 1859 DECL_FIELD_CONTEXT (decl) = record_or_union_type; 1860 1861 set_access_flags (decl, flags); 1862 1863 if ((flags & GCC_CP_FLAG_FIELD_MUTABLE) != 0) 1864 DECL_MUTABLE_P (decl) = 1; 1865 1866 if (TREE_CODE (field_type) == INTEGER_TYPE 1867 && TYPE_PRECISION (field_type) != bitsize) 1868 { 1869 DECL_BIT_FIELD_TYPE (decl) = field_type; 1870 TREE_TYPE (decl) 1871 = c_build_bitfield_integer_type (bitsize, TYPE_UNSIGNED (field_type)); 1872 } 1873 1874 SET_DECL_MODE (decl, TYPE_MODE (TREE_TYPE (decl))); 1875 1876 // There's no way to recover this from DWARF. 1877 SET_DECL_OFFSET_ALIGN (decl, TYPE_PRECISION (pointer_sized_int_node)); 1878 1879 tree pos = bitsize_int (bitpos); 1880 pos_from_bit (&DECL_FIELD_OFFSET (decl), &DECL_FIELD_BIT_OFFSET (decl), 1881 DECL_OFFSET_ALIGN (decl), pos); 1882 1883 DECL_SIZE (decl) = bitsize_int (bitsize); 1884 DECL_SIZE_UNIT (decl) = size_int ((bitsize + BITS_PER_UNIT - 1) 1885 / BITS_PER_UNIT); 1886 1887 DECL_CHAIN (decl) = TYPE_FIELDS (record_or_union_type); 1888 TYPE_FIELDS (record_or_union_type) = decl; 1889 1890 return convert_out (decl); 1891 } 1892 1893 int 1894 plugin_finish_class_type (cc1_plugin::connection *, 1895 unsigned long size_in_bytes) 1896 { 1897 tree record_or_union_type = current_class_type; 1898 1899 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type))); 1900 1901 finish_struct (record_or_union_type, NULL); 1902 1903 gcc_assert (compare_tree_int (TYPE_SIZE_UNIT (record_or_union_type), 1904 size_in_bytes) == 0); 1905 1906 return 1; 1907 } 1908 1909 gcc_type 1910 plugin_start_enum_type (cc1_plugin::connection *self, 1911 const char *name, 1912 gcc_type underlying_int_type_in, 1913 enum gcc_cp_symbol_kind flags, 1914 const char *filename, 1915 unsigned int line_number) 1916 { 1917 plugin_context *ctx = static_cast<plugin_context *> (self); 1918 tree underlying_int_type = convert_in (underlying_int_type_in); 1919 1920 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_ENUM); 1921 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK 1922 | GCC_CP_FLAG_MASK_ENUM))) == 0); 1923 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !at_class_scope_p ()); 1924 1925 if (underlying_int_type == error_mark_node) 1926 return convert_out (error_mark_node); 1927 1928 bool is_new_type = false; 1929 1930 tree id = name ? get_identifier (name) : make_anon_name (); 1931 1932 tree type = start_enum (id, NULL_TREE, 1933 underlying_int_type, 1934 /* attributes = */ NULL_TREE, 1935 !!(flags & GCC_CP_FLAG_ENUM_SCOPED), &is_new_type); 1936 1937 gcc_assert (is_new_type); 1938 1939 source_location loc = ctx->get_source_location (filename, line_number); 1940 tree type_decl = TYPE_NAME (type); 1941 DECL_SOURCE_LOCATION (type_decl) = loc; 1942 SET_OPAQUE_ENUM_P (type, false); 1943 1944 set_access_flags (type_decl, flags); 1945 1946 return convert_out (ctx->preserve (type)); 1947 } 1948 1949 gcc_decl 1950 plugin_build_enum_constant (cc1_plugin::connection *, 1951 gcc_type enum_type_in, 1952 const char *name, 1953 unsigned long value) 1954 { 1955 tree enum_type = convert_in (enum_type_in); 1956 1957 gcc_assert (TREE_CODE (enum_type) == ENUMERAL_TYPE); 1958 1959 build_enumerator (get_identifier (name), build_int_cst (enum_type, value), 1960 enum_type, NULL_TREE, BUILTINS_LOCATION); 1961 1962 return convert_out (TREE_VALUE (TYPE_VALUES (enum_type))); 1963 } 1964 1965 int 1966 plugin_finish_enum_type (cc1_plugin::connection *, 1967 gcc_type enum_type_in) 1968 { 1969 tree enum_type = convert_in (enum_type_in); 1970 1971 finish_enum_value_list (enum_type); 1972 finish_enum (enum_type); 1973 1974 return 1; 1975 } 1976 1977 gcc_type 1978 plugin_build_function_type (cc1_plugin::connection *self, 1979 gcc_type return_type_in, 1980 const struct gcc_type_array *argument_types_in, 1981 int is_varargs) 1982 { 1983 tree *argument_types; 1984 tree return_type = convert_in (return_type_in); 1985 tree result; 1986 1987 argument_types = new tree[argument_types_in->n_elements]; 1988 for (int i = 0; i < argument_types_in->n_elements; ++i) 1989 argument_types[i] = convert_in (argument_types_in->elements[i]); 1990 1991 if (is_varargs) 1992 result = build_varargs_function_type_array (return_type, 1993 argument_types_in->n_elements, 1994 argument_types); 1995 else 1996 result = build_function_type_array (return_type, 1997 argument_types_in->n_elements, 1998 argument_types); 1999 2000 delete[] argument_types; 2001 2002 plugin_context *ctx = static_cast<plugin_context *> (self); 2003 return convert_out (ctx->preserve (result)); 2004 } 2005 2006 #if 0 2007 2008 gcc_type 2009 plugin_add_function_default_args (cc1_plugin::connection *self, 2010 gcc_type function_type_in, 2011 const struct gcc_cp_function_args *defaults) 2012 { 2013 tree function_type = convert_in (function_type_in); 2014 2015 gcc_assert (TREE_CODE (function_type) == FUNCTION_TYPE); 2016 2017 if (!defaults || !defaults->n_elements) 2018 return function_type_in; 2019 2020 tree pargs = TYPE_ARG_TYPES (function_type); 2021 tree nargs = NULL_TREE; 2022 2023 /* Build a reversed copy of the list of default-less arguments in 2024 NARGS. At the end of the loop, PARGS will point to the end of 2025 the argument list, or to the first argument that had a default 2026 value. */ 2027 while (pargs && TREE_VALUE (pargs) != void_list_node 2028 && !TREE_PURPOSE (pargs)) 2029 { 2030 nargs = tree_cons (NULL_TREE, TREE_VALUE (pargs), nargs); 2031 pargs = TREE_CHAIN (pargs); 2032 } 2033 2034 /* Set the defaults in the now-leading NARGS, taking into account 2035 that NARGS is reversed but DEFAULTS->elements isn't. */ 2036 tree ndargs = nargs; 2037 int i = defaults->n_elements; 2038 while (i--) 2039 { 2040 gcc_assert (ndargs); 2041 tree deflt = convert_in (defaults->elements[i]); 2042 if (!deflt) 2043 deflt = error_mark_node; 2044 TREE_PURPOSE (ndargs) = deflt; 2045 ndargs = TREE_CHAIN (ndargs); 2046 } 2047 2048 /* Finally, reverse NARGS, and append the remaining PARGS that 2049 already had defaults. */ 2050 nargs = nreverse (nargs); 2051 nargs = chainon (nargs, pargs); 2052 2053 tree result = build_function_type (TREE_TYPE (function_type), nargs); 2054 2055 /* Copy exceptions, attributes and whatnot. */ 2056 result = build_exception_variant (result, 2057 TYPE_RAISES_EXCEPTIONS (function_type)); 2058 result = cp_build_type_attribute_variant (result, 2059 TYPE_ATTRIBUTES (function_type)); 2060 2061 plugin_context *ctx = static_cast<plugin_context *> (self); 2062 return convert_out (ctx->preserve (result)); 2063 } 2064 2065 int 2066 plugin_set_deferred_function_default_args (cc1_plugin::connection *, 2067 gcc_decl function_in, 2068 const struct gcc_cp_function_args 2069 *defaults) 2070 { 2071 tree function = convert_in (function_in); 2072 2073 gcc_assert (TREE_CODE (function) == FUNCTION_DECL); 2074 2075 if (!defaults || !defaults->n_elements) 2076 return 1; 2077 2078 tree arg = FUNCTION_FIRST_USER_PARMTYPE (function); 2079 2080 for (int i = 0; i < defaults->n_elements; i++) 2081 { 2082 while (arg && TREE_PURPOSE (arg) != error_mark_node) 2083 arg = TREE_CHAIN (arg); 2084 2085 if (!arg) 2086 return 0; 2087 2088 TREE_PURPOSE (arg) = convert_in (defaults->elements[i]); 2089 arg = TREE_CHAIN (arg); 2090 } 2091 2092 return 1; 2093 } 2094 2095 #endif 2096 2097 gcc_decl 2098 plugin_get_function_parameter_decl (cc1_plugin::connection *, 2099 gcc_decl function_in, 2100 int index) 2101 { 2102 tree function = convert_in (function_in); 2103 2104 gcc_assert (TREE_CODE (function) == FUNCTION_DECL); 2105 2106 if (index == -1) 2107 { 2108 gcc_assert (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE); 2109 2110 return convert_out (DECL_ARGUMENTS (function)); 2111 } 2112 2113 gcc_assert (index >= 0); 2114 2115 tree args = FUNCTION_FIRST_USER_PARM (function); 2116 2117 for (int i = 0; args && i < index; i++) 2118 args = DECL_CHAIN (args); 2119 2120 return convert_out (args); 2121 } 2122 2123 gcc_type 2124 plugin_build_exception_spec_variant (cc1_plugin::connection *self, 2125 gcc_type function_type_in, 2126 const struct gcc_type_array *except_types_in) 2127 { 2128 tree function_type = convert_in (function_type_in); 2129 tree except_types = NULL_TREE; 2130 2131 if (!except_types_in) 2132 except_types = noexcept_false_spec; 2133 else if (!except_types_in->n_elements) 2134 except_types = empty_except_spec; 2135 else 2136 for (int i = 0; i < except_types_in->n_elements; i++) 2137 except_types = add_exception_specifier (except_types, 2138 convert_in 2139 (except_types_in->elements[i]), 2140 0); 2141 2142 function_type = build_exception_variant (function_type, 2143 except_types); 2144 2145 plugin_context *ctx = static_cast<plugin_context *> (self); 2146 return convert_out (ctx->preserve (function_type)); 2147 } 2148 2149 gcc_type 2150 plugin_build_method_type (cc1_plugin::connection *self, 2151 gcc_type class_type_in, 2152 gcc_type func_type_in, 2153 enum gcc_cp_qualifiers quals_in, 2154 enum gcc_cp_ref_qualifiers rquals_in) 2155 { 2156 tree class_type = convert_in (class_type_in); 2157 tree func_type = convert_in (func_type_in); 2158 cp_cv_quals quals = 0; 2159 cp_ref_qualifier rquals; 2160 2161 if ((quals_in & GCC_CP_QUALIFIER_CONST) != 0) 2162 quals |= TYPE_QUAL_CONST; 2163 if ((quals_in & GCC_CP_QUALIFIER_VOLATILE) != 0) 2164 quals |= TYPE_QUAL_VOLATILE; 2165 gcc_assert ((quals_in & GCC_CP_QUALIFIER_RESTRICT) == 0); 2166 2167 switch (rquals_in) 2168 { 2169 case GCC_CP_REF_QUAL_NONE: 2170 rquals = REF_QUAL_NONE; 2171 break; 2172 case GCC_CP_REF_QUAL_LVALUE: 2173 rquals = REF_QUAL_LVALUE; 2174 break; 2175 case GCC_CP_REF_QUAL_RVALUE: 2176 rquals = REF_QUAL_RVALUE; 2177 break; 2178 default: 2179 gcc_unreachable (); 2180 } 2181 2182 tree method_type = class_type 2183 ? build_memfn_type (func_type, class_type, quals, rquals) 2184 : apply_memfn_quals (func_type, quals, rquals); 2185 2186 plugin_context *ctx = static_cast<plugin_context *> (self); 2187 return convert_out (ctx->preserve (method_type)); 2188 } 2189 2190 gcc_type 2191 plugin_build_pointer_to_member_type (cc1_plugin::connection *self, 2192 gcc_type class_type_in, 2193 gcc_type member_type_in) 2194 { 2195 tree class_type = convert_in (class_type_in); 2196 tree member_type = convert_in (member_type_in); 2197 2198 tree memptr_type = build_ptrmem_type (class_type, member_type); 2199 2200 plugin_context *ctx = static_cast<plugin_context *> (self); 2201 return convert_out (ctx->preserve (memptr_type)); 2202 } 2203 2204 int 2205 plugin_start_template_decl (cc1_plugin::connection *) 2206 { 2207 begin_template_parm_list (); 2208 2209 TP_PARM_LIST = NULL_TREE; 2210 2211 return 1; 2212 } 2213 2214 gcc_decl 2215 plugin_get_type_decl (cc1_plugin::connection *, 2216 gcc_type type_in) 2217 { 2218 tree type = convert_in (type_in); 2219 2220 tree name = TYPE_NAME (type); 2221 gcc_assert (name); 2222 2223 return convert_out (name); 2224 } 2225 2226 gcc_type 2227 plugin_get_decl_type (cc1_plugin::connection *, 2228 gcc_decl decl_in) 2229 { 2230 tree decl = convert_in (decl_in); 2231 2232 tree type = TREE_TYPE (decl); 2233 gcc_assert (type); 2234 2235 return convert_out (type); 2236 } 2237 2238 gcc_type 2239 plugin_build_type_template_parameter (cc1_plugin::connection *self, 2240 const char *id, 2241 int /* bool */ pack_p, 2242 gcc_type default_type, 2243 const char *filename, 2244 unsigned int line_number) 2245 { 2246 plugin_context *ctx = static_cast<plugin_context *> (self); 2247 source_location loc = ctx->get_source_location (filename, line_number); 2248 2249 gcc_assert (template_parm_scope_p ()); 2250 2251 tree parm = finish_template_type_parm (class_type_node, get_identifier (id)); 2252 parm = build_tree_list (convert_in (default_type), parm); 2253 2254 gcc_assert (!(pack_p && default_type)); 2255 2256 /* Create a type and a decl for the type parm, and add the decl to 2257 TP_PARM_LIST. */ 2258 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm, 2259 /* is_non_type = */ false, pack_p); 2260 2261 /* Locate the decl of the newly-added, processed template parm. */ 2262 parm = TREE_VALUE (tree_last (TP_PARM_LIST)); 2263 2264 /* Return its type. */ 2265 return convert_out (ctx->preserve (TREE_TYPE (parm))); 2266 } 2267 2268 gcc_utempl 2269 plugin_build_template_template_parameter (cc1_plugin::connection *self, 2270 const char *id, 2271 int /* bool */ pack_p, 2272 gcc_utempl default_templ, 2273 const char *filename, 2274 unsigned int line_number) 2275 { 2276 plugin_context *ctx = static_cast<plugin_context *> (self); 2277 source_location loc = ctx->get_source_location (filename, line_number); 2278 2279 gcc_assert (template_parm_scope_p ()); 2280 2281 /* Finish the template parm list that started this template parm. */ 2282 end_template_parm_list (TP_PARM_LIST); 2283 2284 gcc_assert (template_parm_scope_p ()); 2285 2286 tree parm = finish_template_template_parm (class_type_node, 2287 get_identifier (id)); 2288 parm = build_tree_list (convert_in (default_templ), parm); 2289 2290 gcc_assert (!(pack_p && default_templ)); 2291 2292 /* Create a type and a decl for the template parm, and add the decl 2293 to TP_PARM_LIST. */ 2294 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm, 2295 /* is_non_type = */ false, pack_p); 2296 2297 /* Locate the decl of the newly-added, processed template parm. */ 2298 parm = TREE_VALUE (tree_last (TP_PARM_LIST)); 2299 2300 return convert_out (ctx->preserve (parm)); 2301 } 2302 2303 gcc_decl 2304 plugin_build_value_template_parameter (cc1_plugin::connection *self, 2305 gcc_type type, 2306 const char *id, 2307 gcc_expr default_value, 2308 const char *filename, 2309 unsigned int line_number) 2310 { 2311 plugin_context *ctx = static_cast<plugin_context *> (self); 2312 source_location loc = ctx->get_source_location (filename, line_number); 2313 2314 gcc_assert (template_parm_scope_p ()); 2315 2316 cp_declarator declarator; 2317 memset (&declarator, 0, sizeof (declarator)); 2318 // &declarator = make_id_declarator (NULL, get_identifier (id), sfk_none): 2319 declarator.kind = cdk_id; 2320 declarator.u.id.qualifying_scope = NULL; 2321 declarator.u.id.unqualified_name = get_identifier (id); 2322 declarator.u.id.sfk = sfk_none; 2323 2324 cp_decl_specifier_seq declspec; 2325 memset (&declspec, 0, sizeof (declspec)); 2326 // cp_parser_set_decl_spec_type (&declspec, convert_in (type), -token-, false): 2327 declspec.any_specifiers_p = declspec.any_type_specifiers_p = true; 2328 declspec.type = convert_in (type); 2329 declspec.locations[ds_type_spec] = loc; 2330 2331 tree parm = grokdeclarator (&declarator, &declspec, TPARM, 0, 0); 2332 parm = build_tree_list (convert_in (default_value), parm); 2333 2334 /* Create a type and a decl for the template parm, and add the decl 2335 to TP_PARM_LIST. */ 2336 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm, 2337 /* is_non_type = */ true, false); 2338 2339 /* Locate the decl of the newly-added, processed template parm. */ 2340 parm = TREE_VALUE (tree_last (TP_PARM_LIST)); 2341 2342 return convert_out (ctx->preserve (parm)); 2343 } 2344 2345 static tree 2346 targlist (const gcc_cp_template_args *targs) 2347 { 2348 int n = targs->n_elements; 2349 tree vec = make_tree_vec (n); 2350 while (n--) 2351 { 2352 switch (targs->kinds[n]) 2353 { 2354 case GCC_CP_TPARG_VALUE: 2355 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].value); 2356 break; 2357 case GCC_CP_TPARG_CLASS: 2358 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].type); 2359 break; 2360 case GCC_CP_TPARG_TEMPL: 2361 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].templ); 2362 break; 2363 case GCC_CP_TPARG_PACK: 2364 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].pack); 2365 break; 2366 default: 2367 gcc_unreachable (); 2368 } 2369 } 2370 return vec; 2371 } 2372 2373 gcc_type 2374 plugin_build_dependent_typename (cc1_plugin::connection *self, 2375 gcc_type enclosing_type, 2376 const char *id, 2377 const gcc_cp_template_args *targs) 2378 { 2379 plugin_context *ctx = static_cast<plugin_context *> (self); 2380 tree type = convert_in (enclosing_type); 2381 tree name = get_identifier (id); 2382 if (targs) 2383 name = build_min_nt_loc (/*loc=*/0, TEMPLATE_ID_EXPR, 2384 name, targlist (targs)); 2385 tree res = make_typename_type (type, name, typename_type, 2386 /*complain=*/tf_error); 2387 return convert_out (ctx->preserve (res)); 2388 } 2389 2390 gcc_utempl 2391 plugin_build_dependent_class_template (cc1_plugin::connection *self, 2392 gcc_type enclosing_type, 2393 const char *id) 2394 { 2395 plugin_context *ctx = static_cast<plugin_context *> (self); 2396 tree type = convert_in (enclosing_type); 2397 tree name = get_identifier (id); 2398 tree res = make_unbound_class_template (type, name, NULL_TREE, 2399 /*complain=*/tf_error); 2400 return convert_out (ctx->preserve (res)); 2401 } 2402 2403 gcc_type 2404 plugin_build_dependent_type_template_id (cc1_plugin::connection *self, 2405 gcc_utempl template_decl, 2406 const gcc_cp_template_args *targs) 2407 { 2408 plugin_context *ctx = static_cast<plugin_context *> (self); 2409 tree type = convert_in (template_decl); 2410 tree decl = finish_template_type (type, targlist (targs), 2411 /*entering_scope=*/false); 2412 return convert_out (ctx->preserve (TREE_TYPE (decl))); 2413 } 2414 2415 gcc_expr 2416 plugin_build_dependent_expr (cc1_plugin::connection *self, 2417 gcc_decl enclosing_scope, 2418 enum gcc_cp_symbol_kind flags, 2419 const char *name, 2420 gcc_type conv_type_in, 2421 const gcc_cp_template_args *targs) 2422 { 2423 plugin_context *ctx = static_cast<plugin_context *> (self); 2424 tree scope = convert_in (enclosing_scope); 2425 tree conv_type = convert_in (conv_type_in); 2426 tree identifier; 2427 2428 if (TREE_CODE (scope) != NAMESPACE_DECL) 2429 { 2430 tree type = TREE_TYPE (scope); 2431 gcc_assert (TYPE_NAME (type) == scope); 2432 scope = type; 2433 } 2434 2435 if (flags == (GCC_CP_SYMBOL_FUNCTION | GCC_CP_FLAG_SPECIAL_FUNCTION)) 2436 { 2437 bool assop = false, convop = false; 2438 tree_code opcode = ERROR_MARK; 2439 2440 switch (CHARS2 (name[0], name[1])) 2441 { 2442 case CHARS2 ('C', 0x0): // ctor base declaration 2443 case CHARS2 ('C', ' '): 2444 case CHARS2 ('C', '1'): 2445 case CHARS2 ('C', '2'): 2446 case CHARS2 ('C', '4'): 2447 identifier = ctor_identifier; 2448 break; 2449 case CHARS2 ('D', 0x0): // dtor base declaration 2450 case CHARS2 ('D', ' '): 2451 case CHARS2 ('D', '0'): 2452 case CHARS2 ('D', '1'): 2453 case CHARS2 ('D', '2'): 2454 case CHARS2 ('D', '4'): 2455 gcc_assert (!targs); 2456 identifier = dtor_identifier; 2457 break; 2458 case CHARS2 ('n', 'w'): // operator new 2459 opcode = NEW_EXPR; 2460 break; 2461 case CHARS2 ('n', 'a'): // operator new[] 2462 opcode = VEC_NEW_EXPR; 2463 break; 2464 case CHARS2 ('d', 'l'): // operator delete 2465 opcode = DELETE_EXPR; 2466 break; 2467 case CHARS2 ('d', 'a'): // operator delete[] 2468 opcode = VEC_DELETE_EXPR; 2469 break; 2470 case CHARS2 ('p', 's'): // operator + (unary) 2471 opcode = PLUS_EXPR; 2472 break; 2473 case CHARS2 ('n', 'g'): // operator - (unary) 2474 opcode = MINUS_EXPR; 2475 break; 2476 case CHARS2 ('a', 'd'): // operator & (unary) 2477 opcode = BIT_AND_EXPR; 2478 break; 2479 case CHARS2 ('d', 'e'): // operator * (unary) 2480 opcode = MULT_EXPR; 2481 break; 2482 case CHARS2 ('c', 'o'): // operator ~ 2483 opcode = BIT_NOT_EXPR; 2484 break; 2485 case CHARS2 ('p', 'l'): // operator + 2486 opcode = PLUS_EXPR; 2487 break; 2488 case CHARS2 ('m', 'i'): // operator - 2489 opcode = MINUS_EXPR; 2490 break; 2491 case CHARS2 ('m', 'l'): // operator * 2492 opcode = MULT_EXPR; 2493 break; 2494 case CHARS2 ('d', 'v'): // operator / 2495 opcode = TRUNC_DIV_EXPR; 2496 break; 2497 case CHARS2 ('r', 'm'): // operator % 2498 opcode = TRUNC_MOD_EXPR; 2499 break; 2500 case CHARS2 ('a', 'n'): // operator & 2501 opcode = BIT_AND_EXPR; 2502 break; 2503 case CHARS2 ('o', 'r'): // operator | 2504 opcode = BIT_IOR_EXPR; 2505 break; 2506 case CHARS2 ('e', 'o'): // operator ^ 2507 opcode = BIT_XOR_EXPR; 2508 break; 2509 case CHARS2 ('a', 'S'): // operator = 2510 opcode = NOP_EXPR; 2511 assop = true; 2512 break; 2513 case CHARS2 ('p', 'L'): // operator += 2514 opcode = PLUS_EXPR; 2515 assop = true; 2516 break; 2517 case CHARS2 ('m', 'I'): // operator -= 2518 opcode = MINUS_EXPR; 2519 assop = true; 2520 break; 2521 case CHARS2 ('m', 'L'): // operator *= 2522 opcode = MULT_EXPR; 2523 assop = true; 2524 break; 2525 case CHARS2 ('d', 'V'): // operator /= 2526 opcode = TRUNC_DIV_EXPR; 2527 assop = true; 2528 break; 2529 case CHARS2 ('r', 'M'): // operator %= 2530 opcode = TRUNC_MOD_EXPR; 2531 assop = true; 2532 break; 2533 case CHARS2 ('a', 'N'): // operator &= 2534 opcode = BIT_AND_EXPR; 2535 assop = true; 2536 break; 2537 case CHARS2 ('o', 'R'): // operator |= 2538 opcode = BIT_IOR_EXPR; 2539 assop = true; 2540 break; 2541 case CHARS2 ('e', 'O'): // operator ^= 2542 opcode = BIT_XOR_EXPR; 2543 assop = true; 2544 break; 2545 case CHARS2 ('l', 's'): // operator << 2546 opcode = LSHIFT_EXPR; 2547 break; 2548 case CHARS2 ('r', 's'): // operator >> 2549 opcode = RSHIFT_EXPR; 2550 break; 2551 case CHARS2 ('l', 'S'): // operator <<= 2552 opcode = LSHIFT_EXPR; 2553 assop = true; 2554 break; 2555 case CHARS2 ('r', 'S'): // operator >>= 2556 opcode = RSHIFT_EXPR; 2557 assop = true; 2558 break; 2559 case CHARS2 ('e', 'q'): // operator == 2560 opcode = EQ_EXPR; 2561 break; 2562 case CHARS2 ('n', 'e'): // operator != 2563 opcode = NE_EXPR; 2564 break; 2565 case CHARS2 ('l', 't'): // operator < 2566 opcode = LT_EXPR; 2567 break; 2568 case CHARS2 ('g', 't'): // operator > 2569 opcode = GT_EXPR; 2570 break; 2571 case CHARS2 ('l', 'e'): // operator <= 2572 opcode = LE_EXPR; 2573 break; 2574 case CHARS2 ('g', 'e'): // operator >= 2575 opcode = GE_EXPR; 2576 break; 2577 case CHARS2 ('n', 't'): // operator ! 2578 opcode = TRUTH_NOT_EXPR; 2579 break; 2580 case CHARS2 ('a', 'a'): // operator && 2581 opcode = TRUTH_ANDIF_EXPR; 2582 break; 2583 case CHARS2 ('o', 'o'): // operator || 2584 opcode = TRUTH_ORIF_EXPR; 2585 break; 2586 case CHARS2 ('p', 'p'): // operator ++ 2587 opcode = POSTINCREMENT_EXPR; 2588 break; 2589 case CHARS2 ('m', 'm'): // operator -- 2590 opcode = PREDECREMENT_EXPR; 2591 break; 2592 case CHARS2 ('c', 'm'): // operator , 2593 opcode = COMPOUND_EXPR; 2594 break; 2595 case CHARS2 ('p', 'm'): // operator ->* 2596 opcode = MEMBER_REF; 2597 break; 2598 case CHARS2 ('p', 't'): // operator -> 2599 opcode = COMPONENT_REF; 2600 break; 2601 case CHARS2 ('c', 'l'): // operator () 2602 opcode = CALL_EXPR; 2603 break; 2604 case CHARS2 ('i', 'x'): // operator [] 2605 opcode = ARRAY_REF; 2606 break; 2607 case CHARS2 ('c', 'v'): // operator <T> (conversion operator) 2608 convop = true; 2609 identifier = make_conv_op_name (conv_type); 2610 break; 2611 // C++11-only: 2612 case CHARS2 ('l', 'i'): // operator "" <id> 2613 { 2614 char *id = (char *)name + 2; 2615 bool freeid = false; 2616 if (*id >= '0' && *id <= '9') 2617 { 2618 unsigned len = 0; 2619 do 2620 { 2621 len *= 10; 2622 len += id[0] - '0'; 2623 id++; 2624 } 2625 while (*id && *id >= '0' && *id <= '9'); 2626 id = xstrndup (id, len); 2627 freeid = true; 2628 } 2629 identifier = cp_literal_operator_id (id); 2630 if (freeid) 2631 free (id); 2632 } 2633 break; 2634 case CHARS2 ('q', 'u'): // ternary operator, not overloadable. 2635 default: 2636 gcc_unreachable (); 2637 } 2638 2639 gcc_assert (convop || !conv_type); 2640 2641 if (opcode != ERROR_MARK) 2642 identifier = ovl_op_identifier (assop, opcode); 2643 2644 gcc_assert (identifier); 2645 } 2646 else 2647 { 2648 gcc_assert (flags == GCC_CP_SYMBOL_MASK); 2649 gcc_assert (!conv_type); 2650 identifier = get_identifier (name); 2651 } 2652 tree res = identifier; 2653 if (!scope) 2654 res = lookup_name_real (res, 0, 0, true, 0, 0); 2655 else if (!TYPE_P (scope) || !dependent_scope_p (scope)) 2656 { 2657 res = lookup_qualified_name (scope, res, false, true); 2658 /* We've already resolved the name in the scope, so skip the 2659 build_qualified_name call below. */ 2660 scope = NULL; 2661 } 2662 if (targs) 2663 res = lookup_template_function (res, targlist (targs)); 2664 if (scope) 2665 res = build_qualified_name (NULL_TREE, scope, res, !!targs); 2666 return convert_out (ctx->preserve (res)); 2667 } 2668 2669 gcc_expr 2670 plugin_build_literal_expr (cc1_plugin::connection *self, 2671 gcc_type type, unsigned long value) 2672 { 2673 plugin_context *ctx = static_cast<plugin_context *> (self); 2674 tree t = convert_in (type); 2675 tree val = build_int_cst_type (t, (unsigned HOST_WIDE_INT) value); 2676 return convert_out (ctx->preserve (val)); 2677 } 2678 2679 gcc_expr 2680 plugin_build_decl_expr (cc1_plugin::connection *self, 2681 gcc_decl decl_in, 2682 int qualified_p) 2683 { 2684 plugin_context *ctx = static_cast<plugin_context *> (self); 2685 tree decl = convert_in (decl_in); 2686 gcc_assert (DECL_P (decl)); 2687 tree result = decl; 2688 if (qualified_p) 2689 { 2690 gcc_assert (DECL_CLASS_SCOPE_P (decl)); 2691 result = build_offset_ref (DECL_CONTEXT (decl), decl, 2692 /*address_p=*/true, tf_error); 2693 } 2694 return convert_out (ctx->preserve (result)); 2695 } 2696 2697 gcc_expr 2698 plugin_build_unary_expr (cc1_plugin::connection *self, 2699 const char *unary_op, 2700 gcc_expr operand) 2701 { 2702 plugin_context *ctx = static_cast<plugin_context *> (self); 2703 tree op0 = convert_in (operand); 2704 tree_code opcode = ERROR_MARK; 2705 bool global_scope_p = false; 2706 2707 once_more: 2708 switch (CHARS2 (unary_op[0], unary_op[1])) 2709 { 2710 case CHARS2 ('p', 's'): // operator + (unary) 2711 opcode = UNARY_PLUS_EXPR; 2712 break; 2713 case CHARS2 ('n', 'g'): // operator - (unary) 2714 opcode = NEGATE_EXPR; 2715 break; 2716 case CHARS2 ('a', 'd'): // operator & (unary) 2717 opcode = ADDR_EXPR; 2718 break; 2719 case CHARS2 ('d', 'e'): // operator * (unary) 2720 opcode = INDIRECT_REF; 2721 break; 2722 case CHARS2 ('c', 'o'): // operator ~ 2723 opcode = BIT_NOT_EXPR; 2724 break; 2725 case CHARS2 ('n', 't'): // operator ! 2726 opcode = TRUTH_NOT_EXPR; 2727 break; 2728 case CHARS2 ('p', 'p'): // operator ++ 2729 opcode = unary_op[2] == '_' ? PREINCREMENT_EXPR : POSTINCREMENT_EXPR; 2730 break; 2731 case CHARS2 ('m', 'm'): // operator -- 2732 opcode = unary_op[2] == '_' ? PREDECREMENT_EXPR : POSTDECREMENT_EXPR; 2733 break; 2734 case CHARS2 ('n', 'x'): // noexcept 2735 opcode = NOEXCEPT_EXPR; 2736 break; 2737 case CHARS2 ('t', 'w'): // throw 2738 gcc_assert (op0); 2739 opcode = THROW_EXPR; 2740 break; 2741 case CHARS2 ('t', 'r'): // rethrow 2742 gcc_assert (!op0); 2743 opcode = THROW_EXPR; 2744 break; 2745 case CHARS2 ('t', 'e'): // typeid (value) 2746 opcode = TYPEID_EXPR; 2747 break; 2748 case CHARS2 ('s', 'z'): // sizeof (value) 2749 opcode = SIZEOF_EXPR; 2750 break; 2751 case CHARS2 ('a', 'z'): // alignof (value) 2752 opcode = ALIGNOF_EXPR; 2753 break; 2754 case CHARS2 ('g', 's'): // global scope (for delete, delete[]) 2755 gcc_assert (!global_scope_p); 2756 global_scope_p = true; 2757 unary_op += 2; 2758 goto once_more; 2759 case CHARS2 ('d', 'l'): // delete 2760 opcode = DELETE_EXPR; 2761 break; 2762 case CHARS2 ('d', 'a'): // delete[] 2763 opcode = VEC_DELETE_EXPR; 2764 break; 2765 case CHARS2 ('s', 'p'): // pack... 2766 opcode = EXPR_PACK_EXPANSION; 2767 break; 2768 case CHARS2 ('s', 'Z'): // sizeof...(pack) 2769 opcode = TYPE_PACK_EXPANSION; // Not really, but let's use its code. 2770 break; 2771 2772 /* FIXME: __real__, __imag__? */ 2773 2774 default: 2775 gcc_unreachable (); 2776 } 2777 2778 gcc_assert (!global_scope_p 2779 || opcode == DELETE_EXPR || opcode == VEC_DELETE_EXPR); 2780 2781 processing_template_decl++; 2782 bool template_dependent_p = op0 2783 && (type_dependent_expression_p (op0) 2784 || value_dependent_expression_p (op0)); 2785 if (!template_dependent_p) 2786 processing_template_decl--; 2787 2788 tree result; 2789 2790 gcc_assert (op0 || opcode == THROW_EXPR); 2791 2792 switch (opcode) 2793 { 2794 case NOEXCEPT_EXPR: 2795 result = finish_noexcept_expr (op0, tf_error); 2796 break; 2797 2798 case THROW_EXPR: 2799 result = build_throw (op0); 2800 break; 2801 2802 case TYPEID_EXPR: 2803 result = build_typeid (op0, tf_error); 2804 break; 2805 2806 case SIZEOF_EXPR: 2807 case ALIGNOF_EXPR: 2808 result = cxx_sizeof_or_alignof_expr (op0, opcode, true); 2809 break; 2810 2811 case DELETE_EXPR: 2812 case VEC_DELETE_EXPR: 2813 result = delete_sanity (op0, NULL_TREE, opcode == VEC_DELETE_EXPR, 2814 global_scope_p, tf_error); 2815 break; 2816 2817 case EXPR_PACK_EXPANSION: 2818 result = make_pack_expansion (op0); 2819 break; 2820 2821 // We're using this for sizeof...(pack). */ 2822 case TYPE_PACK_EXPANSION: 2823 result = make_pack_expansion (op0); 2824 PACK_EXPANSION_SIZEOF_P (result) = true; 2825 break; 2826 2827 default: 2828 result = build_x_unary_op (/*loc=*/0, opcode, op0, tf_error); 2829 break; 2830 } 2831 2832 if (template_dependent_p) 2833 processing_template_decl--; 2834 2835 return convert_out (ctx->preserve (result)); 2836 } 2837 2838 gcc_expr 2839 plugin_build_binary_expr (cc1_plugin::connection *self, 2840 const char *binary_op, 2841 gcc_expr operand1, 2842 gcc_expr operand2) 2843 { 2844 plugin_context *ctx = static_cast<plugin_context *> (self); 2845 tree op0 = convert_in (operand1); 2846 tree op1 = convert_in (operand2); 2847 tree_code opcode = ERROR_MARK; 2848 2849 switch (CHARS2 (binary_op[0], binary_op[1])) 2850 { 2851 case CHARS2 ('p', 'l'): // operator + 2852 opcode = PLUS_EXPR; 2853 break; 2854 case CHARS2 ('m', 'i'): // operator - 2855 opcode = MINUS_EXPR; 2856 break; 2857 case CHARS2 ('m', 'l'): // operator * 2858 opcode = MULT_EXPR; 2859 break; 2860 case CHARS2 ('d', 'v'): // operator / 2861 opcode = TRUNC_DIV_EXPR; 2862 break; 2863 case CHARS2 ('r', 'm'): // operator % 2864 opcode = TRUNC_MOD_EXPR; 2865 break; 2866 case CHARS2 ('a', 'n'): // operator & 2867 opcode = BIT_AND_EXPR; 2868 break; 2869 case CHARS2 ('o', 'r'): // operator | 2870 opcode = BIT_IOR_EXPR; 2871 break; 2872 case CHARS2 ('e', 'o'): // operator ^ 2873 opcode = BIT_XOR_EXPR; 2874 break; 2875 case CHARS2 ('l', 's'): // operator << 2876 opcode = LSHIFT_EXPR; 2877 break; 2878 case CHARS2 ('r', 's'): // operator >> 2879 opcode = RSHIFT_EXPR; 2880 break; 2881 case CHARS2 ('e', 'q'): // operator == 2882 opcode = EQ_EXPR; 2883 break; 2884 case CHARS2 ('n', 'e'): // operator != 2885 opcode = NE_EXPR; 2886 break; 2887 case CHARS2 ('l', 't'): // operator < 2888 opcode = LT_EXPR; 2889 break; 2890 case CHARS2 ('g', 't'): // operator > 2891 opcode = GT_EXPR; 2892 break; 2893 case CHARS2 ('l', 'e'): // operator <= 2894 opcode = LE_EXPR; 2895 break; 2896 case CHARS2 ('g', 'e'): // operator >= 2897 opcode = GE_EXPR; 2898 break; 2899 case CHARS2 ('a', 'a'): // operator && 2900 opcode = TRUTH_ANDIF_EXPR; 2901 break; 2902 case CHARS2 ('o', 'o'): // operator || 2903 opcode = TRUTH_ORIF_EXPR; 2904 break; 2905 case CHARS2 ('c', 'm'): // operator , 2906 opcode = COMPOUND_EXPR; 2907 break; 2908 case CHARS2 ('p', 'm'): // operator ->* 2909 opcode = MEMBER_REF; 2910 break; 2911 case CHARS2 ('p', 't'): // operator -> 2912 opcode = INDIRECT_REF; // Not really! This will stand for 2913 // INDIRECT_REF followed by COMPONENT_REF 2914 // later on. 2915 break; 2916 case CHARS2 ('i', 'x'): // operator [] 2917 opcode = ARRAY_REF; 2918 break; 2919 case CHARS2 ('d', 's'): // operator .* 2920 opcode = DOTSTAR_EXPR; 2921 break; 2922 case CHARS2 ('d', 't'): // operator . 2923 opcode = COMPONENT_REF; 2924 break; 2925 2926 default: 2927 gcc_unreachable (); 2928 } 2929 2930 processing_template_decl++; 2931 bool template_dependent_p = type_dependent_expression_p (op0) 2932 || value_dependent_expression_p (op0) 2933 || type_dependent_expression_p (op1) 2934 || value_dependent_expression_p (op1); 2935 if (!template_dependent_p) 2936 processing_template_decl--; 2937 2938 tree result; 2939 2940 switch (opcode) 2941 { 2942 case INDIRECT_REF: // This is actually a "->". 2943 op0 = build_x_arrow (/*loc=*/0, op0, tf_error); 2944 /* Fall through. */ 2945 case COMPONENT_REF: 2946 result = finish_class_member_access_expr (op0, op1, 2947 /*template_p=*/false, 2948 tf_error); 2949 break; 2950 2951 default: 2952 result = build_x_binary_op (/*loc=*/0, opcode, op0, ERROR_MARK, 2953 op1, ERROR_MARK, NULL, tf_error); 2954 break; 2955 } 2956 2957 if (template_dependent_p) 2958 processing_template_decl--; 2959 2960 return convert_out (ctx->preserve (result)); 2961 } 2962 2963 gcc_expr 2964 plugin_build_ternary_expr (cc1_plugin::connection *self, 2965 const char *ternary_op, 2966 gcc_expr operand1, 2967 gcc_expr operand2, 2968 gcc_expr operand3) 2969 { 2970 plugin_context *ctx = static_cast<plugin_context *> (self); 2971 tree op0 = convert_in (operand1); 2972 tree op1 = convert_in (operand2); 2973 tree op2 = convert_in (operand3); 2974 gcc_assert (CHARS2 (ternary_op[0], ternary_op[1]) 2975 == CHARS2 ('q', 'u')); // ternary operator 2976 2977 processing_template_decl++; 2978 bool template_dependent_p = type_dependent_expression_p (op0) 2979 || value_dependent_expression_p (op0) 2980 || type_dependent_expression_p (op1) 2981 || value_dependent_expression_p (op1) 2982 || type_dependent_expression_p (op2) 2983 || value_dependent_expression_p (op2); 2984 if (!template_dependent_p) 2985 processing_template_decl--; 2986 2987 tree val = build_x_conditional_expr (/*loc=*/0, op0, op1, op2, tf_error); 2988 2989 if (template_dependent_p) 2990 processing_template_decl--; 2991 2992 return convert_out (ctx->preserve (val)); 2993 } 2994 2995 gcc_expr 2996 plugin_build_unary_type_expr (cc1_plugin::connection *self, 2997 const char *unary_op, 2998 gcc_type operand) 2999 { 3000 plugin_context *ctx = static_cast<plugin_context *> (self); 3001 tree type = convert_in (operand); 3002 tree_code opcode = ERROR_MARK; 3003 3004 switch (CHARS2 (unary_op[0], unary_op[1])) 3005 { 3006 case CHARS2 ('t', 'i'): // typeid (type) 3007 opcode = TYPEID_EXPR; 3008 break; 3009 3010 case CHARS2 ('s', 't'): // sizeof (type) 3011 opcode = SIZEOF_EXPR; 3012 break; 3013 case CHARS2 ('a', 't'): // alignof (type) 3014 opcode = ALIGNOF_EXPR; 3015 break; 3016 3017 case CHARS2 ('s', 'Z'): // sizeof...(pack) 3018 opcode = TYPE_PACK_EXPANSION; // Not really, but let's use its code. 3019 break; 3020 3021 // FIXME: do we have to handle "sp", for the size of a captured 3022 // template parameter pack from an alias template, taking 3023 // multiple template arguments? 3024 3025 default: 3026 gcc_unreachable (); 3027 } 3028 3029 processing_template_decl++; 3030 bool template_dependent_p = dependent_type_p (type); 3031 if (!template_dependent_p) 3032 processing_template_decl--; 3033 3034 tree result; 3035 3036 switch (opcode) 3037 { 3038 case TYPEID_EXPR: 3039 result = get_typeid (type, tf_error); 3040 break; 3041 3042 // We're using this for sizeof...(pack). */ 3043 case TYPE_PACK_EXPANSION: 3044 result = make_pack_expansion (type); 3045 PACK_EXPANSION_SIZEOF_P (result) = true; 3046 break; 3047 3048 default: 3049 /* Use the C++11 alignof semantics. */ 3050 result = cxx_sizeof_or_alignof_type (type, opcode, true, true); 3051 } 3052 3053 if (template_dependent_p) 3054 processing_template_decl--; 3055 3056 return convert_out (ctx->preserve (result)); 3057 } 3058 3059 gcc_expr 3060 plugin_build_cast_expr (cc1_plugin::connection *self, 3061 const char *binary_op, 3062 gcc_type operand1, 3063 gcc_expr operand2) 3064 { 3065 plugin_context *ctx = static_cast<plugin_context *> (self); 3066 tree (*build_cast)(tree type, tree expr, tsubst_flags_t complain) = NULL; 3067 tree type = convert_in (operand1); 3068 tree expr = convert_in (operand2); 3069 3070 switch (CHARS2 (binary_op[0], binary_op[1])) 3071 { 3072 case CHARS2 ('d', 'c'): // dynamic_cast 3073 build_cast = build_dynamic_cast; 3074 break; 3075 3076 case CHARS2 ('s', 'c'): // static_cast 3077 build_cast = build_static_cast; 3078 break; 3079 3080 case CHARS2 ('c', 'c'): // const_cast 3081 build_cast = build_const_cast; 3082 break; 3083 3084 case CHARS2 ('r', 'c'): // reinterpret_cast 3085 build_cast = build_reinterpret_cast; 3086 break; 3087 3088 case CHARS2 ('c', 'v'): // C cast, conversion with one argument 3089 build_cast = cp_build_c_cast; 3090 break; 3091 3092 default: 3093 gcc_unreachable (); 3094 } 3095 3096 processing_template_decl++; 3097 bool template_dependent_p = dependent_type_p (type) 3098 || type_dependent_expression_p (expr) 3099 || value_dependent_expression_p (expr); 3100 if (!template_dependent_p) 3101 processing_template_decl--; 3102 3103 tree val = build_cast (type, expr, tf_error); 3104 3105 if (template_dependent_p) 3106 processing_template_decl--; 3107 3108 return convert_out (ctx->preserve (val)); 3109 } 3110 3111 static inline vec<tree, va_gc> * 3112 args_to_tree_vec (const struct gcc_cp_function_args *args_in) 3113 { 3114 vec<tree, va_gc> *args = make_tree_vector (); 3115 for (int i = 0; i < args_in->n_elements; i++) 3116 vec_safe_push (args, convert_in (args_in->elements[i])); 3117 return args; 3118 } 3119 3120 static inline tree 3121 args_to_tree_list (const struct gcc_cp_function_args *args_in) 3122 { 3123 tree args, *tail = &args; 3124 for (int i = 0; i < args_in->n_elements; i++) 3125 { 3126 *tail = build_tree_list (NULL, convert_in (args_in->elements[i])); 3127 tail = &TREE_CHAIN (*tail); 3128 } 3129 return args; 3130 } 3131 3132 static inline vec<constructor_elt, va_gc> * 3133 args_to_ctor_elts (const struct gcc_cp_function_args *args_in) 3134 { 3135 vec<constructor_elt, va_gc> *args = NULL; 3136 for (int i = 0; i < args_in->n_elements; i++) 3137 CONSTRUCTOR_APPEND_ELT (args, NULL_TREE, convert_in (args_in->elements[i])); 3138 return args; 3139 } 3140 3141 gcc_expr 3142 plugin_build_expression_list_expr (cc1_plugin::connection *self, 3143 const char *conv_op, 3144 gcc_type type_in, 3145 const struct gcc_cp_function_args *values_in) 3146 { 3147 plugin_context *ctx = static_cast<plugin_context *> (self); 3148 tree type = convert_in (type_in); 3149 tree args; 3150 tree result; 3151 3152 switch (CHARS2 (conv_op[0], conv_op[1])) 3153 { 3154 case CHARS2 ('c', 'v'): // conversion with parenthesized expression list 3155 gcc_assert (TYPE_P (type)); 3156 args = args_to_tree_list (values_in); 3157 result = build_functional_cast (type, args, tf_error); 3158 break; 3159 3160 case CHARS2 ('t', 'l'): // conversion with braced expression list 3161 gcc_assert (type); 3162 gcc_assert (TYPE_P (type)); 3163 args = make_node (CONSTRUCTOR); 3164 CONSTRUCTOR_ELTS (args) = args_to_ctor_elts (values_in); 3165 CONSTRUCTOR_IS_DIRECT_INIT (args) = 1; 3166 result = finish_compound_literal (type, args, tf_error); 3167 break; 3168 3169 case CHARS2 ('i', 'l'): // untyped braced expression list 3170 gcc_assert (!type); 3171 result = make_node (CONSTRUCTOR); 3172 CONSTRUCTOR_ELTS (result) = args_to_ctor_elts (values_in); 3173 break; 3174 3175 default: 3176 gcc_unreachable (); 3177 } 3178 3179 return convert_out (ctx->preserve (result)); 3180 } 3181 3182 gcc_expr 3183 plugin_build_new_expr (cc1_plugin::connection *self, 3184 const char *new_op, 3185 const struct gcc_cp_function_args *placement_in, 3186 gcc_type type_in, 3187 const struct gcc_cp_function_args *initializer_in) 3188 { 3189 plugin_context *ctx = static_cast<plugin_context *> (self); 3190 tree type = convert_in (type_in); 3191 vec<tree, va_gc> *placement = NULL, *initializer = NULL; 3192 bool global_scope_p = false; 3193 tree nelts = NULL; 3194 3195 if (placement_in) 3196 placement = args_to_tree_vec (placement_in); 3197 if (initializer_in) 3198 initializer = args_to_tree_vec (initializer_in); 3199 3200 gcc_assert (TYPE_P (type)); 3201 3202 once_more: 3203 switch (CHARS2 (new_op[0], new_op[1])) 3204 { 3205 case CHARS2 ('g', 's'): 3206 gcc_assert (!global_scope_p); 3207 global_scope_p = true; 3208 new_op += 2; 3209 goto once_more; 3210 3211 case CHARS2 ('n', 'w'): // non-array new 3212 gcc_assert (TREE_CODE (type) != ARRAY_TYPE); 3213 break; 3214 3215 case CHARS2 ('n', 'a'): // array new 3216 gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 3217 gcc_assert (TYPE_DOMAIN (type)); 3218 { 3219 // Compute the length of the outermost array type, then discard it. 3220 tree maxelt = TYPE_MAX_VALUE (TYPE_DOMAIN (type)); 3221 tree eltype = TREE_TYPE (maxelt); 3222 tree onecst = integer_one_node; 3223 3224 processing_template_decl++; 3225 bool template_dependent_p = value_dependent_expression_p (maxelt) 3226 || type_dependent_expression_p (maxelt); 3227 if (!template_dependent_p) 3228 { 3229 processing_template_decl--; 3230 onecst = fold_convert (eltype, onecst); 3231 } 3232 3233 nelts = fold_build2 (PLUS_EXPR, eltype, nelts, onecst); 3234 3235 if (template_dependent_p) 3236 processing_template_decl--; 3237 3238 type = TREE_TYPE (type); 3239 } 3240 break; 3241 3242 default: 3243 gcc_unreachable (); 3244 } 3245 3246 processing_template_decl++; 3247 bool template_dependent_p = dependent_type_p (type) 3248 || value_dependent_expression_p (nelts) 3249 || (placement 3250 && any_type_dependent_arguments_p (placement)) 3251 || (initializer 3252 && any_type_dependent_arguments_p (initializer)); 3253 if (!template_dependent_p) 3254 processing_template_decl--; 3255 3256 tree result = build_new (&placement, type, nelts, &initializer, 3257 global_scope_p, tf_error); 3258 3259 if (template_dependent_p) 3260 processing_template_decl--; 3261 3262 if (placement != NULL) 3263 release_tree_vector (placement); 3264 if (initializer != NULL) 3265 release_tree_vector (initializer); 3266 3267 return convert_out (ctx->preserve (result)); 3268 } 3269 3270 gcc_expr 3271 plugin_build_call_expr (cc1_plugin::connection *self, 3272 gcc_expr callable_in, int qualified_p, 3273 const struct gcc_cp_function_args *args_in) 3274 { 3275 plugin_context *ctx = static_cast<plugin_context *> (self); 3276 tree callable = convert_in (callable_in); 3277 tree call_expr; 3278 3279 vec<tree, va_gc> *args = args_to_tree_vec (args_in); 3280 3281 bool koenig_p = false; 3282 if (!qualified_p && !args->is_empty ()) 3283 { 3284 if (identifier_p (callable)) 3285 koenig_p = true; 3286 else if (is_overloaded_fn (callable)) 3287 { 3288 tree fn = get_first_fn (callable); 3289 fn = STRIP_TEMPLATE (fn); 3290 3291 if (!DECL_FUNCTION_MEMBER_P (fn) 3292 && !DECL_LOCAL_FUNCTION_P (fn)) 3293 koenig_p = true; 3294 } 3295 } 3296 3297 if (koenig_p && !any_type_dependent_arguments_p (args)) 3298 callable = perform_koenig_lookup (callable, args, tf_none); 3299 3300 if (TREE_CODE (callable) == COMPONENT_REF) 3301 { 3302 tree object = TREE_OPERAND (callable, 0); 3303 tree memfn = TREE_OPERAND (callable, 1); 3304 3305 if (type_dependent_expression_p (object) 3306 || (!BASELINK_P (memfn) && TREE_CODE (memfn) != FIELD_DECL) 3307 || type_dependent_expression_p (memfn) 3308 || any_type_dependent_arguments_p (args)) 3309 call_expr = build_nt_call_vec (callable, args); 3310 else if (BASELINK_P (memfn)) 3311 call_expr = build_new_method_call (object, memfn, &args, NULL_TREE, 3312 qualified_p 3313 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL 3314 : LOOKUP_NORMAL, 3315 NULL, tf_none); 3316 else 3317 call_expr = finish_call_expr (callable, &args, false, false, tf_none); 3318 } 3319 else if (TREE_CODE (callable) == OFFSET_REF 3320 || TREE_CODE (callable) == MEMBER_REF 3321 || TREE_CODE (callable) == DOTSTAR_EXPR) 3322 call_expr = build_offset_ref_call_from_tree (callable, &args, tf_none); 3323 else 3324 call_expr = finish_call_expr (callable, &args, 3325 !!qualified_p, koenig_p, tf_none); 3326 3327 release_tree_vector (args); 3328 return convert_out (ctx->preserve (call_expr)); 3329 } 3330 3331 gcc_type 3332 plugin_get_expr_type (cc1_plugin::connection *self, 3333 gcc_expr operand) 3334 { 3335 plugin_context *ctx = static_cast<plugin_context *> (self); 3336 tree op0 = convert_in (operand); 3337 tree type; 3338 if (op0) 3339 type = TREE_TYPE (op0); 3340 else 3341 { 3342 type = make_decltype_auto (); 3343 AUTO_IS_DECLTYPE (type) = true; 3344 } 3345 return convert_out (ctx->preserve (type)); 3346 } 3347 3348 gcc_decl 3349 plugin_build_function_template_specialization (cc1_plugin::connection *self, 3350 gcc_decl template_decl, 3351 const gcc_cp_template_args *targs, 3352 gcc_address address, 3353 const char *filename, 3354 unsigned int line_number) 3355 { 3356 plugin_context *ctx = static_cast<plugin_context *> (self); 3357 source_location loc = ctx->get_source_location (filename, line_number); 3358 tree name = convert_in (template_decl); 3359 tree targsl = targlist (targs); 3360 3361 tree decl = tsubst (name, targsl, tf_error, NULL_TREE); 3362 DECL_SOURCE_LOCATION (decl) = loc; 3363 3364 record_decl_address (ctx, build_decl_addr_value (decl, address)); 3365 3366 return convert_out (ctx->preserve (decl)); 3367 } 3368 3369 gcc_decl 3370 plugin_build_class_template_specialization (cc1_plugin::connection *self, 3371 gcc_decl template_decl, 3372 const gcc_cp_template_args *args, 3373 const char *filename, 3374 unsigned int line_number) 3375 { 3376 plugin_context *ctx = static_cast<plugin_context *> (self); 3377 source_location loc = ctx->get_source_location (filename, line_number); 3378 tree name = convert_in (template_decl); 3379 3380 tree tdecl = finish_template_type (name, targlist (args), false);; 3381 DECL_SOURCE_LOCATION (tdecl) = loc; 3382 3383 return convert_out (ctx->preserve (tdecl)); 3384 } 3385 3386 /* Return a builtin type associated with BUILTIN_NAME. */ 3387 3388 static tree 3389 safe_lookup_builtin_type (const char *builtin_name) 3390 { 3391 tree result = NULL_TREE; 3392 3393 if (!builtin_name) 3394 return result; 3395 3396 result = identifier_global_value (get_identifier (builtin_name)); 3397 3398 if (!result) 3399 return result; 3400 3401 gcc_assert (TREE_CODE (result) == TYPE_DECL); 3402 result = TREE_TYPE (result); 3403 return result; 3404 } 3405 3406 gcc_type 3407 plugin_get_int_type (cc1_plugin::connection *self, 3408 int is_unsigned, unsigned long size_in_bytes, 3409 const char *builtin_name) 3410 { 3411 tree result; 3412 3413 if (builtin_name) 3414 { 3415 result = safe_lookup_builtin_type (builtin_name); 3416 gcc_assert (!result || TREE_CODE (result) == INTEGER_TYPE); 3417 } 3418 else 3419 result = c_common_type_for_size (BITS_PER_UNIT * size_in_bytes, 3420 is_unsigned); 3421 3422 if (result == NULL_TREE) 3423 result = error_mark_node; 3424 else 3425 { 3426 gcc_assert (!TYPE_UNSIGNED (result) == !is_unsigned); 3427 gcc_assert (TREE_CODE (TYPE_SIZE (result)) == INTEGER_CST); 3428 gcc_assert (TYPE_PRECISION (result) == BITS_PER_UNIT * size_in_bytes); 3429 3430 plugin_context *ctx = static_cast<plugin_context *> (self); 3431 ctx->preserve (result); 3432 } 3433 return convert_out (result); 3434 } 3435 3436 gcc_type 3437 plugin_get_char_type (cc1_plugin::connection *) 3438 { 3439 return convert_out (char_type_node); 3440 } 3441 3442 gcc_type 3443 plugin_get_float_type (cc1_plugin::connection *, 3444 unsigned long size_in_bytes, 3445 const char *builtin_name) 3446 { 3447 if (builtin_name) 3448 { 3449 tree result = safe_lookup_builtin_type (builtin_name); 3450 3451 if (!result) 3452 return convert_out (error_mark_node); 3453 3454 gcc_assert (TREE_CODE (result) == REAL_TYPE); 3455 gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result)); 3456 3457 return convert_out (result); 3458 } 3459 3460 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (float_type_node)) 3461 return convert_out (float_type_node); 3462 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (double_type_node)) 3463 return convert_out (double_type_node); 3464 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (long_double_type_node)) 3465 return convert_out (long_double_type_node); 3466 return convert_out (error_mark_node); 3467 } 3468 3469 gcc_type 3470 plugin_get_void_type (cc1_plugin::connection *) 3471 { 3472 return convert_out (void_type_node); 3473 } 3474 3475 gcc_type 3476 plugin_get_bool_type (cc1_plugin::connection *) 3477 { 3478 return convert_out (boolean_type_node); 3479 } 3480 3481 gcc_type 3482 plugin_get_nullptr_type (cc1_plugin::connection *) 3483 { 3484 return convert_out (nullptr_type_node); 3485 } 3486 3487 gcc_expr 3488 plugin_get_nullptr_constant (cc1_plugin::connection *) 3489 { 3490 return convert_out (nullptr_node); 3491 } 3492 3493 gcc_type 3494 plugin_build_array_type (cc1_plugin::connection *self, 3495 gcc_type element_type_in, int num_elements) 3496 { 3497 tree element_type = convert_in (element_type_in); 3498 tree result; 3499 3500 if (num_elements == -1) 3501 result = build_array_type (element_type, NULL_TREE); 3502 else 3503 result = build_array_type_nelts (element_type, num_elements); 3504 3505 plugin_context *ctx = static_cast<plugin_context *> (self); 3506 return convert_out (ctx->preserve (result)); 3507 } 3508 3509 gcc_type 3510 plugin_build_dependent_array_type (cc1_plugin::connection *self, 3511 gcc_type element_type_in, 3512 gcc_expr num_elements_in) 3513 { 3514 plugin_context *ctx = static_cast<plugin_context *> (self); 3515 tree element_type = convert_in (element_type_in); 3516 tree size = convert_in (num_elements_in); 3517 tree name = get_identifier ("dependent array type"); 3518 3519 processing_template_decl++; 3520 bool template_dependent_p = dependent_type_p (element_type) 3521 || type_dependent_expression_p (size) 3522 || value_dependent_expression_p (size); 3523 if (!template_dependent_p) 3524 processing_template_decl--; 3525 3526 tree itype = compute_array_index_type (name, size, tf_error); 3527 tree type = build_cplus_array_type (element_type, itype); 3528 3529 if (template_dependent_p) 3530 processing_template_decl--; 3531 3532 return convert_out (ctx->preserve (type)); 3533 } 3534 3535 gcc_type 3536 plugin_build_vla_array_type (cc1_plugin::connection *self, 3537 gcc_type element_type_in, 3538 const char *upper_bound_name) 3539 { 3540 tree element_type = convert_in (element_type_in); 3541 tree upper_bound = lookup_name (get_identifier (upper_bound_name)); 3542 tree size = fold_build2 (PLUS_EXPR, TREE_TYPE (upper_bound), upper_bound, 3543 build_one_cst (TREE_TYPE (upper_bound))); 3544 tree range = compute_array_index_type (NULL_TREE, size, 3545 tf_error); 3546 3547 tree result = build_cplus_array_type (element_type, range); 3548 3549 plugin_context *ctx = static_cast<plugin_context *> (self); 3550 return convert_out (ctx->preserve (result)); 3551 } 3552 3553 gcc_type 3554 plugin_build_qualified_type (cc1_plugin::connection *, 3555 gcc_type unqualified_type_in, 3556 enum gcc_cp_qualifiers qualifiers) 3557 { 3558 tree unqualified_type = convert_in (unqualified_type_in); 3559 cp_cv_quals quals = 0; 3560 3561 if ((qualifiers & GCC_CP_QUALIFIER_CONST) != 0) 3562 quals |= TYPE_QUAL_CONST; 3563 if ((qualifiers & GCC_CP_QUALIFIER_VOLATILE) != 0) 3564 quals |= TYPE_QUAL_VOLATILE; 3565 if ((qualifiers & GCC_CP_QUALIFIER_RESTRICT) != 0) 3566 quals |= TYPE_QUAL_RESTRICT; 3567 3568 gcc_assert ((TREE_CODE (unqualified_type) != METHOD_TYPE 3569 && TREE_CODE (unqualified_type) != REFERENCE_TYPE) 3570 || quals == 0); 3571 3572 return convert_out (build_qualified_type (unqualified_type, quals)); 3573 } 3574 3575 gcc_type 3576 plugin_build_complex_type (cc1_plugin::connection *self, 3577 gcc_type base_type) 3578 { 3579 plugin_context *ctx = static_cast<plugin_context *> (self); 3580 return convert_out (ctx->preserve (build_complex_type (convert_in (base_type)))); 3581 } 3582 3583 gcc_type 3584 plugin_build_vector_type (cc1_plugin::connection *self, 3585 gcc_type base_type, int nunits) 3586 { 3587 plugin_context *ctx = static_cast<plugin_context *> (self); 3588 return convert_out (ctx->preserve (build_vector_type (convert_in (base_type), 3589 nunits))); 3590 } 3591 3592 int 3593 plugin_build_constant (cc1_plugin::connection *self, gcc_type type_in, 3594 const char *name, unsigned long value, 3595 const char *filename, unsigned int line_number) 3596 { 3597 plugin_context *ctx = static_cast<plugin_context *> (self); 3598 tree cst, decl; 3599 tree type = convert_in (type_in); 3600 3601 cst = build_int_cst (type, value); 3602 if (!TYPE_READONLY (type)) 3603 type = build_qualified_type (type, TYPE_QUAL_CONST); 3604 decl = build_decl (ctx->get_source_location (filename, line_number), 3605 VAR_DECL, get_identifier (name), type); 3606 TREE_STATIC (decl) = 1; 3607 TREE_READONLY (decl) = 1; 3608 cp_finish_decl (decl, cst, true, NULL, LOOKUP_ONLYCONVERTING); 3609 safe_pushdecl_maybe_friend (decl, false); 3610 3611 return 1; 3612 } 3613 3614 gcc_type 3615 plugin_error (cc1_plugin::connection *, 3616 const char *message) 3617 { 3618 error ("%s", message); 3619 return convert_out (error_mark_node); 3620 } 3621 3622 int 3623 plugin_add_static_assert (cc1_plugin::connection *self, 3624 gcc_expr condition_in, 3625 const char *errormsg, 3626 const char *filename, 3627 unsigned int line_number) 3628 { 3629 plugin_context *ctx = static_cast<plugin_context *> (self); 3630 tree condition = convert_in (condition_in); 3631 3632 if (!errormsg) 3633 errormsg = ""; 3634 3635 tree message = build_string (strlen (errormsg) + 1, errormsg); 3636 3637 TREE_TYPE (message) = char_array_type_node; 3638 fix_string_type (message); 3639 3640 source_location loc = ctx->get_source_location (filename, line_number); 3641 3642 bool member_p = at_class_scope_p (); 3643 3644 finish_static_assert (condition, message, loc, member_p); 3645 3646 return 1; 3647 } 3648 3649 3650 3651 // Perform GC marking. 3652 3653 static void 3654 gc_mark (void *, void *) 3655 { 3656 if (current_context != NULL) 3657 current_context->mark (); 3658 } 3659 3660 #ifdef __GNUC__ 3661 #pragma GCC visibility push(default) 3662 #endif 3663 3664 int 3665 plugin_init (struct plugin_name_args *plugin_info, 3666 struct plugin_gcc_version *) 3667 { 3668 long fd = -1; 3669 for (int i = 0; i < plugin_info->argc; ++i) 3670 { 3671 if (strcmp (plugin_info->argv[i].key, "fd") == 0) 3672 { 3673 char *tail; 3674 errno = 0; 3675 fd = strtol (plugin_info->argv[i].value, &tail, 0); 3676 if (*tail != '\0' || errno != 0) 3677 fatal_error (input_location, 3678 "%s: invalid file descriptor argument to plugin", 3679 plugin_info->base_name); 3680 break; 3681 } 3682 } 3683 if (fd == -1) 3684 fatal_error (input_location, 3685 "%s: required plugin argument %<fd%> is missing", 3686 plugin_info->base_name); 3687 3688 current_context = new plugin_context (fd); 3689 3690 // Handshake. 3691 cc1_plugin::protocol_int version; 3692 if (!current_context->require ('H') 3693 || ! ::cc1_plugin::unmarshall (current_context, &version)) 3694 fatal_error (input_location, 3695 "%s: handshake failed", plugin_info->base_name); 3696 if (version != GCC_CP_FE_VERSION_0) 3697 fatal_error (input_location, 3698 "%s: unknown version in handshake", plugin_info->base_name); 3699 3700 register_callback (plugin_info->base_name, PLUGIN_PRAGMAS, 3701 plugin_init_extra_pragmas, NULL); 3702 register_callback (plugin_info->base_name, PLUGIN_PRE_GENERICIZE, 3703 rewrite_decls_to_addresses, NULL); 3704 register_callback (plugin_info->base_name, PLUGIN_GGC_MARKING, 3705 gc_mark, NULL); 3706 3707 lang_hooks.print_error_function = plugin_print_error_function; 3708 3709 #define GCC_METHOD0(R, N) \ 3710 { \ 3711 cc1_plugin::callback_ftype *fun \ 3712 = cc1_plugin::callback<R, plugin_ ## N>; \ 3713 current_context->add_callback (# N, fun); \ 3714 } 3715 #define GCC_METHOD1(R, N, A) \ 3716 { \ 3717 cc1_plugin::callback_ftype *fun \ 3718 = cc1_plugin::callback<R, A, plugin_ ## N>; \ 3719 current_context->add_callback (# N, fun); \ 3720 } 3721 #define GCC_METHOD2(R, N, A, B) \ 3722 { \ 3723 cc1_plugin::callback_ftype *fun \ 3724 = cc1_plugin::callback<R, A, B, plugin_ ## N>; \ 3725 current_context->add_callback (# N, fun); \ 3726 } 3727 #define GCC_METHOD3(R, N, A, B, C) \ 3728 { \ 3729 cc1_plugin::callback_ftype *fun \ 3730 = cc1_plugin::callback<R, A, B, C, plugin_ ## N>; \ 3731 current_context->add_callback (# N, fun); \ 3732 } 3733 #define GCC_METHOD4(R, N, A, B, C, D) \ 3734 { \ 3735 cc1_plugin::callback_ftype *fun \ 3736 = cc1_plugin::callback<R, A, B, C, D, \ 3737 plugin_ ## N>; \ 3738 current_context->add_callback (# N, fun); \ 3739 } 3740 #define GCC_METHOD5(R, N, A, B, C, D, E) \ 3741 { \ 3742 cc1_plugin::callback_ftype *fun \ 3743 = cc1_plugin::callback<R, A, B, C, D, E, \ 3744 plugin_ ## N>; \ 3745 current_context->add_callback (# N, fun); \ 3746 } 3747 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \ 3748 { \ 3749 cc1_plugin::callback_ftype *fun \ 3750 = cc1_plugin::callback<R, A, B, C, D, E, F, G, \ 3751 plugin_ ## N>; \ 3752 current_context->add_callback (# N, fun); \ 3753 } 3754 3755 #include "gcc-cp-fe.def" 3756 3757 #undef GCC_METHOD0 3758 #undef GCC_METHOD1 3759 #undef GCC_METHOD2 3760 #undef GCC_METHOD3 3761 #undef GCC_METHOD4 3762 #undef GCC_METHOD5 3763 #undef GCC_METHOD7 3764 3765 return 0; 3766 } 3767