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