1 /* Library interface to C++ front end.
2 Copyright (C) 2014-2020 Free Software Foundation, Inc.
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.
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
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
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/>. */
21 #include <cc1plugin-config.h>
25 #undef PACKAGE_TARNAME
26 #undef PACKAGE_VERSION
28 #include "../gcc/config.h"
32 #undef PACKAGE_TARNAME
33 #undef PACKAGE_VERSION
35 #include "gcc-plugin.h"
37 #include "coretypes.h"
38 #include "stringpool.h"
40 #include "gcc-interface.h"
44 #include "double-int.h"
52 #include "fold-const.h"
53 #include "stor-layout.h"
57 #include "hash-table.h"
59 #include "c-family/c-pragma.h"
60 // #include "c-lang.h"
61 #include "diagnostic.h"
62 #include "langhooks.h"
63 #include "langhooks-def.h"
66 #undef cfun // we want to assign to it, and function.h won't let us
68 #include "callbacks.hh"
69 #include "connection.hh"
70 #include "marshall-cp.hh"
74 #pragma GCC visibility push(default)
76 int plugin_is_GPL_compatible
;
78 #pragma GCC visibility pop
83 static int ATTRIBUTE_UNUSED
84 check_symbol_mask
[GCC_CP_SYMBOL_MASK
>= GCC_CP_SYMBOL_END
? 1 : -1];
86 // This is put into the lang hooks when the plugin starts.
89 plugin_print_error_function (diagnostic_context
*context
, const char *file
,
90 diagnostic_info
*diagnostic
)
92 if (current_function_decl
!= NULL_TREE
93 && DECL_NAME (current_function_decl
) != NULL_TREE
94 && strcmp (IDENTIFIER_POINTER (DECL_NAME (current_function_decl
)),
95 GCC_FE_WRAPPER_FUNCTION
) == 0)
97 lhd_print_error_function (context
, file
, diagnostic
);
102 static unsigned long long
105 return (unsigned long long) (uintptr_t) t
;
109 convert_in (unsigned long long v
)
111 return (tree
) (uintptr_t) v
;
116 struct decl_addr_value
122 struct decl_addr_hasher
: free_ptr_hash
<decl_addr_value
>
124 static inline hashval_t
hash (const decl_addr_value
*);
125 static inline bool equal (const decl_addr_value
*, const decl_addr_value
*);
129 decl_addr_hasher::hash (const decl_addr_value
*e
)
131 return DECL_UID (e
->decl
);
135 decl_addr_hasher::equal (const decl_addr_value
*p1
, const decl_addr_value
*p2
)
137 return p1
->decl
== p2
->decl
;
142 struct string_hasher
: nofree_ptr_hash
<const char>
144 static inline hashval_t
hash (const char *s
)
146 return htab_hash_string (s
);
149 static inline bool equal (const char *p1
, const char *p2
)
151 return strcmp (p1
, p2
) == 0;
157 struct plugin_context
: public cc1_plugin::connection
159 plugin_context (int fd
);
161 // Map decls to addresses.
162 hash_table
<decl_addr_hasher
> address_map
;
164 // A collection of trees that are preserved for the GC.
165 hash_table
< nofree_ptr_hash
<tree_node
> > preserved
;
168 hash_table
<string_hasher
> file_names
;
170 // Perform GC marking.
173 // Preserve a tree during the plugin's operation.
174 tree
preserve (tree t
)
176 tree_node
**slot
= preserved
.find_slot (t
, INSERT
);
181 location_t
get_location_t (const char *filename
,
182 unsigned int line_number
)
184 if (filename
== NULL
)
185 return UNKNOWN_LOCATION
;
187 filename
= intern_filename (filename
);
188 linemap_add (line_table
, LC_ENTER
, false, filename
, line_number
);
189 location_t loc
= linemap_line_start (line_table
, line_number
, 0);
190 linemap_add (line_table
, LC_LEAVE
, false, NULL
, 0);
196 // Add a file name to FILE_NAMES and return the canonical copy.
197 const char *intern_filename (const char *filename
)
199 const char **slot
= file_names
.find_slot (filename
, INSERT
);
202 /* The file name must live as long as the line map, which
203 effectively means as long as this compilation. So, we copy
204 the string here but never free it. */
205 *slot
= xstrdup (filename
);
211 static plugin_context
*current_context
;
215 plugin_context::plugin_context (int fd
)
216 : cc1_plugin::connection (fd
),
224 plugin_context::mark ()
226 for (hash_table
<decl_addr_hasher
>::iterator it
= address_map
.begin ();
227 it
!= address_map
.end ();
230 ggc_mark ((*it
)->decl
);
231 ggc_mark ((*it
)->address
);
234 for (hash_table
< nofree_ptr_hash
<tree_node
> >::iterator
235 it
= preserved
.begin (); it
!= preserved
.end (); ++it
)
240 plugin_binding_oracle (enum cp_oracle_request kind
, tree identifier
)
242 enum gcc_cp_oracle_request request
;
244 gcc_assert (current_context
!= NULL
);
248 case CP_ORACLE_IDENTIFIER
:
249 request
= GCC_CP_ORACLE_IDENTIFIER
;
256 cc1_plugin::call (current_context
, "binding_oracle", &ignore
,
257 request
, IDENTIFIER_POINTER (identifier
));
260 static int push_count
;
262 /* at_function_scope_p () tests cfun, indicating we're actually
263 compiling the function, but we don't even set it when pretending to
264 enter a function scope. We use this distinction to tell these two
265 cases apart: we don't want to define e.g. class names in the user
266 expression function's scope, when they're local to the original
267 function, because they'd get the wrong linkage name. */
270 at_fake_function_scope_p ()
272 return (!cfun
|| cfun
->decl
!= current_function_decl
)
273 && current_scope () == current_function_decl
;
277 push_fake_function (tree fndecl
, scope_kind kind
= sk_function_parms
)
279 current_function_decl
= fndecl
;
280 begin_scope (kind
, fndecl
);
282 begin_scope (sk_block
, NULL
);
288 if (toplevel_bindings_p () && current_namespace
== global_namespace
)
289 pop_from_top_level ();
290 else if (at_namespace_scope_p ())
292 else if (at_class_scope_p ())
296 gcc_assert (at_fake_function_scope_p ());
297 gcc_assert (!at_function_scope_p ());
298 gcc_assert (current_binding_level
->kind
== sk_block
299 && current_binding_level
->this_entity
== NULL
);
302 gcc_assert (current_binding_level
->this_entity
303 == current_function_decl
);
305 current_function_decl
= NULL
;
306 for (cp_binding_level
*scope
= current_binding_level
;
307 scope
; scope
= scope
->level_chain
)
308 if (scope
->kind
== sk_function_parms
)
310 current_function_decl
= scope
->this_entity
;
317 supplement_binding (cxx_binding
*binding
, tree decl
)
319 /* FIXME: this is pretty much a copy of supplement_binding_1 in
320 ../gcc/cp/name-lookup.c; the few replaced/removed bits are marked
322 tree bval
= binding
->value
;
324 tree target_bval
= strip_using_decl (bval
);
325 tree target_decl
= strip_using_decl (decl
);
327 if (TREE_CODE (target_decl
) == TYPE_DECL
&& DECL_ARTIFICIAL (target_decl
)
328 && target_decl
!= target_bval
329 && (TREE_CODE (target_bval
) != TYPE_DECL
330 /* We allow pushing an enum multiple times in a class
331 template in order to handle late matching of underlying
332 type on an opaque-enum-declaration followed by an
334 || (processing_template_decl
335 && TREE_CODE (TREE_TYPE (target_decl
)) == ENUMERAL_TYPE
336 && TREE_CODE (TREE_TYPE (target_bval
)) == ENUMERAL_TYPE
337 && (dependent_type_p (ENUM_UNDERLYING_TYPE
338 (TREE_TYPE (target_decl
)))
339 || dependent_type_p (ENUM_UNDERLYING_TYPE
340 (TREE_TYPE (target_bval
)))))))
341 /* The new name is the type name. */
342 binding
->type
= decl
;
343 else if (/* TARGET_BVAL is null when push_class_level_binding moves
344 an inherited type-binding out of the way to make room
345 for a new value binding. */
347 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
348 has been used in a non-class scope prior declaration.
349 In that case, we should have already issued a
350 diagnostic; for graceful error recovery purpose, pretend
351 this was the intended declaration for that name. */
352 || target_bval
== error_mark_node
353 /* If TARGET_BVAL is anticipated but has not yet been
354 declared, pretend it is not there at all. */
355 || (TREE_CODE (target_bval
) == FUNCTION_DECL
356 && DECL_ANTICIPATED (target_bval
)
357 && !DECL_HIDDEN_FRIEND_P (target_bval
)))
358 binding
->value
= decl
;
359 else if (TREE_CODE (target_bval
) == TYPE_DECL
360 && DECL_ARTIFICIAL (target_bval
)
361 && target_decl
!= target_bval
362 && (TREE_CODE (target_decl
) != TYPE_DECL
363 || same_type_p (TREE_TYPE (target_decl
),
364 TREE_TYPE (target_bval
))))
366 /* The old binding was a type name. It was placed in
367 VALUE field because it was thought, at the point it was
368 declared, to be the only entity with such a name. Move the
369 type name into the type slot; it is now hidden by the new
371 binding
->type
= bval
;
372 binding
->value
= decl
;
373 binding
->value_is_inherited
= false;
375 else if (TREE_CODE (target_bval
) == TYPE_DECL
376 && TREE_CODE (target_decl
) == TYPE_DECL
377 && DECL_NAME (target_decl
) == DECL_NAME (target_bval
)
378 && binding
->scope
->kind
!= sk_class
379 && (same_type_p (TREE_TYPE (target_decl
), TREE_TYPE (target_bval
))
380 /* If either type involves template parameters, we must
381 wait until instantiation. */
382 || uses_template_parms (TREE_TYPE (target_decl
))
383 || uses_template_parms (TREE_TYPE (target_bval
))))
384 /* We have two typedef-names, both naming the same type to have
385 the same name. In general, this is OK because of:
389 In a given scope, a typedef specifier can be used to redefine
390 the name of any type declared in that scope to refer to the
391 type to which it already refers.
393 However, in class scopes, this rule does not apply due to the
394 stricter language in [class.mem] prohibiting redeclarations of
397 /* There can be two block-scope declarations of the same variable,
398 so long as they are `extern' declarations. However, there cannot
399 be two declarations of the same static data member:
403 A member shall not be declared twice in the
404 member-specification. */
405 else if (VAR_P (target_decl
)
406 && VAR_P (target_bval
)
407 && DECL_EXTERNAL (target_decl
) && DECL_EXTERNAL (target_bval
)
408 && !DECL_CLASS_SCOPE_P (target_decl
))
410 duplicate_decls (decl
, binding
->value
, /*newdecl_is_friend=*/false);
413 else if (TREE_CODE (decl
) == NAMESPACE_DECL
414 && TREE_CODE (bval
) == NAMESPACE_DECL
415 && DECL_NAMESPACE_ALIAS (decl
)
416 && DECL_NAMESPACE_ALIAS (bval
)
417 && ORIGINAL_NAMESPACE (bval
) == ORIGINAL_NAMESPACE (decl
))
420 In a declarative region, a namespace-alias-definition can be
421 used to redefine a namespace-alias declared in that declarative
422 region to refer only to the namespace to which it already
427 // _1: diagnose_name_conflict (decl, bval);
431 gcc_assert (ok
); // _1: return ok;
435 reactivate_decl (tree decl
, cp_binding_level
*b
)
437 bool in_function_p
= TREE_CODE (b
->this_entity
) == FUNCTION_DECL
;
438 gcc_assert (in_function_p
439 || (b
== current_binding_level
440 && !at_class_scope_p ()));
442 tree id
= DECL_NAME (decl
);
443 tree type
= NULL_TREE
;
444 if (TREE_CODE (decl
) == TYPE_DECL
)
445 type
= TREE_TYPE (decl
);
447 if (type
&& TYPE_NAME (type
) == decl
448 && (RECORD_OR_UNION_CODE_P (TREE_CODE (type
))
449 || TREE_CODE (type
) == ENUMERAL_TYPE
))
451 gcc_assert (in_function_p
&& DECL_CONTEXT (decl
) == b
->this_entity
);
452 type
= TREE_TYPE (decl
);
456 gcc_assert (DECL_CONTEXT (decl
) == b
->this_entity
457 || DECL_CONTEXT (decl
) == global_namespace
458 || TREE_CODE (DECL_CONTEXT (decl
)) == FUNCTION_DECL
);
462 /* Adjust IDENTIFIER_BINDING to what it would have been if we were
463 at binding level B. Save the binding chain up to that point in
464 [binding, *chainp), and take note of the outermost bindings found
466 cxx_binding
*binding
= IDENTIFIER_BINDING (id
), **chainp
= NULL
;
467 tree
*shadowing_type_p
= NULL
;
470 cp_binding_level
*bc
= current_binding_level
;
471 for (cxx_binding
*prev_binding
= binding
;
472 prev_binding
; prev_binding
= prev_binding
->previous
)
474 while (bc
!= b
&& bc
!= prev_binding
->scope
)
475 bc
= bc
->level_chain
;
482 chainp
= &prev_binding
->previous
;
484 for (tree tshadow
= prev_binding
->scope
->type_shadowed
;
485 tshadow
; tshadow
= TREE_CHAIN (tshadow
))
486 if (TREE_PURPOSE (tshadow
) == id
)
488 shadowing_type_p
= &TREE_VALUE (tshadow
);
495 IDENTIFIER_BINDING (id
) = *chainp
;
499 /* Like push_local_binding, supplement or add a binding to the
501 if (IDENTIFIER_BINDING (id
) && IDENTIFIER_BINDING (id
)->scope
== b
)
502 supplement_binding (IDENTIFIER_BINDING (id
), decl
);
504 push_binding (id
, decl
, b
);
506 /* Now restore the binding chain we'd temporarily removed. */
509 *chainp
= IDENTIFIER_BINDING (id
);
510 IDENTIFIER_BINDING (id
) = binding
;
514 /* Insert the new type binding in the shadowing_type_p
516 tree shadowed_type
= NULL_TREE
;
517 if (shadowing_type_p
)
519 shadowed_type
= *shadowing_type_p
;
520 *shadowing_type_p
= type
;
523 b
->type_shadowed
= tree_cons (id
, shadowed_type
, b
->type_shadowed
);
524 TREE_TYPE (b
->type_shadowed
) = type
;
529 /* Our new binding is the active one, so shadow the earlier
531 b
->type_shadowed
= tree_cons (id
, REAL_IDENTIFIER_TYPE_VALUE (id
),
533 TREE_TYPE (b
->type_shadowed
) = type
;
534 SET_IDENTIFIER_TYPE_VALUE (id
, type
);
537 /* Record that we have a binding for ID, like add_decl_to_level. */
538 tree node
= build_tree_list (NULL_TREE
, decl
);
539 TREE_CHAIN (node
) = b
->names
;
544 plugin_pragma_push_user_expression (cpp_reader
*)
549 gcc_assert (!current_class_ptr
);
550 gcc_assert (!current_class_ref
);
552 gcc_assert (!cp_binding_oracle
);
553 cp_binding_oracle
= plugin_binding_oracle
;
555 /* Make the function containing the user expression a global
556 friend, so as to bypass access controls in it. */
557 if (at_function_scope_p ())
558 set_global_friend (current_function_decl
);
560 gcc_assert (at_function_scope_p ());
561 function
*save_cfun
= cfun
;
562 cp_binding_level
*orig_binding_level
= current_binding_level
;
565 cc1_plugin::call (current_context
, "enter_scope", &success
);
567 gcc_assert (at_fake_function_scope_p () || at_function_scope_p ());
569 function
*unchanged_cfun
= cfun
;
570 tree changed_func_decl
= current_function_decl
;
572 gcc_assert (current_class_type
== DECL_CONTEXT (current_function_decl
)
573 || !(RECORD_OR_UNION_CODE_P
574 (TREE_CODE (DECL_CONTEXT (current_function_decl
)))));
575 push_fake_function (save_cfun
->decl
, sk_block
);
576 current_class_type
= NULL_TREE
;
579 /* If we get here, GDB did NOT change the context. */
580 gcc_assert (cfun
== save_cfun
);
581 gcc_assert (at_function_scope_p ());
582 gcc_assert (orig_binding_level
583 == current_binding_level
->level_chain
->level_chain
);
588 gcc_assert (at_function_scope_p ());
590 cp_binding_level
*b
= current_binding_level
->level_chain
;
591 gcc_assert (b
->this_entity
== cfun
->decl
);
593 /* Reactivate local names from the previous context. Use
594 IDENTIFIER_MARKED to avoid reactivating shadowed names. */
595 for (cp_binding_level
*level
= orig_binding_level
;;)
597 for (tree name
= level
->names
;
598 name
; name
= TREE_CHAIN (name
))
601 if (TREE_CODE (decl
) == TREE_LIST
)
602 decl
= TREE_VALUE (decl
);
603 if (IDENTIFIER_MARKED (DECL_NAME (decl
)))
605 IDENTIFIER_MARKED (DECL_NAME (decl
)) = 1;
606 reactivate_decl (decl
, b
);
608 if (level
->kind
== sk_function_parms
609 && level
->this_entity
== cfun
->decl
)
611 gcc_assert (!level
->this_entity
);
612 level
= level
->level_chain
;
615 /* Now, clear the markers. */
616 for (tree name
= b
->names
; name
; name
= TREE_CHAIN (name
))
619 if (TREE_CODE (decl
) == TREE_LIST
)
620 decl
= TREE_VALUE (decl
);
621 gcc_assert (IDENTIFIER_MARKED (DECL_NAME (decl
)));
622 IDENTIFIER_MARKED (DECL_NAME (decl
)) = 0;
626 if (unchanged_cfun
|| DECL_NONSTATIC_MEMBER_FUNCTION_P (changed_func_decl
))
628 /* Check whether the oracle supplies us with a "this", and if
629 so, arrange for data members and this itself to be
631 tree this_val
= lookup_name (get_identifier ("this"));
632 current_class_ref
= !this_val
? NULL_TREE
633 : cp_build_indirect_ref (input_location
, this_val
, RO_NULL
,
634 tf_warning_or_error
);
635 current_class_ptr
= this_val
;
640 plugin_pragma_pop_user_expression (cpp_reader
*)
645 gcc_assert (cp_binding_oracle
);
647 gcc_assert (at_function_scope_p ());
648 function
*save_cfun
= cfun
;
649 current_class_ptr
= NULL_TREE
;
650 current_class_ref
= NULL_TREE
;
654 if (RECORD_OR_UNION_CODE_P (TREE_CODE (DECL_CONTEXT (current_function_decl
))))
655 current_class_type
= DECL_CONTEXT (current_function_decl
);
658 cc1_plugin::call (current_context
, "leave_scope", &success
);
663 gcc_assert (cfun
== save_cfun
);
665 cp_binding_oracle
= NULL
;
666 gcc_assert (at_function_scope_p ());
670 plugin_init_extra_pragmas (void *, void *)
672 c_register_pragma ("GCC", "push_user_expression", plugin_pragma_push_user_expression
);
673 c_register_pragma ("GCC", "pop_user_expression", plugin_pragma_pop_user_expression
);
674 /* FIXME: this one should go once we get GDB to use push and pop. */
675 c_register_pragma ("GCC", "user_expression", plugin_pragma_push_user_expression
);
680 static decl_addr_value
681 build_decl_addr_value (tree decl
, gcc_address address
)
683 decl_addr_value value
= {
685 build_int_cst_type (ptr_type_node
, address
)
690 static decl_addr_value
*
691 record_decl_address (plugin_context
*ctx
, decl_addr_value value
)
693 decl_addr_value
**slot
= ctx
->address_map
.find_slot (&value
, INSERT
);
694 gcc_assert (*slot
== NULL
);
696 = static_cast<decl_addr_value
*> (xmalloc (sizeof (decl_addr_value
)));
698 /* We don't want GCC to warn about e.g. static functions
699 without a code definition. */
700 TREE_NO_WARNING (value
.decl
) = 1;
704 // Maybe rewrite a decl to its address.
706 address_rewriter (tree
*in
, int *walk_subtrees
, void *arg
)
708 plugin_context
*ctx
= (plugin_context
*) arg
;
711 || TREE_CODE (*in
) == NAMESPACE_DECL
712 || DECL_NAME (*in
) == NULL_TREE
)
715 decl_addr_value value
;
717 decl_addr_value
*found_value
= ctx
->address_map
.find (&value
);
718 if (found_value
!= NULL
)
720 else if (HAS_DECL_ASSEMBLER_NAME_P (*in
))
724 if (!cc1_plugin::call (ctx
, "address_oracle", &address
,
725 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (*in
))))
730 // Insert the decl into the address map in case it is referenced
732 value
= build_decl_addr_value (value
.decl
, address
);
733 found_value
= record_decl_address (ctx
, value
);
738 if (found_value
->address
!= error_mark_node
)
740 // We have an address for the decl, so rewrite the tree.
741 tree ptr_type
= build_pointer_type (TREE_TYPE (*in
));
742 *in
= fold_build1 (INDIRECT_REF
, TREE_TYPE (*in
),
743 fold_build1 (CONVERT_EXPR
, ptr_type
,
744 found_value
->address
));
752 // When generating code for gdb, we want to be able to use absolute
753 // addresses to refer to otherwise external objects that gdb knows
754 // about. gdb passes in these addresses when building decls, and then
755 // before gimplification we go through the trees, rewriting uses to
756 // the equivalent of "*(TYPE *) ADDR".
758 rewrite_decls_to_addresses (void *function_in
, void *)
760 tree function
= (tree
) function_in
;
762 // Do nothing if we're not in gdb.
763 if (current_context
== NULL
)
766 walk_tree (&DECL_SAVED_TREE (function
), address_rewriter
, current_context
,
773 safe_push_template_decl (tree decl
)
775 void (*save_oracle
) (enum cp_oracle_request
, tree identifier
);
777 save_oracle
= cp_binding_oracle
;
778 cp_binding_oracle
= NULL
;
780 tree ret
= push_template_decl (decl
);
782 cp_binding_oracle
= save_oracle
;
788 safe_pushtag (tree name
, tree type
, tag_scope scope
)
790 void (*save_oracle
) (enum cp_oracle_request
, tree identifier
);
792 save_oracle
= cp_binding_oracle
;
793 cp_binding_oracle
= NULL
;
795 tree ret
= pushtag (name
, type
, scope
);
797 cp_binding_oracle
= save_oracle
;
803 safe_pushdecl_maybe_friend (tree decl
, bool is_friend
)
805 void (*save_oracle
) (enum cp_oracle_request
, tree identifier
);
807 save_oracle
= cp_binding_oracle
;
808 cp_binding_oracle
= NULL
;
810 tree ret
= pushdecl (decl
, is_friend
);
812 cp_binding_oracle
= save_oracle
;
820 plugin_push_namespace (cc1_plugin::connection
*,
824 push_to_top_level ();
826 push_namespace (name
? get_identifier (name
) : NULL
);
832 plugin_push_class (cc1_plugin::connection
*,
835 tree type
= convert_in (type_in
);
836 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type
)));
837 gcc_assert (TYPE_CONTEXT (type
) == FROB_CONTEXT (current_scope ()));
845 plugin_push_function (cc1_plugin::connection
*,
846 gcc_decl function_decl_in
)
848 tree fndecl
= convert_in (function_decl_in
);
849 gcc_assert (TREE_CODE (fndecl
) == FUNCTION_DECL
);
850 gcc_assert (DECL_CONTEXT (fndecl
) == FROB_CONTEXT (current_scope ()));
852 push_fake_function (fndecl
);
858 plugin_pop_binding_level (cc1_plugin::connection
*)
865 plugin_reactivate_decl (cc1_plugin::connection
*,
869 tree decl
= convert_in (decl_in
);
870 tree scope
= convert_in (scope_in
);
871 gcc_assert (TREE_CODE (decl
) == VAR_DECL
872 || TREE_CODE (decl
) == FUNCTION_DECL
873 || TREE_CODE (decl
) == TYPE_DECL
);
877 gcc_assert (TREE_CODE (scope
) == FUNCTION_DECL
);
878 for (b
= current_binding_level
;
879 b
->this_entity
!= scope
;
881 gcc_assert (b
->this_entity
!= global_namespace
);
885 gcc_assert (!at_class_scope_p ());
886 b
= current_binding_level
;
889 reactivate_decl (decl
, b
);
898 if (at_namespace_scope_p ())
899 decl
= current_namespace
;
900 else if (at_class_scope_p ())
901 decl
= TYPE_NAME (current_class_type
);
902 else if (at_fake_function_scope_p () || at_function_scope_p ())
903 decl
= current_function_decl
;
911 plugin_get_current_binding_level_decl (cc1_plugin::connection
*)
913 tree decl
= get_current_scope ();
915 return convert_out (decl
);
919 plugin_make_namespace_inline (cc1_plugin::connection
*)
921 tree inline_ns
= current_namespace
;
923 gcc_assert (toplevel_bindings_p ());
924 gcc_assert (inline_ns
!= global_namespace
);
926 tree parent_ns
= CP_DECL_CONTEXT (inline_ns
);
928 if (DECL_NAMESPACE_INLINE_P (inline_ns
))
931 DECL_NAMESPACE_INLINE_P (inline_ns
) = true;
932 vec_safe_push (DECL_NAMESPACE_INLINEES (parent_ns
), inline_ns
);
938 plugin_add_using_namespace (cc1_plugin::connection
*,
941 tree used_ns
= convert_in (used_ns_in
);
943 gcc_assert (TREE_CODE (used_ns
) == NAMESPACE_DECL
);
945 finish_using_directive (used_ns
, NULL_TREE
);
951 plugin_add_namespace_alias (cc1_plugin::connection
*,
955 tree name
= get_identifier (id
);
956 tree target
= convert_in (target_in
);
958 do_namespace_alias (name
, target
);
964 set_access_flags (tree decl
, enum gcc_cp_symbol_kind flags
)
966 gcc_assert (!(flags
& GCC_CP_ACCESS_MASK
) == !DECL_CLASS_SCOPE_P (decl
));
968 switch (flags
& GCC_CP_ACCESS_MASK
)
970 case GCC_CP_ACCESS_PRIVATE
:
971 TREE_PRIVATE (decl
) = true;
972 current_access_specifier
= access_private_node
;
975 case GCC_CP_ACCESS_PROTECTED
:
976 TREE_PROTECTED (decl
) = true;
977 current_access_specifier
= access_protected_node
;
980 case GCC_CP_ACCESS_PUBLIC
:
981 current_access_specifier
= access_public_node
;
990 plugin_add_using_decl (cc1_plugin::connection
*,
991 enum gcc_cp_symbol_kind flags
,
994 tree target
= convert_in (target_in
);
995 gcc_assert ((flags
& GCC_CP_SYMBOL_MASK
) == GCC_CP_SYMBOL_USING
);
996 gcc_assert (!(flags
& GCC_CP_FLAG_MASK
));
997 enum gcc_cp_symbol_kind acc_flags
;
998 acc_flags
= (enum gcc_cp_symbol_kind
) (flags
& GCC_CP_ACCESS_MASK
);
1000 gcc_assert (!template_parm_scope_p ());
1002 bool class_member_p
= at_class_scope_p ();
1003 gcc_assert (!(acc_flags
& GCC_CP_ACCESS_MASK
) == !class_member_p
);
1005 tree identifier
= DECL_NAME (target
);
1006 tree tcontext
= DECL_CONTEXT (target
);
1008 if (UNSCOPED_ENUM_P (tcontext
))
1009 tcontext
= CP_TYPE_CONTEXT (tcontext
);
1013 tree decl
= do_class_using_decl (tcontext
, identifier
);
1015 set_access_flags (decl
, flags
);
1017 finish_member_declaration (decl
);
1021 /* We can't be at local scope. */
1022 gcc_assert (at_namespace_scope_p ());
1023 finish_nonmember_using_decl (tcontext
, identifier
);
1030 build_named_class_type (enum tree_code code
,
1034 /* See at_fake_function_scope_p. */
1035 gcc_assert (!at_function_scope_p ());
1036 tree type
= make_class_type (code
);
1037 tree type_decl
= build_decl (loc
, TYPE_DECL
, id
, type
);
1038 TYPE_NAME (type
) = type_decl
;
1039 TYPE_STUB_DECL (type
) = type_decl
;
1040 DECL_CONTEXT (type_decl
) = TYPE_CONTEXT (type
);
1045 /* Abuse an unused field of the dummy template parms entry to hold the
1047 #define TP_PARM_LIST TREE_TYPE (current_template_parms)
1050 plugin_build_decl (cc1_plugin::connection
*self
,
1052 enum gcc_cp_symbol_kind sym_kind
,
1053 gcc_type sym_type_in
,
1054 const char *substitution_name
,
1055 gcc_address address
,
1056 const char *filename
,
1057 unsigned int line_number
)
1059 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1060 gcc_assert (!name
|| !strchr (name
, ':')); // FIXME: this can go eventually.
1062 enum tree_code code
;
1064 tree sym_type
= convert_in (sym_type_in
);
1065 enum gcc_cp_symbol_kind sym_flags
;
1066 sym_flags
= (enum gcc_cp_symbol_kind
) (sym_kind
& GCC_CP_FLAG_MASK
);
1067 enum gcc_cp_symbol_kind acc_flags
;
1068 acc_flags
= (enum gcc_cp_symbol_kind
) (sym_kind
& GCC_CP_ACCESS_MASK
);
1069 sym_kind
= (enum gcc_cp_symbol_kind
) (sym_kind
& GCC_CP_SYMBOL_MASK
);
1073 case GCC_CP_SYMBOL_FUNCTION
:
1074 code
= FUNCTION_DECL
;
1075 gcc_assert (!(sym_flags
& ~GCC_CP_FLAG_MASK_FUNCTION
));
1078 case GCC_CP_SYMBOL_VARIABLE
:
1080 gcc_assert (!(sym_flags
& ~GCC_CP_FLAG_MASK_VARIABLE
));
1083 case GCC_CP_SYMBOL_TYPEDEF
:
1085 gcc_assert (!sym_flags
);
1088 case GCC_CP_SYMBOL_CLASS
:
1090 gcc_assert (!(sym_flags
& ~GCC_CP_FLAG_MASK_CLASS
));
1091 gcc_assert (!sym_type
);
1094 case GCC_CP_SYMBOL_UNION
:
1096 gcc_assert (!sym_flags
);
1097 gcc_assert (!sym_type
);
1104 bool template_decl_p
= template_parm_scope_p ();
1106 if (template_decl_p
)
1108 gcc_assert (code
== FUNCTION_DECL
|| code
== RECORD_TYPE
1109 || code
== TYPE_DECL
);
1111 /* Finish the template parm list that started this template parm. */
1112 end_template_parm_list (TP_PARM_LIST
);
1114 gcc_assert (!address
);
1115 gcc_assert (!substitution_name
);
1118 location_t loc
= ctx
->get_location_t (filename
, line_number
);
1119 bool class_member_p
= at_class_scope_p ();
1120 bool ctor
= false, dtor
= false, assop
= false;
1121 tree_code opcode
= ERROR_MARK
;
1123 gcc_assert (!(acc_flags
& GCC_CP_ACCESS_MASK
) == !class_member_p
);
1126 if (code
!= FUNCTION_DECL
1127 || !(sym_flags
& GCC_CP_FLAG_SPECIAL_FUNCTION
))
1130 identifier
= get_identifier (name
);
1133 gcc_assert (RECORD_OR_UNION_CODE_P (code
));
1134 identifier
= make_anon_name ();
1138 if (code
== FUNCTION_DECL
)
1140 if (sym_flags
& GCC_CP_FLAG_SPECIAL_FUNCTION
)
1142 #define CHARS2(f,s) (((unsigned char)f << CHAR_BIT) | (unsigned char)s)
1143 switch (CHARS2 (name
[0], name
[1]))
1145 case CHARS2 ('C', 0x0): // ctor base declaration
1146 case CHARS2 ('C', ' '):
1147 case CHARS2 ('C', '1'):
1148 case CHARS2 ('C', '2'):
1149 case CHARS2 ('C', '4'):
1152 gcc_assert (!address
);
1153 gcc_assert (!substitution_name
);
1154 identifier
= DECL_NAME (TYPE_NAME (current_class_type
));
1156 case CHARS2 ('D', 0x0): // dtor base declaration
1157 case CHARS2 ('D', ' '):
1158 case CHARS2 ('D', '0'):
1159 case CHARS2 ('D', '1'):
1160 case CHARS2 ('D', '2'):
1161 case CHARS2 ('D', '4'):
1162 gcc_assert (!template_decl_p
);
1165 case CHARS2 ('n', 'w'): // operator new
1168 case CHARS2 ('n', 'a'): // operator new[]
1169 opcode
= VEC_NEW_EXPR
;
1171 case CHARS2 ('d', 'l'): // operator delete
1172 opcode
= DELETE_EXPR
;
1174 case CHARS2 ('d', 'a'): // operator delete[]
1175 opcode
= VEC_DELETE_EXPR
;
1177 case CHARS2 ('p', 's'): // operator + (unary)
1180 case CHARS2 ('n', 'g'): // operator - (unary)
1181 opcode
= MINUS_EXPR
;
1183 case CHARS2 ('a', 'd'): // operator & (unary)
1184 opcode
= BIT_AND_EXPR
;
1186 case CHARS2 ('d', 'e'): // operator * (unary)
1189 case CHARS2 ('c', 'o'): // operator ~
1190 opcode
= BIT_NOT_EXPR
;
1192 case CHARS2 ('p', 'l'): // operator +
1195 case CHARS2 ('m', 'i'): // operator -
1196 opcode
= MINUS_EXPR
;
1198 case CHARS2 ('m', 'l'): // operator *
1201 case CHARS2 ('d', 'v'): // operator /
1202 opcode
= TRUNC_DIV_EXPR
;
1204 case CHARS2 ('r', 'm'): // operator %
1205 opcode
= TRUNC_MOD_EXPR
;
1207 case CHARS2 ('a', 'n'): // operator &
1208 opcode
= BIT_AND_EXPR
;
1210 case CHARS2 ('o', 'r'): // operator |
1211 opcode
= BIT_IOR_EXPR
;
1213 case CHARS2 ('e', 'o'): // operator ^
1214 opcode
= BIT_XOR_EXPR
;
1216 case CHARS2 ('a', 'S'): // operator =
1220 case CHARS2 ('p', 'L'): // operator +=
1224 case CHARS2 ('m', 'I'): // operator -=
1225 opcode
= MINUS_EXPR
;
1228 case CHARS2 ('m', 'L'): // operator *=
1232 case CHARS2 ('d', 'V'): // operator /=
1233 opcode
= TRUNC_DIV_EXPR
;
1236 case CHARS2 ('r', 'M'): // operator %=
1237 opcode
= TRUNC_MOD_EXPR
;
1240 case CHARS2 ('a', 'N'): // operator &=
1241 opcode
= BIT_AND_EXPR
;
1244 case CHARS2 ('o', 'R'): // operator |=
1245 opcode
= BIT_IOR_EXPR
;
1248 case CHARS2 ('e', 'O'): // operator ^=
1249 opcode
= BIT_XOR_EXPR
;
1252 case CHARS2 ('l', 's'): // operator <<
1253 opcode
= LSHIFT_EXPR
;
1255 case CHARS2 ('r', 's'): // operator >>
1256 opcode
= RSHIFT_EXPR
;
1258 case CHARS2 ('l', 'S'): // operator <<=
1259 opcode
= LSHIFT_EXPR
;
1262 case CHARS2 ('r', 'S'): // operator >>=
1263 opcode
= RSHIFT_EXPR
;
1266 case CHARS2 ('e', 'q'): // operator ==
1269 case CHARS2 ('n', 'e'): // operator !=
1272 case CHARS2 ('l', 't'): // operator <
1275 case CHARS2 ('g', 't'): // operator >
1278 case CHARS2 ('l', 'e'): // operator <=
1281 case CHARS2 ('g', 'e'): // operator >=
1284 case CHARS2 ('n', 't'): // operator !
1285 opcode
= TRUTH_NOT_EXPR
;
1287 case CHARS2 ('a', 'a'): // operator &&
1288 opcode
= TRUTH_ANDIF_EXPR
;
1290 case CHARS2 ('o', 'o'): // operator ||
1291 opcode
= TRUTH_ORIF_EXPR
;
1293 case CHARS2 ('p', 'p'): // operator ++
1294 opcode
= POSTINCREMENT_EXPR
;
1296 case CHARS2 ('m', 'm'): // operator --
1297 /* This stands for either one as an operator name, and
1298 "pp" and "mm" stand for POST??CREMENT, but for some
1299 reason the parser uses this opcode name for
1300 operator--; let's follow their practice. */
1301 opcode
= PREDECREMENT_EXPR
;
1303 case CHARS2 ('c', 'm'): // operator ,
1304 opcode
= COMPOUND_EXPR
;
1306 case CHARS2 ('p', 'm'): // operator ->*
1307 opcode
= MEMBER_REF
;
1309 case CHARS2 ('p', 't'): // operator ->
1310 opcode
= COMPONENT_REF
;
1312 case CHARS2 ('c', 'l'): // operator ()
1315 case CHARS2 ('i', 'x'): // operator []
1318 case CHARS2 ('c', 'v'): // operator <T> (conversion operator)
1319 identifier
= make_conv_op_name (TREE_TYPE (sym_type
));
1322 case CHARS2 ('l', 'i'): // operator "" <id>
1324 char *id
= (char *)name
+ 2;
1325 bool freeid
= false;
1326 if (*id
>= '0' && *id
<= '9')
1335 while (*id
&& *id
>= '0' && *id
<= '9');
1336 id
= xstrndup (id
, len
);
1339 identifier
= cp_literal_operator_id (id
);
1344 case CHARS2 ('q', 'u'): // ternary operator, not overloadable.
1349 if (opcode
!= ERROR_MARK
)
1350 identifier
= ovl_op_identifier (assop
, opcode
);
1352 decl
= build_lang_decl_loc (loc
, code
, identifier
, sym_type
);
1353 /* FIXME: current_lang_name is lang_name_c while compiling an
1354 extern "C" function, and we haven't switched to a global
1355 context at this point, and this breaks function
1357 SET_DECL_LANGUAGE (decl
, lang_cplusplus
);
1358 if (TREE_CODE (sym_type
) == METHOD_TYPE
)
1359 DECL_ARGUMENTS (decl
) = build_this_parm (decl
, current_class_type
,
1360 cp_type_quals (sym_type
));
1361 for (tree arg
= TREE_CODE (sym_type
) == METHOD_TYPE
1362 ? TREE_CHAIN (TYPE_ARG_TYPES (sym_type
))
1363 : TYPE_ARG_TYPES (sym_type
);
1364 arg
&& arg
!= void_list_node
;
1365 arg
= TREE_CHAIN (arg
))
1367 tree parm
= cp_build_parm_decl (decl
, NULL_TREE
, TREE_VALUE (arg
));
1368 DECL_CHAIN (parm
) = DECL_ARGUMENTS (decl
);
1369 DECL_ARGUMENTS (decl
) = parm
;
1371 DECL_ARGUMENTS (decl
) = nreverse (DECL_ARGUMENTS (decl
));
1374 if (TREE_CODE (sym_type
) == FUNCTION_TYPE
)
1375 DECL_STATIC_FUNCTION_P (decl
) = 1;
1376 if (sym_flags
& GCC_CP_FLAG_VIRTUAL_FUNCTION
)
1378 DECL_VIRTUAL_P (decl
) = 1;
1379 if (sym_flags
& GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
)
1380 DECL_PURE_VIRTUAL_P (decl
) = 1;
1381 if (sym_flags
& GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION
)
1382 DECL_FINAL_P (decl
) = 1;
1385 gcc_assert (!(sym_flags
& (GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
1386 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION
)));
1390 gcc_assert (!(sym_flags
& (GCC_CP_FLAG_VIRTUAL_FUNCTION
1391 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
1392 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION
)));
1393 gcc_assert (!ctor
&& !dtor
&& !assop
);
1395 if (sym_flags
& GCC_CP_FLAG_EXPLICIT_FUNCTION
)
1396 DECL_NONCONVERTING_P (decl
) = 1;
1397 if (sym_flags
& GCC_CP_FLAG_DEFAULTED_FUNCTION
)
1399 DECL_INITIAL (decl
) = ridpointers
[(int)RID_DEFAULT
];
1400 DECL_DEFAULTED_FN (decl
) = 1;
1402 if (sym_flags
& GCC_CP_FLAG_DELETED_FUNCTION
)
1404 // DECL_INITIAL (decl) = ridpointers[(int)RID_DELETE];
1405 DECL_DELETED_FN (decl
) = 1;
1406 DECL_DECLARED_INLINE_P (decl
) = 1;
1407 DECL_INITIAL (decl
) = error_mark_node
;
1411 DECL_CXX_CONSTRUCTOR_P (decl
) = 1;
1413 DECL_CXX_DESTRUCTOR_P (decl
) = 1;
1414 else if ((sym_flags
& GCC_CP_FLAG_SPECIAL_FUNCTION
)
1415 && opcode
!= ERROR_MARK
)
1416 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl
) = ovl_op_mapping
[opcode
];
1418 else if (RECORD_OR_UNION_CODE_P (code
))
1420 decl
= build_named_class_type (code
, identifier
, loc
);
1421 tree type
= TREE_TYPE (decl
);
1423 if (code
== RECORD_TYPE
1424 && !(sym_flags
& GCC_CP_FLAG_CLASS_IS_STRUCT
))
1425 CLASSTYPE_DECLARED_CLASS (type
) = true;
1427 else if (class_member_p
)
1429 decl
= build_lang_decl_loc (loc
, code
, identifier
, sym_type
);
1431 if (TREE_CODE (decl
) == VAR_DECL
)
1433 DECL_THIS_STATIC (decl
) = 1;
1434 // The remainder of this block does the same as:
1435 // set_linkage_for_static_data_member (decl);
1436 TREE_PUBLIC (decl
) = 1;
1437 TREE_STATIC (decl
) = 1;
1438 DECL_INTERFACE_KNOWN (decl
) = 1;
1440 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
1441 gcc_assert (!(sym_flags
& GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
));
1443 if (sym_flags
& GCC_CP_FLAG_CONSTEXPR_VARIABLE
)
1444 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
1449 decl
= build_decl (loc
, code
, identifier
, sym_type
);
1451 if (TREE_CODE (decl
) == VAR_DECL
)
1453 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
1454 gcc_assert (!(sym_flags
& GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
));
1456 if (sym_flags
& GCC_CP_FLAG_CONSTEXPR_VARIABLE
)
1457 DECL_DECLARED_CONSTEXPR_P (decl
) = true;
1460 TREE_USED (decl
) = 1;
1461 TREE_ADDRESSABLE (decl
) = 1;
1464 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_class_type
);
1465 else if (at_namespace_scope_p ())
1466 DECL_CONTEXT (decl
) = FROB_CONTEXT (current_decl_namespace ());
1468 set_access_flags (decl
, acc_flags
);
1470 /* If this is the typedef that names an otherwise anonymous type,
1471 propagate the typedef name to the type. In normal compilation,
1472 this is done in grokdeclarator. */
1473 if (sym_kind
== GCC_CP_SYMBOL_TYPEDEF
1475 && DECL_CONTEXT (decl
) == TYPE_CONTEXT (sym_type
)
1476 && TYPE_UNNAMED_P (sym_type
))
1477 name_unnamed_type (sym_type
, decl
);
1479 if (sym_kind
!= GCC_CP_SYMBOL_TYPEDEF
1480 && sym_kind
!= GCC_CP_SYMBOL_CLASS
1481 && sym_kind
!= GCC_CP_SYMBOL_UNION
1482 && !template_decl_p
&& !ctor
&& !dtor
)
1484 decl_addr_value value
;
1486 DECL_EXTERNAL (decl
) = 1;
1488 if (substitution_name
!= NULL
)
1490 // If the translator gave us a name without a binding,
1491 // we can just substitute error_mark_node, since we know the
1492 // translator will be reporting an error anyhow.
1494 = lookup_name (get_identifier (substitution_name
));
1495 if (value
.address
== NULL_TREE
)
1496 value
.address
= error_mark_node
;
1499 value
.address
= build_int_cst_type (ptr_type_node
, address
);
1501 value
.address
= NULL
;
1503 record_decl_address (ctx
, value
);
1506 if (class_member_p
&& code
== FUNCTION_DECL
)
1509 maybe_retrofit_in_chrg (decl
);
1511 grok_special_member_properties (decl
);
1514 if (template_decl_p
)
1516 if (RECORD_OR_UNION_CODE_P (code
))
1517 safe_pushtag (identifier
, TREE_TYPE (decl
), ts_current
);
1519 decl
= safe_push_template_decl (decl
);
1521 tree tdecl
= NULL_TREE
;
1523 tdecl
= finish_member_template_decl (decl
);
1525 end_template_decl ();
1527 /* We only support one level of templates, because we only
1528 support declaring generics; actual definitions are only of
1530 gcc_assert (!template_parm_scope_p ());
1533 finish_member_declaration (tdecl
);
1535 else if (RECORD_OR_UNION_CODE_P (code
))
1536 safe_pushtag (identifier
, TREE_TYPE (decl
), ts_current
);
1537 else if (class_member_p
)
1538 finish_member_declaration (decl
);
1540 decl
= safe_pushdecl_maybe_friend (decl
, false);
1543 /* Don't crash after a duplicate declaration of a cdtor. */
1544 && TYPE_FIELDS (current_class_type
) == decl
)
1546 /* ctors and dtors clones are chained after DECL.
1547 However, we create the clones before TYPE_METHODS is
1548 reversed. We test for cloned methods after reversal,
1549 however, and the test requires the clones to follow
1550 DECL. So, we reverse the chain of clones now, so
1551 that it will come out in the right order after
1553 tree save
= DECL_CHAIN (decl
);
1554 DECL_CHAIN (decl
) = NULL_TREE
;
1555 clone_cdtor (decl
, /*update_methods=*/true);
1556 gcc_assert (TYPE_FIELDS (current_class_type
) == decl
);
1557 TYPE_FIELDS (current_class_type
)
1558 = nreverse (TYPE_FIELDS (current_class_type
));
1559 DECL_CHAIN (decl
) = save
;
1562 rest_of_decl_compilation (decl
, toplevel_bindings_p (), 0);
1564 return convert_out (ctx
->preserve (decl
));
1568 plugin_define_cdtor_clone (cc1_plugin::connection
*self
,
1571 gcc_address address
)
1573 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1574 tree decl
= convert_in (cdtor_in
);
1579 switch (CHARS2 (name
[0], name
[1]))
1581 case CHARS2 ('C', '1'): // in-charge constructor
1582 identifier
= complete_ctor_identifier
;
1585 case CHARS2 ('C', '2'): // not-in-charge constructor
1586 identifier
= base_ctor_identifier
;
1589 case CHARS2 ('C', '4'):
1590 identifier
= ctor_identifier
; // unified constructor
1593 case CHARS2 ('D', '0'): // deleting destructor
1594 identifier
= deleting_dtor_identifier
;
1597 case CHARS2 ('D', '1'): // in-charge destructor
1598 identifier
= complete_dtor_identifier
;
1601 case CHARS2 ('D', '2'): // not-in-charge destructor
1602 identifier
= base_dtor_identifier
;
1605 case CHARS2 ('D', '4'):
1606 identifier
= dtor_identifier
; // unified destructor
1614 gcc_assert (!ctor
!= !dtor
);
1616 ? (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl
)
1617 && DECL_NAME (decl
) == ctor_identifier
)
1618 : (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl
)
1619 && DECL_NAME (decl
) == dtor_identifier
));
1621 while (decl
&& DECL_NAME (decl
) != identifier
)
1623 decl
= DECL_CHAIN (decl
);
1624 if (decl
&& !DECL_CLONED_FUNCTION_P (decl
))
1629 record_decl_address (ctx
, build_decl_addr_value (decl
, address
));
1631 return convert_out (decl
);
1635 plugin_add_friend (cc1_plugin::connection
* /* self */,
1639 tree decl
= convert_in (decl_in
);
1640 tree type
= convert_in (type_in
);
1642 gcc_assert (type
|| at_class_scope_p ());
1645 type
= current_class_type
;
1647 gcc_assert (TREE_CODE (type
) == RECORD_TYPE
);
1650 make_friend_class (type
, TREE_TYPE (decl
), true);
1653 DECL_FRIEND_P (decl
) = true;
1654 add_friend (type
, decl
, true);
1661 plugin_build_pointer_type (cc1_plugin::connection
*,
1664 // No need to preserve a pointer type as the base type is preserved.
1665 return convert_out (build_pointer_type (convert_in (base_type
)));
1669 plugin_build_reference_type (cc1_plugin::connection
*,
1670 gcc_type base_type_in
,
1671 enum gcc_cp_ref_qualifiers rquals
)
1677 case GCC_CP_REF_QUAL_LVALUE
:
1680 case GCC_CP_REF_QUAL_RVALUE
:
1683 case GCC_CP_REF_QUAL_NONE
:
1688 tree rtype
= cp_build_reference_type (convert_in (base_type_in
), rval
);
1690 return convert_out (rtype
);
1694 start_class_def (tree type
,
1695 const gcc_vbase_array
*base_classes
)
1700 for (int i
= 0; i
< base_classes
->n_elements
; i
++)
1704 gcc_assert ((base_classes
->flags
[i
] & GCC_CP_SYMBOL_MASK
)
1705 == GCC_CP_SYMBOL_BASECLASS
);
1707 switch (base_classes
->flags
[i
] & GCC_CP_ACCESS_MASK
)
1709 case GCC_CP_ACCESS_PRIVATE
:
1710 access
= ridpointers
[(int)RID_PRIVATE
];
1713 case GCC_CP_ACCESS_PROTECTED
:
1714 access
= ridpointers
[(int)RID_PROTECTED
];
1717 case GCC_CP_ACCESS_PUBLIC
:
1718 access
= ridpointers
[(int)RID_PUBLIC
];
1725 tree base
= finish_base_specifier
1726 (convert_in (base_classes
->elements
[i
]), access
,
1727 (base_classes
->flags
[i
] & GCC_CP_FLAG_BASECLASS_VIRTUAL
) != 0);
1728 TREE_CHAIN (base
) = bases
;
1731 bases
= nreverse (bases
);
1733 xref_basetypes (type
, bases
);
1734 begin_class_definition (type
);
1739 plugin_start_class_type (cc1_plugin::connection
*self
,
1740 gcc_decl typedecl_in
,
1741 const gcc_vbase_array
*base_classes
,
1742 const char *filename
,
1743 unsigned int line_number
)
1745 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1746 location_t loc
= ctx
->get_location_t (filename
, line_number
);
1747 tree typedecl
= convert_in (typedecl_in
);
1748 tree type
= TREE_TYPE (typedecl
);
1750 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type
)));
1751 gcc_assert (!COMPLETE_TYPE_P (type
));
1753 DECL_SOURCE_LOCATION (typedecl
) = loc
;
1755 tree result
= start_class_def (type
, base_classes
);
1757 return convert_out (ctx
->preserve (result
));
1761 plugin_start_closure_class_type (cc1_plugin::connection
*self
,
1763 gcc_decl extra_scope_in
,
1764 enum gcc_cp_symbol_kind flags
,
1765 const char *filename
,
1766 unsigned int line_number
)
1768 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1769 tree extra_scope
= convert_in (extra_scope_in
);
1771 gcc_assert ((flags
& GCC_CP_SYMBOL_MASK
) == GCC_CP_SYMBOL_LAMBDA_CLOSURE
);
1772 gcc_assert ((flags
& (~(GCC_CP_SYMBOL_MASK
| GCC_CP_ACCESS_MASK
))) == 0);
1774 gcc_assert (!(flags
& GCC_CP_ACCESS_MASK
) == !at_class_scope_p ());
1776 /* See at_fake_function_scope_p. */
1777 gcc_assert (!at_function_scope_p ());
1781 if (TREE_CODE (extra_scope
) == PARM_DECL
)
1783 gcc_assert (at_fake_function_scope_p ());
1784 /* Check that the given extra_scope is one of the parameters of
1785 the current function. */
1786 for (tree parm
= DECL_ARGUMENTS (current_function_decl
);
1787 ; parm
= DECL_CHAIN (parm
))
1790 if (parm
== extra_scope
)
1794 else if (TREE_CODE (extra_scope
) == FIELD_DECL
)
1796 gcc_assert (at_class_scope_p ());
1797 gcc_assert (DECL_CONTEXT (extra_scope
) == current_class_type
);
1800 /* FIXME: does this ever really occur? */
1801 gcc_assert (TREE_CODE (extra_scope
) == VAR_DECL
);
1804 tree lambda_expr
= build_lambda_expr ();
1806 LAMBDA_EXPR_LOCATION (lambda_expr
) = ctx
->get_location_t (filename
,
1809 tree type
= begin_lambda_type (lambda_expr
);
1811 /* Instead of calling record_lambda_scope, do this: */
1812 LAMBDA_EXPR_EXTRA_SCOPE (lambda_expr
) = extra_scope
;
1813 LAMBDA_EXPR_DISCRIMINATOR (lambda_expr
) = discriminator
;
1815 tree decl
= TYPE_NAME (type
);
1816 determine_visibility (decl
);
1817 set_access_flags (decl
, flags
);
1819 return convert_out (ctx
->preserve (type
));
1823 plugin_build_lambda_expr (cc1_plugin::connection
*self
,
1824 gcc_type closure_type_in
)
1826 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1827 tree closure_type
= convert_in (closure_type_in
);
1829 gcc_assert (LAMBDA_TYPE_P (closure_type
));
1831 tree lambda_expr
= CLASSTYPE_LAMBDA_EXPR (closure_type
);
1833 tree lambda_object
= build_lambda_object (lambda_expr
);
1835 return convert_out (ctx
->preserve (lambda_object
));
1839 plugin_build_field (cc1_plugin::connection
*,
1840 const char *field_name
,
1841 gcc_type field_type_in
,
1842 enum gcc_cp_symbol_kind flags
,
1843 unsigned long bitsize
,
1844 unsigned long bitpos
)
1846 tree record_or_union_type
= current_class_type
;
1847 tree field_type
= convert_in (field_type_in
);
1849 gcc_assert (at_class_scope_p ());
1850 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type
)));
1851 gcc_assert ((flags
& GCC_CP_SYMBOL_MASK
) == GCC_CP_SYMBOL_FIELD
);
1852 gcc_assert ((flags
& (~(GCC_CP_SYMBOL_MASK
| GCC_CP_ACCESS_MASK
1853 | GCC_CP_FLAG_MASK_FIELD
))) == 0);
1854 gcc_assert ((flags
& GCC_CP_ACCESS_MASK
));
1856 /* Note that gdb does not preserve the location of field decls, so
1857 we can't provide a decent location here. */
1858 tree decl
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
,
1859 get_identifier (field_name
), field_type
);
1860 DECL_FIELD_CONTEXT (decl
) = record_or_union_type
;
1862 set_access_flags (decl
, flags
);
1864 if ((flags
& GCC_CP_FLAG_FIELD_MUTABLE
) != 0)
1865 DECL_MUTABLE_P (decl
) = 1;
1867 if (TREE_CODE (field_type
) == INTEGER_TYPE
1868 && TYPE_PRECISION (field_type
) != bitsize
)
1870 DECL_BIT_FIELD_TYPE (decl
) = field_type
;
1872 = c_build_bitfield_integer_type (bitsize
, TYPE_UNSIGNED (field_type
));
1875 SET_DECL_MODE (decl
, TYPE_MODE (TREE_TYPE (decl
)));
1877 // There's no way to recover this from DWARF.
1878 SET_DECL_OFFSET_ALIGN (decl
, TYPE_PRECISION (pointer_sized_int_node
));
1880 tree pos
= bitsize_int (bitpos
);
1881 pos_from_bit (&DECL_FIELD_OFFSET (decl
), &DECL_FIELD_BIT_OFFSET (decl
),
1882 DECL_OFFSET_ALIGN (decl
), pos
);
1884 DECL_SIZE (decl
) = bitsize_int (bitsize
);
1885 DECL_SIZE_UNIT (decl
) = size_int ((bitsize
+ BITS_PER_UNIT
- 1)
1888 DECL_CHAIN (decl
) = TYPE_FIELDS (record_or_union_type
);
1889 TYPE_FIELDS (record_or_union_type
) = decl
;
1891 return convert_out (decl
);
1895 plugin_finish_class_type (cc1_plugin::connection
*,
1896 unsigned long size_in_bytes
)
1898 tree record_or_union_type
= current_class_type
;
1900 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type
)));
1902 finish_struct (record_or_union_type
, NULL
);
1904 gcc_assert (compare_tree_int (TYPE_SIZE_UNIT (record_or_union_type
),
1905 size_in_bytes
) == 0);
1911 plugin_start_enum_type (cc1_plugin::connection
*self
,
1913 gcc_type underlying_int_type_in
,
1914 enum gcc_cp_symbol_kind flags
,
1915 const char *filename
,
1916 unsigned int line_number
)
1918 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
1919 tree underlying_int_type
= convert_in (underlying_int_type_in
);
1921 gcc_assert ((flags
& GCC_CP_SYMBOL_MASK
) == GCC_CP_SYMBOL_ENUM
);
1922 gcc_assert ((flags
& (~(GCC_CP_SYMBOL_MASK
| GCC_CP_ACCESS_MASK
1923 | GCC_CP_FLAG_MASK_ENUM
))) == 0);
1924 gcc_assert (!(flags
& GCC_CP_ACCESS_MASK
) == !at_class_scope_p ());
1926 if (underlying_int_type
== error_mark_node
)
1927 return convert_out (error_mark_node
);
1929 bool is_new_type
= false;
1931 tree id
= name
? get_identifier (name
) : make_anon_name ();
1933 tree type
= start_enum (id
, NULL_TREE
,
1934 underlying_int_type
,
1935 /* attributes = */ NULL_TREE
,
1936 !!(flags
& GCC_CP_FLAG_ENUM_SCOPED
), &is_new_type
);
1938 gcc_assert (is_new_type
);
1940 location_t loc
= ctx
->get_location_t (filename
, line_number
);
1941 tree type_decl
= TYPE_NAME (type
);
1942 DECL_SOURCE_LOCATION (type_decl
) = loc
;
1943 SET_OPAQUE_ENUM_P (type
, false);
1945 set_access_flags (type_decl
, flags
);
1947 return convert_out (ctx
->preserve (type
));
1951 plugin_build_enum_constant (cc1_plugin::connection
*,
1952 gcc_type enum_type_in
,
1954 unsigned long value
)
1956 tree enum_type
= convert_in (enum_type_in
);
1958 gcc_assert (TREE_CODE (enum_type
) == ENUMERAL_TYPE
);
1960 build_enumerator (get_identifier (name
), build_int_cst (enum_type
, value
),
1961 enum_type
, NULL_TREE
, BUILTINS_LOCATION
);
1963 return convert_out (TREE_VALUE (TYPE_VALUES (enum_type
)));
1967 plugin_finish_enum_type (cc1_plugin::connection
*,
1968 gcc_type enum_type_in
)
1970 tree enum_type
= convert_in (enum_type_in
);
1972 finish_enum_value_list (enum_type
);
1973 finish_enum (enum_type
);
1979 plugin_build_function_type (cc1_plugin::connection
*self
,
1980 gcc_type return_type_in
,
1981 const struct gcc_type_array
*argument_types_in
,
1984 tree
*argument_types
;
1985 tree return_type
= convert_in (return_type_in
);
1988 argument_types
= new tree
[argument_types_in
->n_elements
];
1989 for (int i
= 0; i
< argument_types_in
->n_elements
; ++i
)
1990 argument_types
[i
] = convert_in (argument_types_in
->elements
[i
]);
1993 result
= build_varargs_function_type_array (return_type
,
1994 argument_types_in
->n_elements
,
1997 result
= build_function_type_array (return_type
,
1998 argument_types_in
->n_elements
,
2001 delete[] argument_types
;
2003 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2004 return convert_out (ctx
->preserve (result
));
2010 plugin_add_function_default_args (cc1_plugin::connection
*self
,
2011 gcc_type function_type_in
,
2012 const struct gcc_cp_function_args
*defaults
)
2014 tree function_type
= convert_in (function_type_in
);
2016 gcc_assert (TREE_CODE (function_type
) == FUNCTION_TYPE
);
2018 if (!defaults
|| !defaults
->n_elements
)
2019 return function_type_in
;
2021 tree pargs
= TYPE_ARG_TYPES (function_type
);
2022 tree nargs
= NULL_TREE
;
2024 /* Build a reversed copy of the list of default-less arguments in
2025 NARGS. At the end of the loop, PARGS will point to the end of
2026 the argument list, or to the first argument that had a default
2028 while (pargs
&& TREE_VALUE (pargs
) != void_list_node
2029 && !TREE_PURPOSE (pargs
))
2031 nargs
= tree_cons (NULL_TREE
, TREE_VALUE (pargs
), nargs
);
2032 pargs
= TREE_CHAIN (pargs
);
2035 /* Set the defaults in the now-leading NARGS, taking into account
2036 that NARGS is reversed but DEFAULTS->elements isn't. */
2037 tree ndargs
= nargs
;
2038 int i
= defaults
->n_elements
;
2041 gcc_assert (ndargs
);
2042 tree deflt
= convert_in (defaults
->elements
[i
]);
2044 deflt
= error_mark_node
;
2045 TREE_PURPOSE (ndargs
) = deflt
;
2046 ndargs
= TREE_CHAIN (ndargs
);
2049 /* Finally, reverse NARGS, and append the remaining PARGS that
2050 already had defaults. */
2051 nargs
= nreverse (nargs
);
2052 nargs
= chainon (nargs
, pargs
);
2054 tree result
= build_function_type (TREE_TYPE (function_type
), nargs
);
2056 /* Copy exceptions, attributes and whatnot. */
2057 result
= build_exception_variant (result
,
2058 TYPE_RAISES_EXCEPTIONS (function_type
));
2059 result
= cp_build_type_attribute_variant (result
,
2060 TYPE_ATTRIBUTES (function_type
));
2062 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2063 return convert_out (ctx
->preserve (result
));
2067 plugin_set_deferred_function_default_args (cc1_plugin::connection
*,
2068 gcc_decl function_in
,
2069 const struct gcc_cp_function_args
2072 tree function
= convert_in (function_in
);
2074 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
2076 if (!defaults
|| !defaults
->n_elements
)
2079 tree arg
= FUNCTION_FIRST_USER_PARMTYPE (function
);
2081 for (int i
= 0; i
< defaults
->n_elements
; i
++)
2083 while (arg
&& TREE_PURPOSE (arg
) != error_mark_node
)
2084 arg
= TREE_CHAIN (arg
);
2089 TREE_PURPOSE (arg
) = convert_in (defaults
->elements
[i
]);
2090 arg
= TREE_CHAIN (arg
);
2099 plugin_get_function_parameter_decl (cc1_plugin::connection
*,
2100 gcc_decl function_in
,
2103 tree function
= convert_in (function_in
);
2105 gcc_assert (TREE_CODE (function
) == FUNCTION_DECL
);
2109 gcc_assert (TREE_CODE (TREE_TYPE (function
)) == METHOD_TYPE
);
2111 return convert_out (DECL_ARGUMENTS (function
));
2114 gcc_assert (index
>= 0);
2116 tree args
= FUNCTION_FIRST_USER_PARM (function
);
2118 for (int i
= 0; args
&& i
< index
; i
++)
2119 args
= DECL_CHAIN (args
);
2121 return convert_out (args
);
2125 plugin_build_exception_spec_variant (cc1_plugin::connection
*self
,
2126 gcc_type function_type_in
,
2127 const struct gcc_type_array
*except_types_in
)
2129 tree function_type
= convert_in (function_type_in
);
2130 tree except_types
= NULL_TREE
;
2132 if (!except_types_in
)
2133 except_types
= noexcept_false_spec
;
2134 else if (!except_types_in
->n_elements
)
2135 except_types
= empty_except_spec
;
2137 for (int i
= 0; i
< except_types_in
->n_elements
; i
++)
2138 except_types
= add_exception_specifier (except_types
,
2140 (except_types_in
->elements
[i
]),
2143 function_type
= build_exception_variant (function_type
,
2146 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2147 return convert_out (ctx
->preserve (function_type
));
2151 plugin_build_method_type (cc1_plugin::connection
*self
,
2152 gcc_type class_type_in
,
2153 gcc_type func_type_in
,
2154 enum gcc_cp_qualifiers quals_in
,
2155 enum gcc_cp_ref_qualifiers rquals_in
)
2157 tree class_type
= convert_in (class_type_in
);
2158 tree func_type
= convert_in (func_type_in
);
2159 cp_cv_quals quals
= 0;
2160 cp_ref_qualifier rquals
;
2162 if ((quals_in
& GCC_CP_QUALIFIER_CONST
) != 0)
2163 quals
|= TYPE_QUAL_CONST
;
2164 if ((quals_in
& GCC_CP_QUALIFIER_VOLATILE
) != 0)
2165 quals
|= TYPE_QUAL_VOLATILE
;
2166 gcc_assert ((quals_in
& GCC_CP_QUALIFIER_RESTRICT
) == 0);
2170 case GCC_CP_REF_QUAL_NONE
:
2171 rquals
= REF_QUAL_NONE
;
2173 case GCC_CP_REF_QUAL_LVALUE
:
2174 rquals
= REF_QUAL_LVALUE
;
2176 case GCC_CP_REF_QUAL_RVALUE
:
2177 rquals
= REF_QUAL_RVALUE
;
2183 tree method_type
= class_type
2184 ? build_memfn_type (func_type
, class_type
, quals
, rquals
)
2185 : apply_memfn_quals (func_type
, quals
, rquals
);
2187 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2188 return convert_out (ctx
->preserve (method_type
));
2192 plugin_build_pointer_to_member_type (cc1_plugin::connection
*self
,
2193 gcc_type class_type_in
,
2194 gcc_type member_type_in
)
2196 tree class_type
= convert_in (class_type_in
);
2197 tree member_type
= convert_in (member_type_in
);
2199 tree memptr_type
= build_ptrmem_type (class_type
, member_type
);
2201 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2202 return convert_out (ctx
->preserve (memptr_type
));
2206 plugin_start_template_decl (cc1_plugin::connection
*)
2208 begin_template_parm_list ();
2210 TP_PARM_LIST
= NULL_TREE
;
2216 plugin_get_type_decl (cc1_plugin::connection
*,
2219 tree type
= convert_in (type_in
);
2221 tree name
= TYPE_NAME (type
);
2224 return convert_out (name
);
2228 plugin_get_decl_type (cc1_plugin::connection
*,
2231 tree decl
= convert_in (decl_in
);
2233 tree type
= TREE_TYPE (decl
);
2236 return convert_out (type
);
2240 plugin_build_type_template_parameter (cc1_plugin::connection
*self
,
2242 int /* bool */ pack_p
,
2243 gcc_type default_type
,
2244 const char *filename
,
2245 unsigned int line_number
)
2247 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2248 location_t loc
= ctx
->get_location_t (filename
, line_number
);
2250 gcc_assert (template_parm_scope_p ());
2252 tree parm
= finish_template_type_parm (class_type_node
, get_identifier (id
));
2253 parm
= build_tree_list (convert_in (default_type
), parm
);
2255 gcc_assert (!(pack_p
&& default_type
));
2257 /* Create a type and a decl for the type parm, and add the decl to
2259 TP_PARM_LIST
= process_template_parm (TP_PARM_LIST
, loc
, parm
,
2260 /* is_non_type = */ false, pack_p
);
2262 /* Locate the decl of the newly-added, processed template parm. */
2263 parm
= TREE_VALUE (tree_last (TP_PARM_LIST
));
2265 /* Return its type. */
2266 return convert_out (ctx
->preserve (TREE_TYPE (parm
)));
2270 plugin_build_template_template_parameter (cc1_plugin::connection
*self
,
2272 int /* bool */ pack_p
,
2273 gcc_utempl default_templ
,
2274 const char *filename
,
2275 unsigned int line_number
)
2277 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2278 location_t loc
= ctx
->get_location_t (filename
, line_number
);
2280 gcc_assert (template_parm_scope_p ());
2282 /* Finish the template parm list that started this template parm. */
2283 end_template_parm_list (TP_PARM_LIST
);
2285 gcc_assert (template_parm_scope_p ());
2287 tree parm
= finish_template_template_parm (class_type_node
,
2288 get_identifier (id
));
2289 parm
= build_tree_list (convert_in (default_templ
), parm
);
2291 gcc_assert (!(pack_p
&& default_templ
));
2293 /* Create a type and a decl for the template parm, and add the decl
2295 TP_PARM_LIST
= process_template_parm (TP_PARM_LIST
, loc
, parm
,
2296 /* is_non_type = */ false, pack_p
);
2298 /* Locate the decl of the newly-added, processed template parm. */
2299 parm
= TREE_VALUE (tree_last (TP_PARM_LIST
));
2301 return convert_out (ctx
->preserve (parm
));
2305 plugin_build_value_template_parameter (cc1_plugin::connection
*self
,
2308 gcc_expr default_value
,
2309 const char *filename
,
2310 unsigned int line_number
)
2312 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2313 location_t loc
= ctx
->get_location_t (filename
, line_number
);
2315 gcc_assert (template_parm_scope_p ());
2317 cp_declarator declarator
;
2318 memset (&declarator
, 0, sizeof (declarator
));
2319 // &declarator = make_id_declarator (NULL, get_identifier (id), sfk_none):
2320 declarator
.kind
= cdk_id
;
2321 declarator
.u
.id
.qualifying_scope
= NULL
;
2322 declarator
.u
.id
.unqualified_name
= get_identifier (id
);
2323 declarator
.u
.id
.sfk
= sfk_none
;
2325 cp_decl_specifier_seq declspec
;
2326 memset (&declspec
, 0, sizeof (declspec
));
2327 // cp_parser_set_decl_spec_type (&declspec, convert_in (type), -token-, false):
2328 declspec
.any_specifiers_p
= declspec
.any_type_specifiers_p
= true;
2329 declspec
.type
= convert_in (type
);
2330 declspec
.locations
[ds_type_spec
] = loc
;
2332 tree parm
= grokdeclarator (&declarator
, &declspec
, TPARM
, 0, 0);
2333 parm
= build_tree_list (convert_in (default_value
), parm
);
2335 /* Create a type and a decl for the template parm, and add the decl
2337 TP_PARM_LIST
= process_template_parm (TP_PARM_LIST
, loc
, parm
,
2338 /* is_non_type = */ true, false);
2340 /* Locate the decl of the newly-added, processed template parm. */
2341 parm
= TREE_VALUE (tree_last (TP_PARM_LIST
));
2343 return convert_out (ctx
->preserve (parm
));
2347 targlist (const gcc_cp_template_args
*targs
)
2349 int n
= targs
->n_elements
;
2350 tree vec
= make_tree_vec (n
);
2353 switch (targs
->kinds
[n
])
2355 case GCC_CP_TPARG_VALUE
:
2356 TREE_VEC_ELT (vec
, n
) = convert_in (targs
->elements
[n
].value
);
2358 case GCC_CP_TPARG_CLASS
:
2359 TREE_VEC_ELT (vec
, n
) = convert_in (targs
->elements
[n
].type
);
2361 case GCC_CP_TPARG_TEMPL
:
2362 TREE_VEC_ELT (vec
, n
) = convert_in (targs
->elements
[n
].templ
);
2364 case GCC_CP_TPARG_PACK
:
2365 TREE_VEC_ELT (vec
, n
) = convert_in (targs
->elements
[n
].pack
);
2375 plugin_build_dependent_typename (cc1_plugin::connection
*self
,
2376 gcc_type enclosing_type
,
2378 const gcc_cp_template_args
*targs
)
2380 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2381 tree type
= convert_in (enclosing_type
);
2382 tree name
= get_identifier (id
);
2384 name
= build_min_nt_loc (/*loc=*/0, TEMPLATE_ID_EXPR
,
2385 name
, targlist (targs
));
2386 tree res
= make_typename_type (type
, name
, typename_type
,
2387 /*complain=*/tf_error
);
2388 return convert_out (ctx
->preserve (res
));
2392 plugin_build_dependent_class_template (cc1_plugin::connection
*self
,
2393 gcc_type enclosing_type
,
2396 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2397 tree type
= convert_in (enclosing_type
);
2398 tree name
= get_identifier (id
);
2399 tree res
= make_unbound_class_template (type
, name
, NULL_TREE
,
2400 /*complain=*/tf_error
);
2401 return convert_out (ctx
->preserve (res
));
2405 plugin_build_dependent_type_template_id (cc1_plugin::connection
*self
,
2406 gcc_utempl template_decl
,
2407 const gcc_cp_template_args
*targs
)
2409 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2410 tree type
= convert_in (template_decl
);
2411 tree decl
= finish_template_type (type
, targlist (targs
),
2412 /*entering_scope=*/false);
2413 return convert_out (ctx
->preserve (TREE_TYPE (decl
)));
2417 plugin_build_dependent_expr (cc1_plugin::connection
*self
,
2418 gcc_decl enclosing_scope
,
2419 enum gcc_cp_symbol_kind flags
,
2421 gcc_type conv_type_in
,
2422 const gcc_cp_template_args
*targs
)
2424 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2425 tree scope
= convert_in (enclosing_scope
);
2426 tree conv_type
= convert_in (conv_type_in
);
2429 if (TREE_CODE (scope
) != NAMESPACE_DECL
)
2431 tree type
= TREE_TYPE (scope
);
2432 gcc_assert (TYPE_NAME (type
) == scope
);
2436 if (flags
== (GCC_CP_SYMBOL_FUNCTION
| GCC_CP_FLAG_SPECIAL_FUNCTION
))
2438 bool assop
= false, convop
= false;
2439 tree_code opcode
= ERROR_MARK
;
2441 switch (CHARS2 (name
[0], name
[1]))
2443 case CHARS2 ('C', 0x0): // ctor base declaration
2444 case CHARS2 ('C', ' '):
2445 case CHARS2 ('C', '1'):
2446 case CHARS2 ('C', '2'):
2447 case CHARS2 ('C', '4'):
2448 identifier
= ctor_identifier
;
2450 case CHARS2 ('D', 0x0): // dtor base declaration
2451 case CHARS2 ('D', ' '):
2452 case CHARS2 ('D', '0'):
2453 case CHARS2 ('D', '1'):
2454 case CHARS2 ('D', '2'):
2455 case CHARS2 ('D', '4'):
2456 gcc_assert (!targs
);
2457 identifier
= dtor_identifier
;
2459 case CHARS2 ('n', 'w'): // operator new
2462 case CHARS2 ('n', 'a'): // operator new[]
2463 opcode
= VEC_NEW_EXPR
;
2465 case CHARS2 ('d', 'l'): // operator delete
2466 opcode
= DELETE_EXPR
;
2468 case CHARS2 ('d', 'a'): // operator delete[]
2469 opcode
= VEC_DELETE_EXPR
;
2471 case CHARS2 ('p', 's'): // operator + (unary)
2474 case CHARS2 ('n', 'g'): // operator - (unary)
2475 opcode
= MINUS_EXPR
;
2477 case CHARS2 ('a', 'd'): // operator & (unary)
2478 opcode
= BIT_AND_EXPR
;
2480 case CHARS2 ('d', 'e'): // operator * (unary)
2483 case CHARS2 ('c', 'o'): // operator ~
2484 opcode
= BIT_NOT_EXPR
;
2486 case CHARS2 ('p', 'l'): // operator +
2489 case CHARS2 ('m', 'i'): // operator -
2490 opcode
= MINUS_EXPR
;
2492 case CHARS2 ('m', 'l'): // operator *
2495 case CHARS2 ('d', 'v'): // operator /
2496 opcode
= TRUNC_DIV_EXPR
;
2498 case CHARS2 ('r', 'm'): // operator %
2499 opcode
= TRUNC_MOD_EXPR
;
2501 case CHARS2 ('a', 'n'): // operator &
2502 opcode
= BIT_AND_EXPR
;
2504 case CHARS2 ('o', 'r'): // operator |
2505 opcode
= BIT_IOR_EXPR
;
2507 case CHARS2 ('e', 'o'): // operator ^
2508 opcode
= BIT_XOR_EXPR
;
2510 case CHARS2 ('a', 'S'): // operator =
2514 case CHARS2 ('p', 'L'): // operator +=
2518 case CHARS2 ('m', 'I'): // operator -=
2519 opcode
= MINUS_EXPR
;
2522 case CHARS2 ('m', 'L'): // operator *=
2526 case CHARS2 ('d', 'V'): // operator /=
2527 opcode
= TRUNC_DIV_EXPR
;
2530 case CHARS2 ('r', 'M'): // operator %=
2531 opcode
= TRUNC_MOD_EXPR
;
2534 case CHARS2 ('a', 'N'): // operator &=
2535 opcode
= BIT_AND_EXPR
;
2538 case CHARS2 ('o', 'R'): // operator |=
2539 opcode
= BIT_IOR_EXPR
;
2542 case CHARS2 ('e', 'O'): // operator ^=
2543 opcode
= BIT_XOR_EXPR
;
2546 case CHARS2 ('l', 's'): // operator <<
2547 opcode
= LSHIFT_EXPR
;
2549 case CHARS2 ('r', 's'): // operator >>
2550 opcode
= RSHIFT_EXPR
;
2552 case CHARS2 ('l', 'S'): // operator <<=
2553 opcode
= LSHIFT_EXPR
;
2556 case CHARS2 ('r', 'S'): // operator >>=
2557 opcode
= RSHIFT_EXPR
;
2560 case CHARS2 ('e', 'q'): // operator ==
2563 case CHARS2 ('n', 'e'): // operator !=
2566 case CHARS2 ('l', 't'): // operator <
2569 case CHARS2 ('g', 't'): // operator >
2572 case CHARS2 ('l', 'e'): // operator <=
2575 case CHARS2 ('g', 'e'): // operator >=
2578 case CHARS2 ('n', 't'): // operator !
2579 opcode
= TRUTH_NOT_EXPR
;
2581 case CHARS2 ('a', 'a'): // operator &&
2582 opcode
= TRUTH_ANDIF_EXPR
;
2584 case CHARS2 ('o', 'o'): // operator ||
2585 opcode
= TRUTH_ORIF_EXPR
;
2587 case CHARS2 ('p', 'p'): // operator ++
2588 opcode
= POSTINCREMENT_EXPR
;
2590 case CHARS2 ('m', 'm'): // operator --
2591 opcode
= PREDECREMENT_EXPR
;
2593 case CHARS2 ('c', 'm'): // operator ,
2594 opcode
= COMPOUND_EXPR
;
2596 case CHARS2 ('p', 'm'): // operator ->*
2597 opcode
= MEMBER_REF
;
2599 case CHARS2 ('p', 't'): // operator ->
2600 opcode
= COMPONENT_REF
;
2602 case CHARS2 ('c', 'l'): // operator ()
2605 case CHARS2 ('i', 'x'): // operator []
2608 case CHARS2 ('c', 'v'): // operator <T> (conversion operator)
2610 identifier
= make_conv_op_name (conv_type
);
2613 case CHARS2 ('l', 'i'): // operator "" <id>
2615 char *id
= (char *)name
+ 2;
2616 bool freeid
= false;
2617 if (*id
>= '0' && *id
<= '9')
2626 while (*id
&& *id
>= '0' && *id
<= '9');
2627 id
= xstrndup (id
, len
);
2630 identifier
= cp_literal_operator_id (id
);
2635 case CHARS2 ('q', 'u'): // ternary operator, not overloadable.
2640 gcc_assert (convop
|| !conv_type
);
2642 if (opcode
!= ERROR_MARK
)
2643 identifier
= ovl_op_identifier (assop
, opcode
);
2645 gcc_assert (identifier
);
2649 gcc_assert (flags
== GCC_CP_SYMBOL_MASK
);
2650 gcc_assert (!conv_type
);
2651 identifier
= get_identifier (name
);
2653 tree res
= identifier
;
2655 res
= lookup_name_real (res
, 0, 0, true, 0, 0);
2656 else if (!TYPE_P (scope
) || !dependent_scope_p (scope
))
2658 res
= lookup_qualified_name (scope
, res
, false, true);
2659 /* We've already resolved the name in the scope, so skip the
2660 build_qualified_name call below. */
2664 res
= lookup_template_function (res
, targlist (targs
));
2666 res
= build_qualified_name (NULL_TREE
, scope
, res
, !!targs
);
2667 return convert_out (ctx
->preserve (res
));
2671 plugin_build_literal_expr (cc1_plugin::connection
*self
,
2672 gcc_type type
, unsigned long value
)
2674 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2675 tree t
= convert_in (type
);
2676 tree val
= build_int_cst_type (t
, (unsigned HOST_WIDE_INT
) value
);
2677 return convert_out (ctx
->preserve (val
));
2681 plugin_build_decl_expr (cc1_plugin::connection
*self
,
2685 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2686 tree decl
= convert_in (decl_in
);
2687 gcc_assert (DECL_P (decl
));
2691 gcc_assert (DECL_CLASS_SCOPE_P (decl
));
2692 result
= build_offset_ref (DECL_CONTEXT (decl
), decl
,
2693 /*address_p=*/true, tf_error
);
2695 return convert_out (ctx
->preserve (result
));
2699 plugin_build_unary_expr (cc1_plugin::connection
*self
,
2700 const char *unary_op
,
2703 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2704 tree op0
= convert_in (operand
);
2705 tree_code opcode
= ERROR_MARK
;
2706 bool global_scope_p
= false;
2709 switch (CHARS2 (unary_op
[0], unary_op
[1]))
2711 case CHARS2 ('p', 's'): // operator + (unary)
2712 opcode
= UNARY_PLUS_EXPR
;
2714 case CHARS2 ('n', 'g'): // operator - (unary)
2715 opcode
= NEGATE_EXPR
;
2717 case CHARS2 ('a', 'd'): // operator & (unary)
2720 case CHARS2 ('d', 'e'): // operator * (unary)
2721 opcode
= INDIRECT_REF
;
2723 case CHARS2 ('c', 'o'): // operator ~
2724 opcode
= BIT_NOT_EXPR
;
2726 case CHARS2 ('n', 't'): // operator !
2727 opcode
= TRUTH_NOT_EXPR
;
2729 case CHARS2 ('p', 'p'): // operator ++
2730 opcode
= unary_op
[2] == '_' ? PREINCREMENT_EXPR
: POSTINCREMENT_EXPR
;
2732 case CHARS2 ('m', 'm'): // operator --
2733 opcode
= unary_op
[2] == '_' ? PREDECREMENT_EXPR
: POSTDECREMENT_EXPR
;
2735 case CHARS2 ('n', 'x'): // noexcept
2736 opcode
= NOEXCEPT_EXPR
;
2738 case CHARS2 ('t', 'w'): // throw
2740 opcode
= THROW_EXPR
;
2742 case CHARS2 ('t', 'r'): // rethrow
2744 opcode
= THROW_EXPR
;
2746 case CHARS2 ('t', 'e'): // typeid (value)
2747 opcode
= TYPEID_EXPR
;
2749 case CHARS2 ('s', 'z'): // sizeof (value)
2750 opcode
= SIZEOF_EXPR
;
2752 case CHARS2 ('a', 'z'): // alignof (value)
2753 opcode
= ALIGNOF_EXPR
;
2755 case CHARS2 ('g', 's'): // global scope (for delete, delete[])
2756 gcc_assert (!global_scope_p
);
2757 global_scope_p
= true;
2760 case CHARS2 ('d', 'l'): // delete
2761 opcode
= DELETE_EXPR
;
2763 case CHARS2 ('d', 'a'): // delete[]
2764 opcode
= VEC_DELETE_EXPR
;
2766 case CHARS2 ('s', 'p'): // pack...
2767 opcode
= EXPR_PACK_EXPANSION
;
2769 case CHARS2 ('s', 'Z'): // sizeof...(pack)
2770 opcode
= TYPE_PACK_EXPANSION
; // Not really, but let's use its code.
2773 /* FIXME: __real__, __imag__? */
2779 gcc_assert (!global_scope_p
2780 || opcode
== DELETE_EXPR
|| opcode
== VEC_DELETE_EXPR
);
2782 processing_template_decl
++;
2783 bool template_dependent_p
= op0
2784 && (type_dependent_expression_p (op0
)
2785 || value_dependent_expression_p (op0
));
2786 if (!template_dependent_p
)
2787 processing_template_decl
--;
2791 gcc_assert (op0
|| opcode
== THROW_EXPR
);
2796 result
= finish_noexcept_expr (op0
, tf_error
);
2800 result
= build_throw (input_location
, op0
);
2804 result
= build_typeid (op0
, tf_error
);
2809 result
= cxx_sizeof_or_alignof_expr (input_location
,
2814 case VEC_DELETE_EXPR
:
2815 result
= delete_sanity (input_location
, op0
, NULL_TREE
,
2816 opcode
== VEC_DELETE_EXPR
,
2817 global_scope_p
, tf_error
);
2820 case EXPR_PACK_EXPANSION
:
2821 result
= make_pack_expansion (op0
);
2824 // We're using this for sizeof...(pack). */
2825 case TYPE_PACK_EXPANSION
:
2826 result
= make_pack_expansion (op0
);
2827 PACK_EXPANSION_SIZEOF_P (result
) = true;
2831 result
= build_x_unary_op (/*loc=*/0, opcode
, op0
, tf_error
);
2835 if (template_dependent_p
)
2836 processing_template_decl
--;
2838 return convert_out (ctx
->preserve (result
));
2842 plugin_build_binary_expr (cc1_plugin::connection
*self
,
2843 const char *binary_op
,
2847 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2848 tree op0
= convert_in (operand1
);
2849 tree op1
= convert_in (operand2
);
2850 tree_code opcode
= ERROR_MARK
;
2852 switch (CHARS2 (binary_op
[0], binary_op
[1]))
2854 case CHARS2 ('p', 'l'): // operator +
2857 case CHARS2 ('m', 'i'): // operator -
2858 opcode
= MINUS_EXPR
;
2860 case CHARS2 ('m', 'l'): // operator *
2863 case CHARS2 ('d', 'v'): // operator /
2864 opcode
= TRUNC_DIV_EXPR
;
2866 case CHARS2 ('r', 'm'): // operator %
2867 opcode
= TRUNC_MOD_EXPR
;
2869 case CHARS2 ('a', 'n'): // operator &
2870 opcode
= BIT_AND_EXPR
;
2872 case CHARS2 ('o', 'r'): // operator |
2873 opcode
= BIT_IOR_EXPR
;
2875 case CHARS2 ('e', 'o'): // operator ^
2876 opcode
= BIT_XOR_EXPR
;
2878 case CHARS2 ('l', 's'): // operator <<
2879 opcode
= LSHIFT_EXPR
;
2881 case CHARS2 ('r', 's'): // operator >>
2882 opcode
= RSHIFT_EXPR
;
2884 case CHARS2 ('e', 'q'): // operator ==
2887 case CHARS2 ('n', 'e'): // operator !=
2890 case CHARS2 ('l', 't'): // operator <
2893 case CHARS2 ('g', 't'): // operator >
2896 case CHARS2 ('l', 'e'): // operator <=
2899 case CHARS2 ('g', 'e'): // operator >=
2902 case CHARS2 ('a', 'a'): // operator &&
2903 opcode
= TRUTH_ANDIF_EXPR
;
2905 case CHARS2 ('o', 'o'): // operator ||
2906 opcode
= TRUTH_ORIF_EXPR
;
2908 case CHARS2 ('c', 'm'): // operator ,
2909 opcode
= COMPOUND_EXPR
;
2911 case CHARS2 ('p', 'm'): // operator ->*
2912 opcode
= MEMBER_REF
;
2914 case CHARS2 ('p', 't'): // operator ->
2915 opcode
= INDIRECT_REF
; // Not really! This will stand for
2916 // INDIRECT_REF followed by COMPONENT_REF
2919 case CHARS2 ('i', 'x'): // operator []
2922 case CHARS2 ('d', 's'): // operator .*
2923 opcode
= DOTSTAR_EXPR
;
2925 case CHARS2 ('d', 't'): // operator .
2926 opcode
= COMPONENT_REF
;
2933 processing_template_decl
++;
2934 bool template_dependent_p
= type_dependent_expression_p (op0
)
2935 || value_dependent_expression_p (op0
)
2936 || type_dependent_expression_p (op1
)
2937 || value_dependent_expression_p (op1
);
2938 if (!template_dependent_p
)
2939 processing_template_decl
--;
2945 case INDIRECT_REF
: // This is actually a "->".
2946 op0
= build_x_arrow (/*loc=*/0, op0
, tf_error
);
2949 result
= finish_class_member_access_expr (op0
, op1
,
2950 /*template_p=*/false,
2955 result
= build_x_binary_op (/*loc=*/0, opcode
, op0
, ERROR_MARK
,
2956 op1
, ERROR_MARK
, NULL
, tf_error
);
2960 if (template_dependent_p
)
2961 processing_template_decl
--;
2963 return convert_out (ctx
->preserve (result
));
2967 plugin_build_ternary_expr (cc1_plugin::connection
*self
,
2968 const char *ternary_op
,
2973 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2974 tree op0
= convert_in (operand1
);
2975 tree op1
= convert_in (operand2
);
2976 tree op2
= convert_in (operand3
);
2977 gcc_assert (CHARS2 (ternary_op
[0], ternary_op
[1])
2978 == CHARS2 ('q', 'u')); // ternary operator
2980 processing_template_decl
++;
2981 bool template_dependent_p
= type_dependent_expression_p (op0
)
2982 || value_dependent_expression_p (op0
)
2983 || type_dependent_expression_p (op1
)
2984 || value_dependent_expression_p (op1
)
2985 || type_dependent_expression_p (op2
)
2986 || value_dependent_expression_p (op2
);
2987 if (!template_dependent_p
)
2988 processing_template_decl
--;
2990 tree val
= build_x_conditional_expr (/*loc=*/0, op0
, op1
, op2
, tf_error
);
2992 if (template_dependent_p
)
2993 processing_template_decl
--;
2995 return convert_out (ctx
->preserve (val
));
2999 plugin_build_unary_type_expr (cc1_plugin::connection
*self
,
3000 const char *unary_op
,
3003 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3004 tree type
= convert_in (operand
);
3005 tree_code opcode
= ERROR_MARK
;
3007 switch (CHARS2 (unary_op
[0], unary_op
[1]))
3009 case CHARS2 ('t', 'i'): // typeid (type)
3010 opcode
= TYPEID_EXPR
;
3013 case CHARS2 ('s', 't'): // sizeof (type)
3014 opcode
= SIZEOF_EXPR
;
3016 case CHARS2 ('a', 't'): // alignof (type)
3017 opcode
= ALIGNOF_EXPR
;
3020 case CHARS2 ('s', 'Z'): // sizeof...(pack)
3021 opcode
= TYPE_PACK_EXPANSION
; // Not really, but let's use its code.
3024 // FIXME: do we have to handle "sp", for the size of a captured
3025 // template parameter pack from an alias template, taking
3026 // multiple template arguments?
3032 processing_template_decl
++;
3033 bool template_dependent_p
= dependent_type_p (type
);
3034 if (!template_dependent_p
)
3035 processing_template_decl
--;
3042 result
= get_typeid (type
, tf_error
);
3045 // We're using this for sizeof...(pack). */
3046 case TYPE_PACK_EXPANSION
:
3047 result
= make_pack_expansion (type
);
3048 PACK_EXPANSION_SIZEOF_P (result
) = true;
3052 /* Use the C++11 alignof semantics. */
3053 result
= cxx_sizeof_or_alignof_type (input_location
, type
,
3054 opcode
, true, true);
3057 if (template_dependent_p
)
3058 processing_template_decl
--;
3060 return convert_out (ctx
->preserve (result
));
3064 plugin_build_cast_expr (cc1_plugin::connection
*self
,
3065 const char *binary_op
,
3069 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3070 tree (*build_cast
)(location_t loc
, tree type
, tree expr
,
3071 tsubst_flags_t complain
) = NULL
;
3072 tree type
= convert_in (operand1
);
3073 tree expr
= convert_in (operand2
);
3075 switch (CHARS2 (binary_op
[0], binary_op
[1]))
3077 case CHARS2 ('d', 'c'): // dynamic_cast
3078 build_cast
= build_dynamic_cast
;
3081 case CHARS2 ('s', 'c'): // static_cast
3082 build_cast
= build_static_cast
;
3085 case CHARS2 ('c', 'c'): // const_cast
3086 build_cast
= build_const_cast
;
3089 case CHARS2 ('r', 'c'): // reinterpret_cast
3090 build_cast
= build_reinterpret_cast
;
3093 case CHARS2 ('c', 'v'): // C cast, conversion with one argument
3094 build_cast
= cp_build_c_cast
;
3101 processing_template_decl
++;
3102 bool template_dependent_p
= dependent_type_p (type
)
3103 || type_dependent_expression_p (expr
)
3104 || value_dependent_expression_p (expr
);
3105 if (!template_dependent_p
)
3106 processing_template_decl
--;
3108 tree val
= build_cast (input_location
, type
, expr
, tf_error
);
3110 if (template_dependent_p
)
3111 processing_template_decl
--;
3113 return convert_out (ctx
->preserve (val
));
3116 static inline vec
<tree
, va_gc
> *
3117 args_to_tree_vec (const struct gcc_cp_function_args
*args_in
)
3119 vec
<tree
, va_gc
> *args
= make_tree_vector ();
3120 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3121 vec_safe_push (args
, convert_in (args_in
->elements
[i
]));
3126 args_to_tree_list (const struct gcc_cp_function_args
*args_in
)
3128 tree args
, *tail
= &args
;
3129 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3131 *tail
= build_tree_list (NULL
, convert_in (args_in
->elements
[i
]));
3132 tail
= &TREE_CHAIN (*tail
);
3137 static inline vec
<constructor_elt
, va_gc
> *
3138 args_to_ctor_elts (const struct gcc_cp_function_args
*args_in
)
3140 vec
<constructor_elt
, va_gc
> *args
= NULL
;
3141 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3142 CONSTRUCTOR_APPEND_ELT (args
, NULL_TREE
, convert_in (args_in
->elements
[i
]));
3147 plugin_build_expression_list_expr (cc1_plugin::connection
*self
,
3148 const char *conv_op
,
3150 const struct gcc_cp_function_args
*values_in
)
3152 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3153 tree type
= convert_in (type_in
);
3157 switch (CHARS2 (conv_op
[0], conv_op
[1]))
3159 case CHARS2 ('c', 'v'): // conversion with parenthesized expression list
3160 gcc_assert (TYPE_P (type
));
3161 args
= args_to_tree_list (values_in
);
3162 result
= build_functional_cast (input_location
, type
, args
, tf_error
);
3165 case CHARS2 ('t', 'l'): // conversion with braced expression list
3167 gcc_assert (TYPE_P (type
));
3168 args
= make_node (CONSTRUCTOR
);
3169 CONSTRUCTOR_ELTS (args
) = args_to_ctor_elts (values_in
);
3170 CONSTRUCTOR_IS_DIRECT_INIT (args
) = 1;
3171 result
= finish_compound_literal (type
, args
, tf_error
);
3174 case CHARS2 ('i', 'l'): // untyped braced expression list
3176 result
= make_node (CONSTRUCTOR
);
3177 CONSTRUCTOR_ELTS (result
) = args_to_ctor_elts (values_in
);
3184 return convert_out (ctx
->preserve (result
));
3188 plugin_build_new_expr (cc1_plugin::connection
*self
,
3190 const struct gcc_cp_function_args
*placement_in
,
3192 const struct gcc_cp_function_args
*initializer_in
)
3194 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3195 tree type
= convert_in (type_in
);
3196 vec
<tree
, va_gc
> *placement
= NULL
, *initializer
= NULL
;
3197 bool global_scope_p
= false;
3201 placement
= args_to_tree_vec (placement_in
);
3203 initializer
= args_to_tree_vec (initializer_in
);
3205 gcc_assert (TYPE_P (type
));
3208 switch (CHARS2 (new_op
[0], new_op
[1]))
3210 case CHARS2 ('g', 's'):
3211 gcc_assert (!global_scope_p
);
3212 global_scope_p
= true;
3216 case CHARS2 ('n', 'w'): // non-array new
3217 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
3220 case CHARS2 ('n', 'a'): // array new
3221 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3222 gcc_assert (TYPE_DOMAIN (type
));
3224 // Compute the length of the outermost array type, then discard it.
3225 tree maxelt
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
3226 tree eltype
= TREE_TYPE (maxelt
);
3227 tree onecst
= integer_one_node
;
3229 processing_template_decl
++;
3230 bool template_dependent_p
= value_dependent_expression_p (maxelt
)
3231 || type_dependent_expression_p (maxelt
);
3232 if (!template_dependent_p
)
3234 processing_template_decl
--;
3235 onecst
= fold_convert (eltype
, onecst
);
3238 nelts
= fold_build2 (PLUS_EXPR
, eltype
, nelts
, onecst
);
3240 if (template_dependent_p
)
3241 processing_template_decl
--;
3243 type
= TREE_TYPE (type
);
3251 processing_template_decl
++;
3252 bool template_dependent_p
= dependent_type_p (type
)
3253 || value_dependent_expression_p (nelts
)
3255 && any_type_dependent_arguments_p (placement
))
3257 && any_type_dependent_arguments_p (initializer
));
3258 if (!template_dependent_p
)
3259 processing_template_decl
--;
3261 tree result
= build_new (input_location
, &placement
, type
, nelts
,
3262 &initializer
, global_scope_p
, tf_error
);
3264 if (template_dependent_p
)
3265 processing_template_decl
--;
3267 if (placement
!= NULL
)
3268 release_tree_vector (placement
);
3269 if (initializer
!= NULL
)
3270 release_tree_vector (initializer
);
3272 return convert_out (ctx
->preserve (result
));
3276 plugin_build_call_expr (cc1_plugin::connection
*self
,
3277 gcc_expr callable_in
, int qualified_p
,
3278 const struct gcc_cp_function_args
*args_in
)
3280 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3281 tree callable
= convert_in (callable_in
);
3284 vec
<tree
, va_gc
> *args
= args_to_tree_vec (args_in
);
3286 bool koenig_p
= false;
3287 if (!qualified_p
&& !args
->is_empty ())
3289 if (identifier_p (callable
))
3291 else if (is_overloaded_fn (callable
))
3293 tree fn
= get_first_fn (callable
);
3294 fn
= STRIP_TEMPLATE (fn
);
3296 if (!DECL_FUNCTION_MEMBER_P (fn
)
3297 && !DECL_LOCAL_FUNCTION_P (fn
))
3302 if (koenig_p
&& !any_type_dependent_arguments_p (args
))
3303 callable
= perform_koenig_lookup (callable
, args
, tf_none
);
3305 if (TREE_CODE (callable
) == COMPONENT_REF
)
3307 tree object
= TREE_OPERAND (callable
, 0);
3308 tree memfn
= TREE_OPERAND (callable
, 1);
3310 if (type_dependent_expression_p (object
)
3311 || (!BASELINK_P (memfn
) && TREE_CODE (memfn
) != FIELD_DECL
)
3312 || type_dependent_expression_p (memfn
)
3313 || any_type_dependent_arguments_p (args
))
3314 call_expr
= build_nt_call_vec (callable
, args
);
3315 else if (BASELINK_P (memfn
))
3316 call_expr
= build_new_method_call (object
, memfn
, &args
, NULL_TREE
,
3318 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
3322 call_expr
= finish_call_expr (callable
, &args
, false, false, tf_none
);
3324 else if (TREE_CODE (callable
) == OFFSET_REF
3325 || TREE_CODE (callable
) == MEMBER_REF
3326 || TREE_CODE (callable
) == DOTSTAR_EXPR
)
3327 call_expr
= build_offset_ref_call_from_tree (callable
, &args
, tf_none
);
3329 call_expr
= finish_call_expr (callable
, &args
,
3330 !!qualified_p
, koenig_p
, tf_none
);
3332 release_tree_vector (args
);
3333 return convert_out (ctx
->preserve (call_expr
));
3337 plugin_get_expr_type (cc1_plugin::connection
*self
,
3340 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3341 tree op0
= convert_in (operand
);
3344 type
= TREE_TYPE (op0
);
3346 type
= make_decltype_auto ();
3347 return convert_out (ctx
->preserve (type
));
3351 plugin_build_function_template_specialization (cc1_plugin::connection
*self
,
3352 gcc_decl template_decl
,
3353 const gcc_cp_template_args
*targs
,
3354 gcc_address address
,
3355 const char *filename
,
3356 unsigned int line_number
)
3358 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3359 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3360 tree name
= convert_in (template_decl
);
3361 tree targsl
= targlist (targs
);
3363 tree decl
= tsubst (name
, targsl
, tf_error
, NULL_TREE
);
3364 DECL_SOURCE_LOCATION (decl
) = loc
;
3366 record_decl_address (ctx
, build_decl_addr_value (decl
, address
));
3368 return convert_out (ctx
->preserve (decl
));
3372 plugin_build_class_template_specialization (cc1_plugin::connection
*self
,
3373 gcc_decl template_decl
,
3374 const gcc_cp_template_args
*args
,
3375 const char *filename
,
3376 unsigned int line_number
)
3378 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3379 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3380 tree name
= convert_in (template_decl
);
3382 tree tdecl
= finish_template_type (name
, targlist (args
), false);;
3383 DECL_SOURCE_LOCATION (tdecl
) = loc
;
3385 return convert_out (ctx
->preserve (tdecl
));
3388 /* Return a builtin type associated with BUILTIN_NAME. */
3391 safe_lookup_builtin_type (const char *builtin_name
)
3393 tree result
= NULL_TREE
;
3398 result
= identifier_global_value (get_identifier (builtin_name
));
3403 gcc_assert (TREE_CODE (result
) == TYPE_DECL
);
3404 result
= TREE_TYPE (result
);
3409 plugin_get_int_type (cc1_plugin::connection
*self
,
3410 int is_unsigned
, unsigned long size_in_bytes
,
3411 const char *builtin_name
)
3417 result
= safe_lookup_builtin_type (builtin_name
);
3418 gcc_assert (!result
|| TREE_CODE (result
) == INTEGER_TYPE
);
3421 result
= c_common_type_for_size (BITS_PER_UNIT
* size_in_bytes
,
3424 if (result
== NULL_TREE
)
3425 result
= error_mark_node
;
3428 gcc_assert (!TYPE_UNSIGNED (result
) == !is_unsigned
);
3429 gcc_assert (TREE_CODE (TYPE_SIZE (result
)) == INTEGER_CST
);
3430 gcc_assert (TYPE_PRECISION (result
) == BITS_PER_UNIT
* size_in_bytes
);
3432 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3433 ctx
->preserve (result
);
3435 return convert_out (result
);
3439 plugin_get_char_type (cc1_plugin::connection
*)
3441 return convert_out (char_type_node
);
3445 plugin_get_float_type (cc1_plugin::connection
*,
3446 unsigned long size_in_bytes
,
3447 const char *builtin_name
)
3451 tree result
= safe_lookup_builtin_type (builtin_name
);
3454 return convert_out (error_mark_node
);
3456 gcc_assert (TREE_CODE (result
) == REAL_TYPE
);
3457 gcc_assert (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (result
));
3459 return convert_out (result
);
3462 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (float_type_node
))
3463 return convert_out (float_type_node
);
3464 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (double_type_node
))
3465 return convert_out (double_type_node
);
3466 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (long_double_type_node
))
3467 return convert_out (long_double_type_node
);
3468 return convert_out (error_mark_node
);
3472 plugin_get_void_type (cc1_plugin::connection
*)
3474 return convert_out (void_type_node
);
3478 plugin_get_bool_type (cc1_plugin::connection
*)
3480 return convert_out (boolean_type_node
);
3484 plugin_get_nullptr_type (cc1_plugin::connection
*)
3486 return convert_out (nullptr_type_node
);
3490 plugin_get_nullptr_constant (cc1_plugin::connection
*)
3492 return convert_out (nullptr_node
);
3496 plugin_build_array_type (cc1_plugin::connection
*self
,
3497 gcc_type element_type_in
, int num_elements
)
3499 tree element_type
= convert_in (element_type_in
);
3502 if (num_elements
== -1)
3503 result
= build_array_type (element_type
, NULL_TREE
);
3505 result
= build_array_type_nelts (element_type
, num_elements
);
3507 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3508 return convert_out (ctx
->preserve (result
));
3512 plugin_build_dependent_array_type (cc1_plugin::connection
*self
,
3513 gcc_type element_type_in
,
3514 gcc_expr num_elements_in
)
3516 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3517 tree element_type
= convert_in (element_type_in
);
3518 tree size
= convert_in (num_elements_in
);
3519 tree name
= get_identifier ("dependent array type");
3521 processing_template_decl
++;
3522 bool template_dependent_p
= dependent_type_p (element_type
)
3523 || type_dependent_expression_p (size
)
3524 || value_dependent_expression_p (size
);
3525 if (!template_dependent_p
)
3526 processing_template_decl
--;
3528 tree itype
= compute_array_index_type (name
, size
, tf_error
);
3529 tree type
= build_cplus_array_type (element_type
, itype
);
3531 if (template_dependent_p
)
3532 processing_template_decl
--;
3534 return convert_out (ctx
->preserve (type
));
3538 plugin_build_vla_array_type (cc1_plugin::connection
*self
,
3539 gcc_type element_type_in
,
3540 const char *upper_bound_name
)
3542 tree element_type
= convert_in (element_type_in
);
3543 tree upper_bound
= lookup_name (get_identifier (upper_bound_name
));
3544 tree size
= fold_build2 (PLUS_EXPR
, TREE_TYPE (upper_bound
), upper_bound
,
3545 build_one_cst (TREE_TYPE (upper_bound
)));
3546 tree range
= compute_array_index_type (NULL_TREE
, size
,
3549 tree result
= build_cplus_array_type (element_type
, range
);
3551 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3552 return convert_out (ctx
->preserve (result
));
3556 plugin_build_qualified_type (cc1_plugin::connection
*,
3557 gcc_type unqualified_type_in
,
3558 enum gcc_cp_qualifiers qualifiers
)
3560 tree unqualified_type
= convert_in (unqualified_type_in
);
3561 cp_cv_quals quals
= 0;
3563 if ((qualifiers
& GCC_CP_QUALIFIER_CONST
) != 0)
3564 quals
|= TYPE_QUAL_CONST
;
3565 if ((qualifiers
& GCC_CP_QUALIFIER_VOLATILE
) != 0)
3566 quals
|= TYPE_QUAL_VOLATILE
;
3567 if ((qualifiers
& GCC_CP_QUALIFIER_RESTRICT
) != 0)
3568 quals
|= TYPE_QUAL_RESTRICT
;
3570 gcc_assert ((TREE_CODE (unqualified_type
) != METHOD_TYPE
3571 && TREE_CODE (unqualified_type
) != REFERENCE_TYPE
)
3574 return convert_out (build_qualified_type (unqualified_type
, quals
));
3578 plugin_build_complex_type (cc1_plugin::connection
*self
,
3581 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3582 return convert_out (ctx
->preserve (build_complex_type (convert_in (base_type
))));
3586 plugin_build_vector_type (cc1_plugin::connection
*self
,
3587 gcc_type base_type
, int nunits
)
3589 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3590 return convert_out (ctx
->preserve (build_vector_type (convert_in (base_type
),
3595 plugin_build_constant (cc1_plugin::connection
*self
, gcc_type type_in
,
3596 const char *name
, unsigned long value
,
3597 const char *filename
, unsigned int line_number
)
3599 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3601 tree type
= convert_in (type_in
);
3603 cst
= build_int_cst (type
, value
);
3604 if (!TYPE_READONLY (type
))
3605 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
3606 decl
= build_decl (ctx
->get_location_t (filename
, line_number
),
3607 VAR_DECL
, get_identifier (name
), type
);
3608 TREE_STATIC (decl
) = 1;
3609 TREE_READONLY (decl
) = 1;
3610 cp_finish_decl (decl
, cst
, true, NULL
, LOOKUP_ONLYCONVERTING
);
3611 safe_pushdecl_maybe_friend (decl
, false);
3617 plugin_error (cc1_plugin::connection
*,
3618 const char *message
)
3620 error ("%s", message
);
3621 return convert_out (error_mark_node
);
3625 plugin_add_static_assert (cc1_plugin::connection
*self
,
3626 gcc_expr condition_in
,
3627 const char *errormsg
,
3628 const char *filename
,
3629 unsigned int line_number
)
3631 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3632 tree condition
= convert_in (condition_in
);
3637 tree message
= build_string (strlen (errormsg
) + 1, errormsg
);
3639 TREE_TYPE (message
) = char_array_type_node
;
3640 fix_string_type (message
);
3642 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3644 bool member_p
= at_class_scope_p ();
3646 finish_static_assert (condition
, message
, loc
, member_p
);
3653 // Perform GC marking.
3656 gc_mark (void *, void *)
3658 if (current_context
!= NULL
)
3659 current_context
->mark ();
3663 #pragma GCC visibility push(default)
3667 plugin_init (struct plugin_name_args
*plugin_info
,
3668 struct plugin_gcc_version
*)
3671 for (int i
= 0; i
< plugin_info
->argc
; ++i
)
3673 if (strcmp (plugin_info
->argv
[i
].key
, "fd") == 0)
3677 fd
= strtol (plugin_info
->argv
[i
].value
, &tail
, 0);
3678 if (*tail
!= '\0' || errno
!= 0)
3679 fatal_error (input_location
,
3680 "%s: invalid file descriptor argument to plugin",
3681 plugin_info
->base_name
);
3686 fatal_error (input_location
,
3687 "%s: required plugin argument %<fd%> is missing",
3688 plugin_info
->base_name
);
3690 current_context
= new plugin_context (fd
);
3693 cc1_plugin::protocol_int version
;
3694 if (!current_context
->require ('H')
3695 || ! ::cc1_plugin::unmarshall (current_context
, &version
))
3696 fatal_error (input_location
,
3697 "%s: handshake failed", plugin_info
->base_name
);
3698 if (version
!= GCC_CP_FE_VERSION_0
)
3699 fatal_error (input_location
,
3700 "%s: unknown version in handshake", plugin_info
->base_name
);
3702 register_callback (plugin_info
->base_name
, PLUGIN_PRAGMAS
,
3703 plugin_init_extra_pragmas
, NULL
);
3704 register_callback (plugin_info
->base_name
, PLUGIN_PRE_GENERICIZE
,
3705 rewrite_decls_to_addresses
, NULL
);
3706 register_callback (plugin_info
->base_name
, PLUGIN_GGC_MARKING
,
3709 lang_hooks
.print_error_function
= plugin_print_error_function
;
3711 #define GCC_METHOD0(R, N) \
3713 cc1_plugin::callback_ftype *fun \
3714 = cc1_plugin::callback<R, plugin_ ## N>; \
3715 current_context->add_callback (# N, fun); \
3717 #define GCC_METHOD1(R, N, A) \
3719 cc1_plugin::callback_ftype *fun \
3720 = cc1_plugin::callback<R, A, plugin_ ## N>; \
3721 current_context->add_callback (# N, fun); \
3723 #define GCC_METHOD2(R, N, A, B) \
3725 cc1_plugin::callback_ftype *fun \
3726 = cc1_plugin::callback<R, A, B, plugin_ ## N>; \
3727 current_context->add_callback (# N, fun); \
3729 #define GCC_METHOD3(R, N, A, B, C) \
3731 cc1_plugin::callback_ftype *fun \
3732 = cc1_plugin::callback<R, A, B, C, plugin_ ## N>; \
3733 current_context->add_callback (# N, fun); \
3735 #define GCC_METHOD4(R, N, A, B, C, D) \
3737 cc1_plugin::callback_ftype *fun \
3738 = cc1_plugin::callback<R, A, B, C, D, \
3740 current_context->add_callback (# N, fun); \
3742 #define GCC_METHOD5(R, N, A, B, C, D, E) \
3744 cc1_plugin::callback_ftype *fun \
3745 = cc1_plugin::callback<R, A, B, C, D, E, \
3747 current_context->add_callback (# N, fun); \
3749 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
3751 cc1_plugin::callback_ftype *fun \
3752 = cc1_plugin::callback<R, A, B, C, D, E, F, G, \
3754 current_context->add_callback (# N, fun); \
3757 #include "gcc-cp-fe.def"