1 /* Library interface to C++ front end.
2 Copyright (C) 2014-2019 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_function_decl (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 (op0
);
2804 result
= build_typeid (op0
, tf_error
);
2809 result
= cxx_sizeof_or_alignof_expr (op0
, opcode
, true);
2813 case VEC_DELETE_EXPR
:
2814 result
= delete_sanity (op0
, NULL_TREE
, opcode
== VEC_DELETE_EXPR
,
2815 global_scope_p
, tf_error
);
2818 case EXPR_PACK_EXPANSION
:
2819 result
= make_pack_expansion (op0
);
2822 // We're using this for sizeof...(pack). */
2823 case TYPE_PACK_EXPANSION
:
2824 result
= make_pack_expansion (op0
);
2825 PACK_EXPANSION_SIZEOF_P (result
) = true;
2829 result
= build_x_unary_op (/*loc=*/0, opcode
, op0
, tf_error
);
2833 if (template_dependent_p
)
2834 processing_template_decl
--;
2836 return convert_out (ctx
->preserve (result
));
2840 plugin_build_binary_expr (cc1_plugin::connection
*self
,
2841 const char *binary_op
,
2845 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2846 tree op0
= convert_in (operand1
);
2847 tree op1
= convert_in (operand2
);
2848 tree_code opcode
= ERROR_MARK
;
2850 switch (CHARS2 (binary_op
[0], binary_op
[1]))
2852 case CHARS2 ('p', 'l'): // operator +
2855 case CHARS2 ('m', 'i'): // operator -
2856 opcode
= MINUS_EXPR
;
2858 case CHARS2 ('m', 'l'): // operator *
2861 case CHARS2 ('d', 'v'): // operator /
2862 opcode
= TRUNC_DIV_EXPR
;
2864 case CHARS2 ('r', 'm'): // operator %
2865 opcode
= TRUNC_MOD_EXPR
;
2867 case CHARS2 ('a', 'n'): // operator &
2868 opcode
= BIT_AND_EXPR
;
2870 case CHARS2 ('o', 'r'): // operator |
2871 opcode
= BIT_IOR_EXPR
;
2873 case CHARS2 ('e', 'o'): // operator ^
2874 opcode
= BIT_XOR_EXPR
;
2876 case CHARS2 ('l', 's'): // operator <<
2877 opcode
= LSHIFT_EXPR
;
2879 case CHARS2 ('r', 's'): // operator >>
2880 opcode
= RSHIFT_EXPR
;
2882 case CHARS2 ('e', 'q'): // operator ==
2885 case CHARS2 ('n', 'e'): // operator !=
2888 case CHARS2 ('l', 't'): // operator <
2891 case CHARS2 ('g', 't'): // operator >
2894 case CHARS2 ('l', 'e'): // operator <=
2897 case CHARS2 ('g', 'e'): // operator >=
2900 case CHARS2 ('a', 'a'): // operator &&
2901 opcode
= TRUTH_ANDIF_EXPR
;
2903 case CHARS2 ('o', 'o'): // operator ||
2904 opcode
= TRUTH_ORIF_EXPR
;
2906 case CHARS2 ('c', 'm'): // operator ,
2907 opcode
= COMPOUND_EXPR
;
2909 case CHARS2 ('p', 'm'): // operator ->*
2910 opcode
= MEMBER_REF
;
2912 case CHARS2 ('p', 't'): // operator ->
2913 opcode
= INDIRECT_REF
; // Not really! This will stand for
2914 // INDIRECT_REF followed by COMPONENT_REF
2917 case CHARS2 ('i', 'x'): // operator []
2920 case CHARS2 ('d', 's'): // operator .*
2921 opcode
= DOTSTAR_EXPR
;
2923 case CHARS2 ('d', 't'): // operator .
2924 opcode
= COMPONENT_REF
;
2931 processing_template_decl
++;
2932 bool template_dependent_p
= type_dependent_expression_p (op0
)
2933 || value_dependent_expression_p (op0
)
2934 || type_dependent_expression_p (op1
)
2935 || value_dependent_expression_p (op1
);
2936 if (!template_dependent_p
)
2937 processing_template_decl
--;
2943 case INDIRECT_REF
: // This is actually a "->".
2944 op0
= build_x_arrow (/*loc=*/0, op0
, tf_error
);
2947 result
= finish_class_member_access_expr (op0
, op1
,
2948 /*template_p=*/false,
2953 result
= build_x_binary_op (/*loc=*/0, opcode
, op0
, ERROR_MARK
,
2954 op1
, ERROR_MARK
, NULL
, tf_error
);
2958 if (template_dependent_p
)
2959 processing_template_decl
--;
2961 return convert_out (ctx
->preserve (result
));
2965 plugin_build_ternary_expr (cc1_plugin::connection
*self
,
2966 const char *ternary_op
,
2971 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
2972 tree op0
= convert_in (operand1
);
2973 tree op1
= convert_in (operand2
);
2974 tree op2
= convert_in (operand3
);
2975 gcc_assert (CHARS2 (ternary_op
[0], ternary_op
[1])
2976 == CHARS2 ('q', 'u')); // ternary operator
2978 processing_template_decl
++;
2979 bool template_dependent_p
= type_dependent_expression_p (op0
)
2980 || value_dependent_expression_p (op0
)
2981 || type_dependent_expression_p (op1
)
2982 || value_dependent_expression_p (op1
)
2983 || type_dependent_expression_p (op2
)
2984 || value_dependent_expression_p (op2
);
2985 if (!template_dependent_p
)
2986 processing_template_decl
--;
2988 tree val
= build_x_conditional_expr (/*loc=*/0, op0
, op1
, op2
, tf_error
);
2990 if (template_dependent_p
)
2991 processing_template_decl
--;
2993 return convert_out (ctx
->preserve (val
));
2997 plugin_build_unary_type_expr (cc1_plugin::connection
*self
,
2998 const char *unary_op
,
3001 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3002 tree type
= convert_in (operand
);
3003 tree_code opcode
= ERROR_MARK
;
3005 switch (CHARS2 (unary_op
[0], unary_op
[1]))
3007 case CHARS2 ('t', 'i'): // typeid (type)
3008 opcode
= TYPEID_EXPR
;
3011 case CHARS2 ('s', 't'): // sizeof (type)
3012 opcode
= SIZEOF_EXPR
;
3014 case CHARS2 ('a', 't'): // alignof (type)
3015 opcode
= ALIGNOF_EXPR
;
3018 case CHARS2 ('s', 'Z'): // sizeof...(pack)
3019 opcode
= TYPE_PACK_EXPANSION
; // Not really, but let's use its code.
3022 // FIXME: do we have to handle "sp", for the size of a captured
3023 // template parameter pack from an alias template, taking
3024 // multiple template arguments?
3030 processing_template_decl
++;
3031 bool template_dependent_p
= dependent_type_p (type
);
3032 if (!template_dependent_p
)
3033 processing_template_decl
--;
3040 result
= get_typeid (type
, tf_error
);
3043 // We're using this for sizeof...(pack). */
3044 case TYPE_PACK_EXPANSION
:
3045 result
= make_pack_expansion (type
);
3046 PACK_EXPANSION_SIZEOF_P (result
) = true;
3050 /* Use the C++11 alignof semantics. */
3051 result
= cxx_sizeof_or_alignof_type (type
, opcode
, true, true);
3054 if (template_dependent_p
)
3055 processing_template_decl
--;
3057 return convert_out (ctx
->preserve (result
));
3061 plugin_build_cast_expr (cc1_plugin::connection
*self
,
3062 const char *binary_op
,
3066 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3067 tree (*build_cast
)(tree type
, tree expr
, tsubst_flags_t complain
) = NULL
;
3068 tree type
= convert_in (operand1
);
3069 tree expr
= convert_in (operand2
);
3071 switch (CHARS2 (binary_op
[0], binary_op
[1]))
3073 case CHARS2 ('d', 'c'): // dynamic_cast
3074 build_cast
= build_dynamic_cast
;
3077 case CHARS2 ('s', 'c'): // static_cast
3078 build_cast
= build_static_cast
;
3081 case CHARS2 ('c', 'c'): // const_cast
3082 build_cast
= build_const_cast
;
3085 case CHARS2 ('r', 'c'): // reinterpret_cast
3086 build_cast
= build_reinterpret_cast
;
3089 case CHARS2 ('c', 'v'): // C cast, conversion with one argument
3090 build_cast
= cp_build_c_cast
;
3097 processing_template_decl
++;
3098 bool template_dependent_p
= dependent_type_p (type
)
3099 || type_dependent_expression_p (expr
)
3100 || value_dependent_expression_p (expr
);
3101 if (!template_dependent_p
)
3102 processing_template_decl
--;
3104 tree val
= build_cast (type
, expr
, tf_error
);
3106 if (template_dependent_p
)
3107 processing_template_decl
--;
3109 return convert_out (ctx
->preserve (val
));
3112 static inline vec
<tree
, va_gc
> *
3113 args_to_tree_vec (const struct gcc_cp_function_args
*args_in
)
3115 vec
<tree
, va_gc
> *args
= make_tree_vector ();
3116 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3117 vec_safe_push (args
, convert_in (args_in
->elements
[i
]));
3122 args_to_tree_list (const struct gcc_cp_function_args
*args_in
)
3124 tree args
, *tail
= &args
;
3125 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3127 *tail
= build_tree_list (NULL
, convert_in (args_in
->elements
[i
]));
3128 tail
= &TREE_CHAIN (*tail
);
3133 static inline vec
<constructor_elt
, va_gc
> *
3134 args_to_ctor_elts (const struct gcc_cp_function_args
*args_in
)
3136 vec
<constructor_elt
, va_gc
> *args
= NULL
;
3137 for (int i
= 0; i
< args_in
->n_elements
; i
++)
3138 CONSTRUCTOR_APPEND_ELT (args
, NULL_TREE
, convert_in (args_in
->elements
[i
]));
3143 plugin_build_expression_list_expr (cc1_plugin::connection
*self
,
3144 const char *conv_op
,
3146 const struct gcc_cp_function_args
*values_in
)
3148 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3149 tree type
= convert_in (type_in
);
3153 switch (CHARS2 (conv_op
[0], conv_op
[1]))
3155 case CHARS2 ('c', 'v'): // conversion with parenthesized expression list
3156 gcc_assert (TYPE_P (type
));
3157 args
= args_to_tree_list (values_in
);
3158 result
= build_functional_cast (input_location
, type
, args
, tf_error
);
3161 case CHARS2 ('t', 'l'): // conversion with braced expression list
3163 gcc_assert (TYPE_P (type
));
3164 args
= make_node (CONSTRUCTOR
);
3165 CONSTRUCTOR_ELTS (args
) = args_to_ctor_elts (values_in
);
3166 CONSTRUCTOR_IS_DIRECT_INIT (args
) = 1;
3167 result
= finish_compound_literal (type
, args
, tf_error
);
3170 case CHARS2 ('i', 'l'): // untyped braced expression list
3172 result
= make_node (CONSTRUCTOR
);
3173 CONSTRUCTOR_ELTS (result
) = args_to_ctor_elts (values_in
);
3180 return convert_out (ctx
->preserve (result
));
3184 plugin_build_new_expr (cc1_plugin::connection
*self
,
3186 const struct gcc_cp_function_args
*placement_in
,
3188 const struct gcc_cp_function_args
*initializer_in
)
3190 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3191 tree type
= convert_in (type_in
);
3192 vec
<tree
, va_gc
> *placement
= NULL
, *initializer
= NULL
;
3193 bool global_scope_p
= false;
3197 placement
= args_to_tree_vec (placement_in
);
3199 initializer
= args_to_tree_vec (initializer_in
);
3201 gcc_assert (TYPE_P (type
));
3204 switch (CHARS2 (new_op
[0], new_op
[1]))
3206 case CHARS2 ('g', 's'):
3207 gcc_assert (!global_scope_p
);
3208 global_scope_p
= true;
3212 case CHARS2 ('n', 'w'): // non-array new
3213 gcc_assert (TREE_CODE (type
) != ARRAY_TYPE
);
3216 case CHARS2 ('n', 'a'): // array new
3217 gcc_assert (TREE_CODE (type
) == ARRAY_TYPE
);
3218 gcc_assert (TYPE_DOMAIN (type
));
3220 // Compute the length of the outermost array type, then discard it.
3221 tree maxelt
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
3222 tree eltype
= TREE_TYPE (maxelt
);
3223 tree onecst
= integer_one_node
;
3225 processing_template_decl
++;
3226 bool template_dependent_p
= value_dependent_expression_p (maxelt
)
3227 || type_dependent_expression_p (maxelt
);
3228 if (!template_dependent_p
)
3230 processing_template_decl
--;
3231 onecst
= fold_convert (eltype
, onecst
);
3234 nelts
= fold_build2 (PLUS_EXPR
, eltype
, nelts
, onecst
);
3236 if (template_dependent_p
)
3237 processing_template_decl
--;
3239 type
= TREE_TYPE (type
);
3247 processing_template_decl
++;
3248 bool template_dependent_p
= dependent_type_p (type
)
3249 || value_dependent_expression_p (nelts
)
3251 && any_type_dependent_arguments_p (placement
))
3253 && any_type_dependent_arguments_p (initializer
));
3254 if (!template_dependent_p
)
3255 processing_template_decl
--;
3257 tree result
= build_new (&placement
, type
, nelts
, &initializer
,
3258 global_scope_p
, tf_error
);
3260 if (template_dependent_p
)
3261 processing_template_decl
--;
3263 if (placement
!= NULL
)
3264 release_tree_vector (placement
);
3265 if (initializer
!= NULL
)
3266 release_tree_vector (initializer
);
3268 return convert_out (ctx
->preserve (result
));
3272 plugin_build_call_expr (cc1_plugin::connection
*self
,
3273 gcc_expr callable_in
, int qualified_p
,
3274 const struct gcc_cp_function_args
*args_in
)
3276 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3277 tree callable
= convert_in (callable_in
);
3280 vec
<tree
, va_gc
> *args
= args_to_tree_vec (args_in
);
3282 bool koenig_p
= false;
3283 if (!qualified_p
&& !args
->is_empty ())
3285 if (identifier_p (callable
))
3287 else if (is_overloaded_fn (callable
))
3289 tree fn
= get_first_fn (callable
);
3290 fn
= STRIP_TEMPLATE (fn
);
3292 if (!DECL_FUNCTION_MEMBER_P (fn
)
3293 && !DECL_LOCAL_FUNCTION_P (fn
))
3298 if (koenig_p
&& !any_type_dependent_arguments_p (args
))
3299 callable
= perform_koenig_lookup (callable
, args
, tf_none
);
3301 if (TREE_CODE (callable
) == COMPONENT_REF
)
3303 tree object
= TREE_OPERAND (callable
, 0);
3304 tree memfn
= TREE_OPERAND (callable
, 1);
3306 if (type_dependent_expression_p (object
)
3307 || (!BASELINK_P (memfn
) && TREE_CODE (memfn
) != FIELD_DECL
)
3308 || type_dependent_expression_p (memfn
)
3309 || any_type_dependent_arguments_p (args
))
3310 call_expr
= build_nt_call_vec (callable
, args
);
3311 else if (BASELINK_P (memfn
))
3312 call_expr
= build_new_method_call (object
, memfn
, &args
, NULL_TREE
,
3314 ? LOOKUP_NORMAL
|LOOKUP_NONVIRTUAL
3318 call_expr
= finish_call_expr (callable
, &args
, false, false, tf_none
);
3320 else if (TREE_CODE (callable
) == OFFSET_REF
3321 || TREE_CODE (callable
) == MEMBER_REF
3322 || TREE_CODE (callable
) == DOTSTAR_EXPR
)
3323 call_expr
= build_offset_ref_call_from_tree (callable
, &args
, tf_none
);
3325 call_expr
= finish_call_expr (callable
, &args
,
3326 !!qualified_p
, koenig_p
, tf_none
);
3328 release_tree_vector (args
);
3329 return convert_out (ctx
->preserve (call_expr
));
3333 plugin_get_expr_type (cc1_plugin::connection
*self
,
3336 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3337 tree op0
= convert_in (operand
);
3340 type
= TREE_TYPE (op0
);
3343 type
= make_decltype_auto ();
3344 AUTO_IS_DECLTYPE (type
) = true;
3346 return convert_out (ctx
->preserve (type
));
3350 plugin_build_function_template_specialization (cc1_plugin::connection
*self
,
3351 gcc_decl template_decl
,
3352 const gcc_cp_template_args
*targs
,
3353 gcc_address address
,
3354 const char *filename
,
3355 unsigned int line_number
)
3357 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3358 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3359 tree name
= convert_in (template_decl
);
3360 tree targsl
= targlist (targs
);
3362 tree decl
= tsubst (name
, targsl
, tf_error
, NULL_TREE
);
3363 DECL_SOURCE_LOCATION (decl
) = loc
;
3365 record_decl_address (ctx
, build_decl_addr_value (decl
, address
));
3367 return convert_out (ctx
->preserve (decl
));
3371 plugin_build_class_template_specialization (cc1_plugin::connection
*self
,
3372 gcc_decl template_decl
,
3373 const gcc_cp_template_args
*args
,
3374 const char *filename
,
3375 unsigned int line_number
)
3377 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3378 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3379 tree name
= convert_in (template_decl
);
3381 tree tdecl
= finish_template_type (name
, targlist (args
), false);;
3382 DECL_SOURCE_LOCATION (tdecl
) = loc
;
3384 return convert_out (ctx
->preserve (tdecl
));
3387 /* Return a builtin type associated with BUILTIN_NAME. */
3390 safe_lookup_builtin_type (const char *builtin_name
)
3392 tree result
= NULL_TREE
;
3397 result
= identifier_global_value (get_identifier (builtin_name
));
3402 gcc_assert (TREE_CODE (result
) == TYPE_DECL
);
3403 result
= TREE_TYPE (result
);
3408 plugin_get_int_type (cc1_plugin::connection
*self
,
3409 int is_unsigned
, unsigned long size_in_bytes
,
3410 const char *builtin_name
)
3416 result
= safe_lookup_builtin_type (builtin_name
);
3417 gcc_assert (!result
|| TREE_CODE (result
) == INTEGER_TYPE
);
3420 result
= c_common_type_for_size (BITS_PER_UNIT
* size_in_bytes
,
3423 if (result
== NULL_TREE
)
3424 result
= error_mark_node
;
3427 gcc_assert (!TYPE_UNSIGNED (result
) == !is_unsigned
);
3428 gcc_assert (TREE_CODE (TYPE_SIZE (result
)) == INTEGER_CST
);
3429 gcc_assert (TYPE_PRECISION (result
) == BITS_PER_UNIT
* size_in_bytes
);
3431 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3432 ctx
->preserve (result
);
3434 return convert_out (result
);
3438 plugin_get_char_type (cc1_plugin::connection
*)
3440 return convert_out (char_type_node
);
3444 plugin_get_float_type (cc1_plugin::connection
*,
3445 unsigned long size_in_bytes
,
3446 const char *builtin_name
)
3450 tree result
= safe_lookup_builtin_type (builtin_name
);
3453 return convert_out (error_mark_node
);
3455 gcc_assert (TREE_CODE (result
) == REAL_TYPE
);
3456 gcc_assert (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (result
));
3458 return convert_out (result
);
3461 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (float_type_node
))
3462 return convert_out (float_type_node
);
3463 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (double_type_node
))
3464 return convert_out (double_type_node
);
3465 if (BITS_PER_UNIT
* size_in_bytes
== TYPE_PRECISION (long_double_type_node
))
3466 return convert_out (long_double_type_node
);
3467 return convert_out (error_mark_node
);
3471 plugin_get_void_type (cc1_plugin::connection
*)
3473 return convert_out (void_type_node
);
3477 plugin_get_bool_type (cc1_plugin::connection
*)
3479 return convert_out (boolean_type_node
);
3483 plugin_get_nullptr_type (cc1_plugin::connection
*)
3485 return convert_out (nullptr_type_node
);
3489 plugin_get_nullptr_constant (cc1_plugin::connection
*)
3491 return convert_out (nullptr_node
);
3495 plugin_build_array_type (cc1_plugin::connection
*self
,
3496 gcc_type element_type_in
, int num_elements
)
3498 tree element_type
= convert_in (element_type_in
);
3501 if (num_elements
== -1)
3502 result
= build_array_type (element_type
, NULL_TREE
);
3504 result
= build_array_type_nelts (element_type
, num_elements
);
3506 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3507 return convert_out (ctx
->preserve (result
));
3511 plugin_build_dependent_array_type (cc1_plugin::connection
*self
,
3512 gcc_type element_type_in
,
3513 gcc_expr num_elements_in
)
3515 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3516 tree element_type
= convert_in (element_type_in
);
3517 tree size
= convert_in (num_elements_in
);
3518 tree name
= get_identifier ("dependent array type");
3520 processing_template_decl
++;
3521 bool template_dependent_p
= dependent_type_p (element_type
)
3522 || type_dependent_expression_p (size
)
3523 || value_dependent_expression_p (size
);
3524 if (!template_dependent_p
)
3525 processing_template_decl
--;
3527 tree itype
= compute_array_index_type (name
, size
, tf_error
);
3528 tree type
= build_cplus_array_type (element_type
, itype
);
3530 if (template_dependent_p
)
3531 processing_template_decl
--;
3533 return convert_out (ctx
->preserve (type
));
3537 plugin_build_vla_array_type (cc1_plugin::connection
*self
,
3538 gcc_type element_type_in
,
3539 const char *upper_bound_name
)
3541 tree element_type
= convert_in (element_type_in
);
3542 tree upper_bound
= lookup_name (get_identifier (upper_bound_name
));
3543 tree size
= fold_build2 (PLUS_EXPR
, TREE_TYPE (upper_bound
), upper_bound
,
3544 build_one_cst (TREE_TYPE (upper_bound
)));
3545 tree range
= compute_array_index_type (NULL_TREE
, size
,
3548 tree result
= build_cplus_array_type (element_type
, range
);
3550 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3551 return convert_out (ctx
->preserve (result
));
3555 plugin_build_qualified_type (cc1_plugin::connection
*,
3556 gcc_type unqualified_type_in
,
3557 enum gcc_cp_qualifiers qualifiers
)
3559 tree unqualified_type
= convert_in (unqualified_type_in
);
3560 cp_cv_quals quals
= 0;
3562 if ((qualifiers
& GCC_CP_QUALIFIER_CONST
) != 0)
3563 quals
|= TYPE_QUAL_CONST
;
3564 if ((qualifiers
& GCC_CP_QUALIFIER_VOLATILE
) != 0)
3565 quals
|= TYPE_QUAL_VOLATILE
;
3566 if ((qualifiers
& GCC_CP_QUALIFIER_RESTRICT
) != 0)
3567 quals
|= TYPE_QUAL_RESTRICT
;
3569 gcc_assert ((TREE_CODE (unqualified_type
) != METHOD_TYPE
3570 && TREE_CODE (unqualified_type
) != REFERENCE_TYPE
)
3573 return convert_out (build_qualified_type (unqualified_type
, quals
));
3577 plugin_build_complex_type (cc1_plugin::connection
*self
,
3580 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3581 return convert_out (ctx
->preserve (build_complex_type (convert_in (base_type
))));
3585 plugin_build_vector_type (cc1_plugin::connection
*self
,
3586 gcc_type base_type
, int nunits
)
3588 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3589 return convert_out (ctx
->preserve (build_vector_type (convert_in (base_type
),
3594 plugin_build_constant (cc1_plugin::connection
*self
, gcc_type type_in
,
3595 const char *name
, unsigned long value
,
3596 const char *filename
, unsigned int line_number
)
3598 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3600 tree type
= convert_in (type_in
);
3602 cst
= build_int_cst (type
, value
);
3603 if (!TYPE_READONLY (type
))
3604 type
= build_qualified_type (type
, TYPE_QUAL_CONST
);
3605 decl
= build_decl (ctx
->get_location_t (filename
, line_number
),
3606 VAR_DECL
, get_identifier (name
), type
);
3607 TREE_STATIC (decl
) = 1;
3608 TREE_READONLY (decl
) = 1;
3609 cp_finish_decl (decl
, cst
, true, NULL
, LOOKUP_ONLYCONVERTING
);
3610 safe_pushdecl_maybe_friend (decl
, false);
3616 plugin_error (cc1_plugin::connection
*,
3617 const char *message
)
3619 error ("%s", message
);
3620 return convert_out (error_mark_node
);
3624 plugin_add_static_assert (cc1_plugin::connection
*self
,
3625 gcc_expr condition_in
,
3626 const char *errormsg
,
3627 const char *filename
,
3628 unsigned int line_number
)
3630 plugin_context
*ctx
= static_cast<plugin_context
*> (self
);
3631 tree condition
= convert_in (condition_in
);
3636 tree message
= build_string (strlen (errormsg
) + 1, errormsg
);
3638 TREE_TYPE (message
) = char_array_type_node
;
3639 fix_string_type (message
);
3641 location_t loc
= ctx
->get_location_t (filename
, line_number
);
3643 bool member_p
= at_class_scope_p ();
3645 finish_static_assert (condition
, message
, loc
, member_p
);
3652 // Perform GC marking.
3655 gc_mark (void *, void *)
3657 if (current_context
!= NULL
)
3658 current_context
->mark ();
3662 #pragma GCC visibility push(default)
3666 plugin_init (struct plugin_name_args
*plugin_info
,
3667 struct plugin_gcc_version
*)
3670 for (int i
= 0; i
< plugin_info
->argc
; ++i
)
3672 if (strcmp (plugin_info
->argv
[i
].key
, "fd") == 0)
3676 fd
= strtol (plugin_info
->argv
[i
].value
, &tail
, 0);
3677 if (*tail
!= '\0' || errno
!= 0)
3678 fatal_error (input_location
,
3679 "%s: invalid file descriptor argument to plugin",
3680 plugin_info
->base_name
);
3685 fatal_error (input_location
,
3686 "%s: required plugin argument %<fd%> is missing",
3687 plugin_info
->base_name
);
3689 current_context
= new plugin_context (fd
);
3692 cc1_plugin::protocol_int version
;
3693 if (!current_context
->require ('H')
3694 || ! ::cc1_plugin::unmarshall (current_context
, &version
))
3695 fatal_error (input_location
,
3696 "%s: handshake failed", plugin_info
->base_name
);
3697 if (version
!= GCC_CP_FE_VERSION_0
)
3698 fatal_error (input_location
,
3699 "%s: unknown version in handshake", plugin_info
->base_name
);
3701 register_callback (plugin_info
->base_name
, PLUGIN_PRAGMAS
,
3702 plugin_init_extra_pragmas
, NULL
);
3703 register_callback (plugin_info
->base_name
, PLUGIN_PRE_GENERICIZE
,
3704 rewrite_decls_to_addresses
, NULL
);
3705 register_callback (plugin_info
->base_name
, PLUGIN_GGC_MARKING
,
3708 lang_hooks
.print_error_function
= plugin_print_error_function
;
3710 #define GCC_METHOD0(R, N) \
3712 cc1_plugin::callback_ftype *fun \
3713 = cc1_plugin::callback<R, plugin_ ## N>; \
3714 current_context->add_callback (# N, fun); \
3716 #define GCC_METHOD1(R, N, A) \
3718 cc1_plugin::callback_ftype *fun \
3719 = cc1_plugin::callback<R, A, plugin_ ## N>; \
3720 current_context->add_callback (# N, fun); \
3722 #define GCC_METHOD2(R, N, A, B) \
3724 cc1_plugin::callback_ftype *fun \
3725 = cc1_plugin::callback<R, A, B, plugin_ ## N>; \
3726 current_context->add_callback (# N, fun); \
3728 #define GCC_METHOD3(R, N, A, B, C) \
3730 cc1_plugin::callback_ftype *fun \
3731 = cc1_plugin::callback<R, A, B, C, plugin_ ## N>; \
3732 current_context->add_callback (# N, fun); \
3734 #define GCC_METHOD4(R, N, A, B, C, D) \
3736 cc1_plugin::callback_ftype *fun \
3737 = cc1_plugin::callback<R, A, B, C, D, \
3739 current_context->add_callback (# N, fun); \
3741 #define GCC_METHOD5(R, N, A, B, C, D, E) \
3743 cc1_plugin::callback_ftype *fun \
3744 = cc1_plugin::callback<R, A, B, C, D, E, \
3746 current_context->add_callback (# N, fun); \
3748 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
3750 cc1_plugin::callback_ftype *fun \
3751 = cc1_plugin::callback<R, A, B, C, D, E, F, G, \
3753 current_context->add_callback (# N, fun); \
3756 #include "gcc-cp-fe.def"