PR debug/84545
[official-gcc.git] / libcc1 / libcp1plugin.cc
blob0137cc9e4e132f170979641088b1059d01e7104d
1 /* Library interface to C++ front end.
2 Copyright (C) 2014-2018 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
10 version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
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>
23 #undef PACKAGE_NAME
24 #undef PACKAGE_STRING
25 #undef PACKAGE_TARNAME
26 #undef PACKAGE_VERSION
28 #include "../gcc/config.h"
30 #undef PACKAGE_NAME
31 #undef PACKAGE_STRING
32 #undef PACKAGE_TARNAME
33 #undef PACKAGE_VERSION
35 #include "gcc-plugin.h"
36 #include "system.h"
37 #include "coretypes.h"
38 #include "stringpool.h"
40 #include "gcc-interface.h"
41 #include "hash-set.h"
42 #include "machmode.h"
43 #include "vec.h"
44 #include "double-int.h"
45 #include "input.h"
46 #include "alias.h"
47 #include "symtab.h"
48 #include "options.h"
49 #include "wide-int.h"
50 #include "inchash.h"
51 #include "tree.h"
52 #include "fold-const.h"
53 #include "stor-layout.h"
54 #include "cp-tree.h"
55 #include "toplev.h"
56 #include "timevar.h"
57 #include "hash-table.h"
58 #include "tm.h"
59 #include "c-family/c-pragma.h"
60 // #include "c-lang.h"
61 #include "diagnostic.h"
62 #include "langhooks.h"
63 #include "langhooks-def.h"
64 #include "decl.h"
65 #include "function.h"
66 #undef cfun // we want to assign to it, and function.h won't let us
68 #include "callbacks.hh"
69 #include "connection.hh"
70 #include "marshall-cp.hh"
71 #include "rpc.hh"
73 #ifdef __GNUC__
74 #pragma GCC visibility push(default)
75 #endif
76 int plugin_is_GPL_compatible;
77 #ifdef __GNUC__
78 #pragma GCC visibility pop
79 #endif
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.
88 static void
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)
96 return;
97 lhd_print_error_function (context, file, diagnostic);
102 static unsigned long long
103 convert_out (tree t)
105 return (unsigned long long) (uintptr_t) t;
108 static tree
109 convert_in (unsigned long long v)
111 return (tree) (uintptr_t) v;
116 struct decl_addr_value
118 tree decl;
119 tree address;
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 *);
128 inline hashval_t
129 decl_addr_hasher::hash (const decl_addr_value *e)
131 return DECL_UID (e->decl);
134 inline bool
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;
167 // File name cache.
168 hash_table<string_hasher> file_names;
170 // Perform GC marking.
171 void mark ();
173 // Preserve a tree during the plugin's operation.
174 tree preserve (tree t)
176 tree_node **slot = preserved.find_slot (t, INSERT);
177 *slot = t;
178 return t;
181 source_location get_source_location (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 source_location loc = linemap_line_start (line_table, line_number, 0);
190 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
191 return loc;
194 private:
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);
200 if (*slot == NULL)
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);
207 return *slot;
211 static plugin_context *current_context;
215 plugin_context::plugin_context (int fd)
216 : cc1_plugin::connection (fd),
217 address_map (30),
218 preserved (30),
219 file_names (30)
223 void
224 plugin_context::mark ()
226 for (hash_table<decl_addr_hasher>::iterator it = address_map.begin ();
227 it != address_map.end ();
228 ++it)
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)
236 ggc_mark (&*it);
239 static void
240 plugin_binding_oracle (enum cp_oracle_request kind, tree identifier)
242 enum gcc_cp_oracle_request request;
244 gcc_assert (current_context != NULL);
246 switch (kind)
248 case CP_ORACLE_IDENTIFIER:
249 request = GCC_CP_ORACLE_IDENTIFIER;
250 break;
251 default:
252 abort ();
255 int ignore;
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. */
269 static bool
270 at_fake_function_scope_p ()
272 return (!cfun || cfun->decl != current_function_decl)
273 && current_scope () == current_function_decl;
276 static void
277 push_fake_function (tree fndecl, scope_kind kind = sk_function_parms)
279 current_function_decl = fndecl;
280 begin_scope (kind, fndecl);
281 ++function_depth;
282 begin_scope (sk_block, NULL);
285 static void
286 pop_scope ()
288 if (toplevel_bindings_p () && current_namespace == global_namespace)
289 pop_from_top_level ();
290 else if (at_namespace_scope_p ())
291 pop_namespace ();
292 else if (at_class_scope_p ())
293 popclass ();
294 else
296 gcc_assert (at_fake_function_scope_p ());
297 gcc_assert (!at_function_scope_p ());
298 gcc_assert (current_binding_level->kind == sk_block
299 && current_binding_level->this_entity == NULL);
300 leave_scope ();
301 --function_depth;
302 gcc_assert (current_binding_level->this_entity
303 == current_function_decl);
304 leave_scope ();
305 current_function_decl = NULL;
306 for (cp_binding_level *scope = current_binding_level;
307 scope; scope = scope->level_chain)
308 if (scope->kind == sk_function_parms)
310 current_function_decl = scope->this_entity;
311 break;
316 static void
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
321 with "// _1:". */
322 tree bval = binding->value;
323 bool ok = true;
324 tree target_bval = strip_using_decl (bval);
325 tree target_decl = strip_using_decl (decl);
327 if (TREE_CODE (target_decl) == TYPE_DECL && DECL_ARTIFICIAL (target_decl)
328 && target_decl != target_bval
329 && (TREE_CODE (target_bval) != TYPE_DECL
330 /* We allow pushing an enum multiple times in a class
331 template in order to handle late matching of underlying
332 type on an opaque-enum-declaration followed by an
333 enum-specifier. */
334 || (processing_template_decl
335 && TREE_CODE (TREE_TYPE (target_decl)) == ENUMERAL_TYPE
336 && TREE_CODE (TREE_TYPE (target_bval)) == ENUMERAL_TYPE
337 && (dependent_type_p (ENUM_UNDERLYING_TYPE
338 (TREE_TYPE (target_decl)))
339 || dependent_type_p (ENUM_UNDERLYING_TYPE
340 (TREE_TYPE (target_bval)))))))
341 /* The new name is the type name. */
342 binding->type = decl;
343 else if (/* TARGET_BVAL is null when push_class_level_binding moves
344 an inherited type-binding out of the way to make room
345 for a new value binding. */
346 !target_bval
347 /* TARGET_BVAL is error_mark_node when TARGET_DECL's name
348 has been used in a non-class scope prior declaration.
349 In that case, we should have already issued a
350 diagnostic; for graceful error recovery purpose, pretend
351 this was the intended declaration for that name. */
352 || target_bval == error_mark_node
353 /* If TARGET_BVAL is anticipated but has not yet been
354 declared, pretend it is not there at all. */
355 || (TREE_CODE (target_bval) == FUNCTION_DECL
356 && DECL_ANTICIPATED (target_bval)
357 && !DECL_HIDDEN_FRIEND_P (target_bval)))
358 binding->value = decl;
359 else if (TREE_CODE (target_bval) == TYPE_DECL
360 && DECL_ARTIFICIAL (target_bval)
361 && target_decl != target_bval
362 && (TREE_CODE (target_decl) != TYPE_DECL
363 || same_type_p (TREE_TYPE (target_decl),
364 TREE_TYPE (target_bval))))
366 /* The old binding was a type name. It was placed in
367 VALUE field because it was thought, at the point it was
368 declared, to be the only entity with such a name. Move the
369 type name into the type slot; it is now hidden by the new
370 binding. */
371 binding->type = bval;
372 binding->value = decl;
373 binding->value_is_inherited = false;
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:
387 [dcl.typedef]
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
395 members. */
396 ok = false;
397 /* There can be two block-scope declarations of the same variable,
398 so long as they are `extern' declarations. However, there cannot
399 be two declarations of the same static data member:
401 [class.mem]
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);
411 ok = 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))
418 /* [namespace.alias]
420 In a declarative region, a namespace-alias-definition can be
421 used to redefine a namespace-alias declared in that declarative
422 region to refer only to the namespace to which it already
423 refers. */
424 ok = false;
425 else
427 // _1: diagnose_name_conflict (decl, bval);
428 ok = false;
431 gcc_assert (ok); // _1: return ok;
434 static void
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);
454 else
456 gcc_assert (DECL_CONTEXT (decl) == b->this_entity
457 || DECL_CONTEXT (decl) == global_namespace
458 || TREE_CODE (DECL_CONTEXT (decl)) == FUNCTION_DECL);
459 type = NULL_TREE;
462 /* Adjust IDENTIFIER_BINDING to what it would have been if we were
463 at binding level B. Save the binding chain up to that point in
464 [binding, *chainp), and take note of the outermost bindings found
465 before B. */
466 cxx_binding *binding = IDENTIFIER_BINDING (id), **chainp = NULL;
467 tree *shadowing_type_p = NULL;
468 if (binding)
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;
476 if (bc == b)
478 if (!chainp)
479 binding = NULL;
480 break;
482 chainp = &prev_binding->previous;
483 if (type)
484 for (tree tshadow = prev_binding->scope->type_shadowed;
485 tshadow; tshadow = TREE_CHAIN (tshadow))
486 if (TREE_PURPOSE (tshadow) == id)
488 shadowing_type_p = &TREE_VALUE (tshadow);
489 break;
493 if (chainp)
495 IDENTIFIER_BINDING (id) = *chainp;
496 *chainp = NULL;
499 /* Like push_local_binding, supplement or add a binding to the
500 desired level. */
501 if (IDENTIFIER_BINDING (id) && IDENTIFIER_BINDING (id)->scope == b)
502 supplement_binding (IDENTIFIER_BINDING (id), decl);
503 else
504 push_binding (id, decl, b);
506 /* Now restore the binding chain we'd temporarily removed. */
507 if (chainp)
509 *chainp = IDENTIFIER_BINDING (id);
510 IDENTIFIER_BINDING (id) = binding;
512 if (type)
514 /* Insert the new type binding in the shadowing_type_p
515 TREE_VALUE chain. */
516 tree shadowed_type = NULL_TREE;
517 if (shadowing_type_p)
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;
527 else if (type)
529 /* Our new binding is the active one, so shadow the earlier
530 binding. */
531 b->type_shadowed = tree_cons (id, REAL_IDENTIFIER_TYPE_VALUE (id),
532 b->type_shadowed);
533 TREE_TYPE (b->type_shadowed) = type;
534 SET_IDENTIFIER_TYPE_VALUE (id, type);
537 /* Record that we have a binding for ID, like add_decl_to_level. */
538 tree node = build_tree_list (NULL_TREE, decl);
539 TREE_CHAIN (node) = b->names;
540 b->names = node;
543 static void
544 plugin_pragma_push_user_expression (cpp_reader *)
546 if (push_count++)
547 return;
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;
564 int success;
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;
577 if (unchanged_cfun)
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);
585 else
587 cfun = save_cfun;
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))
600 tree decl = name;
601 if (TREE_CODE (decl) == TREE_LIST)
602 decl = TREE_VALUE (decl);
603 if (IDENTIFIER_MARKED (DECL_NAME (decl)))
604 continue;
605 IDENTIFIER_MARKED (DECL_NAME (decl)) = 1;
606 reactivate_decl (decl, b);
608 if (level->kind == sk_function_parms
609 && level->this_entity == cfun->decl)
610 break;
611 gcc_assert (!level->this_entity);
612 level = level->level_chain;
615 /* Now, clear the markers. */
616 for (tree name = b->names; name; name = TREE_CHAIN (name))
618 tree decl = name;
619 if (TREE_CODE (decl) == TREE_LIST)
620 decl = TREE_VALUE (decl);
621 gcc_assert (IDENTIFIER_MARKED (DECL_NAME (decl)));
622 IDENTIFIER_MARKED (DECL_NAME (decl)) = 0;
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
630 usable. */
631 tree this_val = lookup_name (get_identifier ("this"));
632 current_class_ref = !this_val ? NULL_TREE
633 : cp_build_indirect_ref (this_val, RO_NULL, tf_warning_or_error);
634 current_class_ptr = this_val;
638 static void
639 plugin_pragma_pop_user_expression (cpp_reader *)
641 if (--push_count)
642 return;
644 gcc_assert (cp_binding_oracle);
646 gcc_assert (at_function_scope_p ());
647 function *save_cfun = cfun;
648 current_class_ptr = NULL_TREE;
649 current_class_ref = NULL_TREE;
651 cfun = NULL;
652 pop_scope ();
653 if (RECORD_OR_UNION_CODE_P (TREE_CODE (DECL_CONTEXT (current_function_decl))))
654 current_class_type = DECL_CONTEXT (current_function_decl);
656 int success;
657 cc1_plugin::call (current_context, "leave_scope", &success);
659 if (!cfun)
660 cfun = save_cfun;
661 else
662 gcc_assert (cfun == save_cfun);
664 cp_binding_oracle = NULL;
665 gcc_assert (at_function_scope_p ());
668 static void
669 plugin_init_extra_pragmas (void *, void *)
671 c_register_pragma ("GCC", "push_user_expression", plugin_pragma_push_user_expression);
672 c_register_pragma ("GCC", "pop_user_expression", plugin_pragma_pop_user_expression);
673 /* FIXME: this one should go once we get GDB to use push and pop. */
674 c_register_pragma ("GCC", "user_expression", plugin_pragma_push_user_expression);
679 static decl_addr_value
680 build_decl_addr_value (tree decl, gcc_address address)
682 decl_addr_value value = {
683 decl,
684 build_int_cst_type (ptr_type_node, address)
686 return value;
689 static decl_addr_value *
690 record_decl_address (plugin_context *ctx, decl_addr_value value)
692 decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT);
693 gcc_assert (*slot == NULL);
694 *slot
695 = static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value)));
696 **slot = value;
697 /* We don't want GCC to warn about e.g. static functions
698 without a code definition. */
699 TREE_NO_WARNING (value.decl) = 1;
700 return *slot;
703 // Maybe rewrite a decl to its address.
704 static tree
705 address_rewriter (tree *in, int *walk_subtrees, void *arg)
707 plugin_context *ctx = (plugin_context *) arg;
709 if (!DECL_P (*in)
710 || TREE_CODE (*in) == NAMESPACE_DECL
711 || DECL_NAME (*in) == NULL_TREE)
712 return NULL_TREE;
714 decl_addr_value value;
715 value.decl = *in;
716 decl_addr_value *found_value = ctx->address_map.find (&value);
717 if (found_value != NULL)
719 else if (HAS_DECL_ASSEMBLER_NAME_P (*in))
721 gcc_address address;
723 if (!cc1_plugin::call (ctx, "address_oracle", &address,
724 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (*in))))
725 return NULL_TREE;
726 if (address == 0)
727 return NULL_TREE;
729 // Insert the decl into the address map in case it is referenced
730 // again.
731 value = build_decl_addr_value (value.decl, address);
732 found_value = record_decl_address (ctx, value);
734 else
735 return NULL_TREE;
737 if (found_value->address != error_mark_node)
739 // We have an address for the decl, so rewrite the tree.
740 tree ptr_type = build_pointer_type (TREE_TYPE (*in));
741 *in = fold_build1 (INDIRECT_REF, TREE_TYPE (*in),
742 fold_build1 (CONVERT_EXPR, ptr_type,
743 found_value->address));
746 *walk_subtrees = 0;
748 return NULL_TREE;
751 // When generating code for gdb, we want to be able to use absolute
752 // addresses to refer to otherwise external objects that gdb knows
753 // about. gdb passes in these addresses when building decls, and then
754 // before gimplification we go through the trees, rewriting uses to
755 // the equivalent of "*(TYPE *) ADDR".
756 static void
757 rewrite_decls_to_addresses (void *function_in, void *)
759 tree function = (tree) function_in;
761 // Do nothing if we're not in gdb.
762 if (current_context == NULL)
763 return;
765 walk_tree (&DECL_SAVED_TREE (function), address_rewriter, current_context,
766 NULL);
771 static inline tree
772 safe_push_template_decl (tree decl)
774 void (*save_oracle) (enum cp_oracle_request, tree identifier);
776 save_oracle = cp_binding_oracle;
777 cp_binding_oracle = NULL;
779 tree ret = push_template_decl (decl);
781 cp_binding_oracle = save_oracle;
783 return ret;
786 static inline tree
787 safe_pushtag (tree name, tree type, tag_scope scope)
789 void (*save_oracle) (enum cp_oracle_request, tree identifier);
791 save_oracle = cp_binding_oracle;
792 cp_binding_oracle = NULL;
794 tree ret = pushtag (name, type, scope);
796 cp_binding_oracle = save_oracle;
798 return ret;
801 static inline tree
802 safe_pushdecl_maybe_friend (tree decl, bool is_friend)
804 void (*save_oracle) (enum cp_oracle_request, tree identifier);
806 save_oracle = cp_binding_oracle;
807 cp_binding_oracle = NULL;
809 tree ret = pushdecl (decl, is_friend);
811 cp_binding_oracle = save_oracle;
813 return ret;
819 plugin_push_namespace (cc1_plugin::connection *,
820 const char *name)
822 if (name && !*name)
823 push_to_top_level ();
824 else
825 push_namespace (name ? get_identifier (name) : NULL);
827 return 1;
831 plugin_push_class (cc1_plugin::connection *,
832 gcc_type type_in)
834 tree type = convert_in (type_in);
835 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type)));
836 gcc_assert (TYPE_CONTEXT (type) == FROB_CONTEXT (current_scope ()));
838 pushclass (type);
840 return 1;
844 plugin_push_function (cc1_plugin::connection *,
845 gcc_decl function_decl_in)
847 tree fndecl = convert_in (function_decl_in);
848 gcc_assert (TREE_CODE (fndecl) == FUNCTION_DECL);
849 gcc_assert (DECL_CONTEXT (fndecl) == FROB_CONTEXT (current_scope ()));
851 push_fake_function (fndecl);
853 return 1;
857 plugin_pop_binding_level (cc1_plugin::connection *)
859 pop_scope ();
860 return 1;
864 plugin_reactivate_decl (cc1_plugin::connection *,
865 gcc_decl decl_in,
866 gcc_decl scope_in)
868 tree decl = convert_in (decl_in);
869 tree scope = convert_in (scope_in);
870 gcc_assert (TREE_CODE (decl) == VAR_DECL
871 || TREE_CODE (decl) == FUNCTION_DECL
872 || TREE_CODE (decl) == TYPE_DECL);
873 cp_binding_level *b;
874 if (scope)
876 gcc_assert (TREE_CODE (scope) == FUNCTION_DECL);
877 for (b = current_binding_level;
878 b->this_entity != scope;
879 b = b->level_chain)
880 gcc_assert (b->this_entity != global_namespace);
882 else
884 gcc_assert (!at_class_scope_p ());
885 b = current_binding_level;
888 reactivate_decl (decl, b);
889 return 1;
892 static tree
893 get_current_scope ()
895 tree decl;
897 if (at_namespace_scope_p ())
898 decl = current_namespace;
899 else if (at_class_scope_p ())
900 decl = TYPE_NAME (current_class_type);
901 else if (at_fake_function_scope_p () || at_function_scope_p ())
902 decl = current_function_decl;
903 else
904 gcc_unreachable ();
906 return decl;
909 gcc_decl
910 plugin_get_current_binding_level_decl (cc1_plugin::connection *)
912 tree decl = get_current_scope ();
914 return convert_out (decl);
918 plugin_make_namespace_inline (cc1_plugin::connection *)
920 tree inline_ns = current_namespace;
922 gcc_assert (toplevel_bindings_p ());
923 gcc_assert (inline_ns != global_namespace);
925 tree parent_ns = CP_DECL_CONTEXT (inline_ns);
927 if (DECL_NAMESPACE_INLINE_P (inline_ns))
928 return 0;
930 DECL_NAMESPACE_INLINE_P (inline_ns) = true;
931 vec_safe_push (DECL_NAMESPACE_INLINEES (parent_ns), inline_ns);
933 return 1;
937 plugin_add_using_namespace (cc1_plugin::connection *,
938 gcc_decl used_ns_in)
940 tree used_ns = convert_in (used_ns_in);
942 gcc_assert (TREE_CODE (used_ns) == NAMESPACE_DECL);
944 finish_namespace_using_directive (used_ns, NULL_TREE);
946 return 1;
950 plugin_add_namespace_alias (cc1_plugin::connection *,
951 const char *id,
952 gcc_decl target_in)
954 tree name = get_identifier (id);
955 tree target = convert_in (target_in);
957 do_namespace_alias (name, target);
959 return 1;
962 static inline void
963 set_access_flags (tree decl, enum gcc_cp_symbol_kind flags)
965 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !DECL_CLASS_SCOPE_P (decl));
967 switch (flags & GCC_CP_ACCESS_MASK)
969 case GCC_CP_ACCESS_PRIVATE:
970 TREE_PRIVATE (decl) = true;
971 current_access_specifier = access_private_node;
972 break;
974 case GCC_CP_ACCESS_PROTECTED:
975 TREE_PROTECTED (decl) = true;
976 current_access_specifier = access_protected_node;
977 break;
979 case GCC_CP_ACCESS_PUBLIC:
980 current_access_specifier = access_public_node;
981 break;
983 default:
984 break;
989 plugin_add_using_decl (cc1_plugin::connection *,
990 enum gcc_cp_symbol_kind flags,
991 gcc_decl target_in)
993 tree target = convert_in (target_in);
994 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_USING);
995 gcc_assert (!(flags & GCC_CP_FLAG_MASK));
996 enum gcc_cp_symbol_kind acc_flags;
997 acc_flags = (enum gcc_cp_symbol_kind) (flags & GCC_CP_ACCESS_MASK);
999 gcc_assert (!template_parm_scope_p ());
1001 bool class_member_p = at_class_scope_p ();
1002 gcc_assert (!(acc_flags & GCC_CP_ACCESS_MASK) == !class_member_p);
1004 tree identifier = DECL_NAME (target);
1005 tree tcontext = DECL_CONTEXT (target);
1007 if (UNSCOPED_ENUM_P (tcontext))
1008 tcontext = CP_TYPE_CONTEXT (tcontext);
1010 if (class_member_p)
1012 tree decl = do_class_using_decl (tcontext, identifier);
1014 set_access_flags (decl, flags);
1016 finish_member_declaration (decl);
1018 else
1020 /* We can't be at local scope. */
1021 gcc_assert (at_namespace_scope_p ());
1022 finish_namespace_using_decl (target, tcontext, identifier);
1025 return 1;
1028 static tree
1029 build_named_class_type (enum tree_code code,
1030 tree id,
1031 source_location loc)
1033 /* See at_fake_function_scope_p. */
1034 gcc_assert (!at_function_scope_p ());
1035 tree type = make_class_type (code);
1036 tree type_decl = build_decl (loc, TYPE_DECL, id, type);
1037 TYPE_NAME (type) = type_decl;
1038 TYPE_STUB_DECL (type) = type_decl;
1039 DECL_CONTEXT (type_decl) = TYPE_CONTEXT (type);
1041 return type_decl;
1044 /* Abuse an unused field of the dummy template parms entry to hold the
1045 parm list. */
1046 #define TP_PARM_LIST TREE_TYPE (current_template_parms)
1048 gcc_decl
1049 plugin_build_decl (cc1_plugin::connection *self,
1050 const char *name,
1051 enum gcc_cp_symbol_kind sym_kind,
1052 gcc_type sym_type_in,
1053 const char *substitution_name,
1054 gcc_address address,
1055 const char *filename,
1056 unsigned int line_number)
1058 plugin_context *ctx = static_cast<plugin_context *> (self);
1059 gcc_assert (!name || !strchr (name, ':')); // FIXME: this can go eventually.
1061 enum tree_code code;
1062 tree decl;
1063 tree sym_type = convert_in (sym_type_in);
1064 enum gcc_cp_symbol_kind sym_flags;
1065 sym_flags = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_FLAG_MASK);
1066 enum gcc_cp_symbol_kind acc_flags;
1067 acc_flags = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_ACCESS_MASK);
1068 sym_kind = (enum gcc_cp_symbol_kind) (sym_kind & GCC_CP_SYMBOL_MASK);
1070 switch (sym_kind)
1072 case GCC_CP_SYMBOL_FUNCTION:
1073 code = FUNCTION_DECL;
1074 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_FUNCTION));
1075 break;
1077 case GCC_CP_SYMBOL_VARIABLE:
1078 code = VAR_DECL;
1079 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_VARIABLE));
1080 break;
1082 case GCC_CP_SYMBOL_TYPEDEF:
1083 code = TYPE_DECL;
1084 gcc_assert (!sym_flags);
1085 break;
1087 case GCC_CP_SYMBOL_CLASS:
1088 code = RECORD_TYPE;
1089 gcc_assert (!(sym_flags & ~GCC_CP_FLAG_MASK_CLASS));
1090 gcc_assert (!sym_type);
1091 break;
1093 case GCC_CP_SYMBOL_UNION:
1094 code = UNION_TYPE;
1095 gcc_assert (!sym_flags);
1096 gcc_assert (!sym_type);
1097 break;
1099 default:
1100 gcc_unreachable ();
1103 bool template_decl_p = template_parm_scope_p ();
1105 if (template_decl_p)
1107 gcc_assert (code == FUNCTION_DECL || code == RECORD_TYPE
1108 || code == TYPE_DECL);
1110 /* Finish the template parm list that started this template parm. */
1111 end_template_parm_list (TP_PARM_LIST);
1113 gcc_assert (!address);
1114 gcc_assert (!substitution_name);
1117 source_location loc = ctx->get_source_location (filename, line_number);
1118 bool class_member_p = at_class_scope_p ();
1119 bool ctor = false, dtor = false, assop = false;
1120 tree_code opcode = ERROR_MARK;
1122 gcc_assert (!(acc_flags & GCC_CP_ACCESS_MASK) == !class_member_p);
1124 tree identifier;
1125 if (code != FUNCTION_DECL
1126 || !(sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION))
1128 if (name)
1129 identifier = get_identifier (name);
1130 else
1132 gcc_assert (RECORD_OR_UNION_CODE_P (code));
1133 identifier = make_anon_name ();
1137 if (code == FUNCTION_DECL)
1139 if (sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION)
1141 #define CHARS2(f,s) (((unsigned char)f << CHAR_BIT) | (unsigned char)s)
1142 switch (CHARS2 (name[0], name[1]))
1144 case CHARS2 ('C', 0x0): // ctor base declaration
1145 case CHARS2 ('C', ' '):
1146 case CHARS2 ('C', '1'):
1147 case CHARS2 ('C', '2'):
1148 case CHARS2 ('C', '4'):
1149 ctor = true;
1150 cdtor:
1151 gcc_assert (!address);
1152 gcc_assert (!substitution_name);
1153 identifier = DECL_NAME (TYPE_NAME (current_class_type));
1154 break;
1155 case CHARS2 ('D', 0x0): // dtor base declaration
1156 case CHARS2 ('D', ' '):
1157 case CHARS2 ('D', '0'):
1158 case CHARS2 ('D', '1'):
1159 case CHARS2 ('D', '2'):
1160 case CHARS2 ('D', '4'):
1161 gcc_assert (!template_decl_p);
1162 dtor = true;
1163 goto cdtor;
1164 case CHARS2 ('n', 'w'): // operator new
1165 opcode = NEW_EXPR;
1166 break;
1167 case CHARS2 ('n', 'a'): // operator new[]
1168 opcode = VEC_NEW_EXPR;
1169 break;
1170 case CHARS2 ('d', 'l'): // operator delete
1171 opcode = DELETE_EXPR;
1172 break;
1173 case CHARS2 ('d', 'a'): // operator delete[]
1174 opcode = VEC_DELETE_EXPR;
1175 break;
1176 case CHARS2 ('p', 's'): // operator + (unary)
1177 opcode = PLUS_EXPR;
1178 break;
1179 case CHARS2 ('n', 'g'): // operator - (unary)
1180 opcode = MINUS_EXPR;
1181 break;
1182 case CHARS2 ('a', 'd'): // operator & (unary)
1183 opcode = BIT_AND_EXPR;
1184 break;
1185 case CHARS2 ('d', 'e'): // operator * (unary)
1186 opcode = MULT_EXPR;
1187 break;
1188 case CHARS2 ('c', 'o'): // operator ~
1189 opcode = BIT_NOT_EXPR;
1190 break;
1191 case CHARS2 ('p', 'l'): // operator +
1192 opcode = PLUS_EXPR;
1193 break;
1194 case CHARS2 ('m', 'i'): // operator -
1195 opcode = MINUS_EXPR;
1196 break;
1197 case CHARS2 ('m', 'l'): // operator *
1198 opcode = MULT_EXPR;
1199 break;
1200 case CHARS2 ('d', 'v'): // operator /
1201 opcode = TRUNC_DIV_EXPR;
1202 break;
1203 case CHARS2 ('r', 'm'): // operator %
1204 opcode = TRUNC_MOD_EXPR;
1205 break;
1206 case CHARS2 ('a', 'n'): // operator &
1207 opcode = BIT_AND_EXPR;
1208 break;
1209 case CHARS2 ('o', 'r'): // operator |
1210 opcode = BIT_IOR_EXPR;
1211 break;
1212 case CHARS2 ('e', 'o'): // operator ^
1213 opcode = BIT_XOR_EXPR;
1214 break;
1215 case CHARS2 ('a', 'S'): // operator =
1216 opcode = NOP_EXPR;
1217 assop = true;
1218 break;
1219 case CHARS2 ('p', 'L'): // operator +=
1220 opcode = PLUS_EXPR;
1221 assop = true;
1222 break;
1223 case CHARS2 ('m', 'I'): // operator -=
1224 opcode = MINUS_EXPR;
1225 assop = true;
1226 break;
1227 case CHARS2 ('m', 'L'): // operator *=
1228 opcode = MULT_EXPR;
1229 assop = true;
1230 break;
1231 case CHARS2 ('d', 'V'): // operator /=
1232 opcode = TRUNC_DIV_EXPR;
1233 assop = true;
1234 break;
1235 case CHARS2 ('r', 'M'): // operator %=
1236 opcode = TRUNC_MOD_EXPR;
1237 assop = true;
1238 break;
1239 case CHARS2 ('a', 'N'): // operator &=
1240 opcode = BIT_AND_EXPR;
1241 assop = true;
1242 break;
1243 case CHARS2 ('o', 'R'): // operator |=
1244 opcode = BIT_IOR_EXPR;
1245 assop = true;
1246 break;
1247 case CHARS2 ('e', 'O'): // operator ^=
1248 opcode = BIT_XOR_EXPR;
1249 assop = true;
1250 break;
1251 case CHARS2 ('l', 's'): // operator <<
1252 opcode = LSHIFT_EXPR;
1253 break;
1254 case CHARS2 ('r', 's'): // operator >>
1255 opcode = RSHIFT_EXPR;
1256 break;
1257 case CHARS2 ('l', 'S'): // operator <<=
1258 opcode = LSHIFT_EXPR;
1259 assop = true;
1260 break;
1261 case CHARS2 ('r', 'S'): // operator >>=
1262 opcode = RSHIFT_EXPR;
1263 assop = true;
1264 break;
1265 case CHARS2 ('e', 'q'): // operator ==
1266 opcode = EQ_EXPR;
1267 break;
1268 case CHARS2 ('n', 'e'): // operator !=
1269 opcode = NE_EXPR;
1270 break;
1271 case CHARS2 ('l', 't'): // operator <
1272 opcode = LT_EXPR;
1273 break;
1274 case CHARS2 ('g', 't'): // operator >
1275 opcode = GT_EXPR;
1276 break;
1277 case CHARS2 ('l', 'e'): // operator <=
1278 opcode = LE_EXPR;
1279 break;
1280 case CHARS2 ('g', 'e'): // operator >=
1281 opcode = GE_EXPR;
1282 break;
1283 case CHARS2 ('n', 't'): // operator !
1284 opcode = TRUTH_NOT_EXPR;
1285 break;
1286 case CHARS2 ('a', 'a'): // operator &&
1287 opcode = TRUTH_ANDIF_EXPR;
1288 break;
1289 case CHARS2 ('o', 'o'): // operator ||
1290 opcode = TRUTH_ORIF_EXPR;
1291 break;
1292 case CHARS2 ('p', 'p'): // operator ++
1293 opcode = POSTINCREMENT_EXPR;
1294 break;
1295 case CHARS2 ('m', 'm'): // operator --
1296 /* This stands for either one as an operator name, and
1297 "pp" and "mm" stand for POST??CREMENT, but for some
1298 reason the parser uses this opcode name for
1299 operator--; let's follow their practice. */
1300 opcode = PREDECREMENT_EXPR;
1301 break;
1302 case CHARS2 ('c', 'm'): // operator ,
1303 opcode = COMPOUND_EXPR;
1304 break;
1305 case CHARS2 ('p', 'm'): // operator ->*
1306 opcode = MEMBER_REF;
1307 break;
1308 case CHARS2 ('p', 't'): // operator ->
1309 opcode = COMPONENT_REF;
1310 break;
1311 case CHARS2 ('c', 'l'): // operator ()
1312 opcode = CALL_EXPR;
1313 break;
1314 case CHARS2 ('i', 'x'): // operator []
1315 opcode = ARRAY_REF;
1316 break;
1317 case CHARS2 ('c', 'v'): // operator <T> (conversion operator)
1318 identifier = make_conv_op_name (TREE_TYPE (sym_type));
1319 break;
1320 // C++11-only:
1321 case CHARS2 ('l', 'i'): // operator "" <id>
1323 char *id = (char *)name + 2;
1324 bool freeid = false;
1325 if (*id >= '0' && *id <= '9')
1327 unsigned len = 0;
1330 len *= 10;
1331 len += id[0] - '0';
1332 id++;
1334 while (*id && *id >= '0' && *id <= '9');
1335 id = xstrndup (id, len);
1336 freeid = true;
1338 identifier = cp_literal_operator_id (id);
1339 if (freeid)
1340 free (id);
1342 break;
1343 case CHARS2 ('q', 'u'): // ternary operator, not overloadable.
1344 default:
1345 gcc_unreachable ();
1348 if (opcode != ERROR_MARK)
1349 identifier = ovl_op_identifier (assop, opcode);
1351 decl = build_lang_decl_loc (loc, code, identifier, sym_type);
1352 /* FIXME: current_lang_name is lang_name_c while compiling an
1353 extern "C" function, and we haven't switched to a global
1354 context at this point, and this breaks function
1355 overloading. */
1356 SET_DECL_LANGUAGE (decl, lang_cplusplus);
1357 if (TREE_CODE (sym_type) == METHOD_TYPE)
1358 DECL_ARGUMENTS (decl) = build_this_parm (decl, current_class_type,
1359 cp_type_quals (sym_type));
1360 for (tree arg = TREE_CODE (sym_type) == METHOD_TYPE
1361 ? TREE_CHAIN (TYPE_ARG_TYPES (sym_type))
1362 : TYPE_ARG_TYPES (sym_type);
1363 arg && arg != void_list_node;
1364 arg = TREE_CHAIN (arg))
1366 tree parm = cp_build_parm_decl (decl, NULL_TREE, TREE_VALUE (arg));
1367 DECL_CHAIN (parm) = DECL_ARGUMENTS (decl);
1368 DECL_ARGUMENTS (decl) = parm;
1370 DECL_ARGUMENTS (decl) = nreverse (DECL_ARGUMENTS (decl));
1371 if (class_member_p)
1373 if (TREE_CODE (sym_type) == FUNCTION_TYPE)
1374 DECL_STATIC_FUNCTION_P (decl) = 1;
1375 if (sym_flags & GCC_CP_FLAG_VIRTUAL_FUNCTION)
1377 DECL_VIRTUAL_P (decl) = 1;
1378 if (sym_flags & GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION)
1379 DECL_PURE_VIRTUAL_P (decl) = 1;
1380 if (sym_flags & GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION)
1381 DECL_FINAL_P (decl) = 1;
1383 else
1384 gcc_assert (!(sym_flags & (GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
1385 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION)));
1387 else
1389 gcc_assert (!(sym_flags & (GCC_CP_FLAG_VIRTUAL_FUNCTION
1390 | GCC_CP_FLAG_PURE_VIRTUAL_FUNCTION
1391 | GCC_CP_FLAG_FINAL_VIRTUAL_FUNCTION)));
1392 gcc_assert (!ctor && !dtor && !assop);
1394 if (sym_flags & GCC_CP_FLAG_EXPLICIT_FUNCTION)
1395 DECL_NONCONVERTING_P (decl) = 1;
1396 if (sym_flags & GCC_CP_FLAG_DEFAULTED_FUNCTION)
1398 DECL_INITIAL (decl) = ridpointers[(int)RID_DEFAULT];
1399 DECL_DEFAULTED_FN (decl) = 1;
1401 if (sym_flags & GCC_CP_FLAG_DELETED_FUNCTION)
1403 // DECL_INITIAL (decl) = ridpointers[(int)RID_DELETE];
1404 DECL_DELETED_FN (decl) = 1;
1405 DECL_DECLARED_INLINE_P (decl) = 1;
1406 DECL_INITIAL (decl) = error_mark_node;
1409 if (ctor)
1410 DECL_CXX_CONSTRUCTOR_P (decl) = 1;
1411 else if (dtor)
1412 DECL_CXX_DESTRUCTOR_P (decl) = 1;
1413 else if ((sym_flags & GCC_CP_FLAG_SPECIAL_FUNCTION)
1414 && opcode != ERROR_MARK)
1415 DECL_OVERLOADED_OPERATOR_CODE_RAW (decl) = ovl_op_mapping[opcode];
1417 else if (RECORD_OR_UNION_CODE_P (code))
1419 decl = build_named_class_type (code, identifier, loc);
1420 tree type = TREE_TYPE (decl);
1422 if (code == RECORD_TYPE
1423 && !(sym_flags & GCC_CP_FLAG_CLASS_IS_STRUCT))
1424 CLASSTYPE_DECLARED_CLASS (type) = true;
1426 else if (class_member_p)
1428 decl = build_lang_decl_loc (loc, code, identifier, sym_type);
1430 if (TREE_CODE (decl) == VAR_DECL)
1432 DECL_THIS_STATIC (decl) = 1;
1433 // The remainder of this block does the same as:
1434 // set_linkage_for_static_data_member (decl);
1435 TREE_PUBLIC (decl) = 1;
1436 TREE_STATIC (decl) = 1;
1437 DECL_INTERFACE_KNOWN (decl) = 1;
1439 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
1440 gcc_assert (!(sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE));
1442 if (sym_flags & GCC_CP_FLAG_CONSTEXPR_VARIABLE)
1443 DECL_DECLARED_CONSTEXPR_P (decl) = true;
1446 else
1448 decl = build_decl (loc, code, identifier, sym_type);
1450 if (TREE_CODE (decl) == VAR_DECL)
1452 // FIXME: sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE
1453 gcc_assert (!(sym_flags & GCC_CP_FLAG_THREAD_LOCAL_VARIABLE));
1455 if (sym_flags & GCC_CP_FLAG_CONSTEXPR_VARIABLE)
1456 DECL_DECLARED_CONSTEXPR_P (decl) = true;
1459 TREE_USED (decl) = 1;
1460 TREE_ADDRESSABLE (decl) = 1;
1462 if (class_member_p)
1463 DECL_CONTEXT (decl) = FROB_CONTEXT (current_class_type);
1464 else if (at_namespace_scope_p ())
1465 DECL_CONTEXT (decl) = FROB_CONTEXT (current_decl_namespace ());
1467 set_access_flags (decl, acc_flags);
1469 /* If this is the typedef that names an otherwise anonymous type,
1470 propagate the typedef name to the type. In normal compilation,
1471 this is done in grokdeclarator. */
1472 if (sym_kind == GCC_CP_SYMBOL_TYPEDEF
1473 && !template_decl_p
1474 && DECL_CONTEXT (decl) == TYPE_CONTEXT (sym_type)
1475 && TYPE_UNNAMED_P (sym_type))
1476 name_unnamed_type (sym_type, decl);
1478 if (sym_kind != GCC_CP_SYMBOL_TYPEDEF
1479 && sym_kind != GCC_CP_SYMBOL_CLASS
1480 && sym_kind != GCC_CP_SYMBOL_UNION
1481 && !template_decl_p && !ctor && !dtor)
1483 decl_addr_value value;
1485 DECL_EXTERNAL (decl) = 1;
1486 value.decl = decl;
1487 if (substitution_name != NULL)
1489 // If the translator gave us a name without a binding,
1490 // we can just substitute error_mark_node, since we know the
1491 // translator will be reporting an error anyhow.
1492 value.address
1493 = lookup_name (get_identifier (substitution_name));
1494 if (value.address == NULL_TREE)
1495 value.address = error_mark_node;
1497 else if (address)
1498 value.address = build_int_cst_type (ptr_type_node, address);
1499 else
1500 value.address = NULL;
1501 if (value.address)
1502 record_decl_address (ctx, value);
1505 if (class_member_p && code == FUNCTION_DECL)
1507 if (ctor || dtor)
1508 maybe_retrofit_in_chrg (decl);
1510 grok_special_member_properties (decl);
1513 if (template_decl_p)
1515 if (RECORD_OR_UNION_CODE_P (code))
1516 safe_pushtag (identifier, TREE_TYPE (decl), ts_current);
1517 else
1518 decl = safe_push_template_decl (decl);
1520 tree tdecl = NULL_TREE;
1521 if (class_member_p)
1522 tdecl = finish_member_template_decl (decl);
1524 end_template_decl ();
1526 /* We only support one level of templates, because we only
1527 support declaring generics; actual definitions are only of
1528 specializations. */
1529 gcc_assert (!template_parm_scope_p ());
1531 if (class_member_p)
1532 finish_member_declaration (tdecl);
1534 else if (RECORD_OR_UNION_CODE_P (code))
1535 safe_pushtag (identifier, TREE_TYPE (decl), ts_current);
1536 else if (class_member_p)
1537 finish_member_declaration (decl);
1538 else
1539 decl = safe_pushdecl_maybe_friend (decl, false);
1541 if ((ctor || dtor)
1542 /* Don't crash after a duplicate declaration of a cdtor. */
1543 && TYPE_FIELDS (current_class_type) == decl)
1545 /* ctors and dtors clones are chained after DECL.
1546 However, we create the clones before TYPE_METHODS is
1547 reversed. We test for cloned methods after reversal,
1548 however, and the test requires the clones to follow
1549 DECL. So, we reverse the chain of clones now, so
1550 that it will come out in the right order after
1551 reversal. */
1552 tree save = DECL_CHAIN (decl);
1553 DECL_CHAIN (decl) = NULL_TREE;
1554 clone_function_decl (decl, /*update_methods=*/true);
1555 gcc_assert (TYPE_FIELDS (current_class_type) == decl);
1556 TYPE_FIELDS (current_class_type)
1557 = nreverse (TYPE_FIELDS (current_class_type));
1558 DECL_CHAIN (decl) = save;
1561 rest_of_decl_compilation (decl, toplevel_bindings_p (), 0);
1563 return convert_out (ctx->preserve (decl));
1566 gcc_decl
1567 plugin_define_cdtor_clone (cc1_plugin::connection *self,
1568 const char *name,
1569 gcc_decl cdtor_in,
1570 gcc_address address)
1572 plugin_context *ctx = static_cast<plugin_context *> (self);
1573 tree decl = convert_in (cdtor_in);
1574 bool ctor = false;
1575 bool dtor = false;
1576 tree identifier;
1578 switch (CHARS2 (name[0], name[1]))
1580 case CHARS2 ('C', '1'): // in-charge constructor
1581 identifier = complete_ctor_identifier;
1582 ctor = true;
1583 break;
1584 case CHARS2 ('C', '2'): // not-in-charge constructor
1585 identifier = base_ctor_identifier;
1586 ctor = true;
1587 break;
1588 case CHARS2 ('C', '4'):
1589 identifier = ctor_identifier; // unified constructor
1590 ctor = true;
1591 break;
1592 case CHARS2 ('D', '0'): // deleting destructor
1593 identifier = deleting_dtor_identifier;
1594 dtor = true;
1595 break;
1596 case CHARS2 ('D', '1'): // in-charge destructor
1597 identifier = complete_dtor_identifier;
1598 dtor = true;
1599 break;
1600 case CHARS2 ('D', '2'): // not-in-charge destructor
1601 identifier = base_dtor_identifier;
1602 dtor = true;
1603 break;
1604 case CHARS2 ('D', '4'):
1605 identifier = dtor_identifier; // unified destructor
1606 dtor = true;
1607 break;
1609 default:
1610 gcc_unreachable ();
1613 gcc_assert (!ctor != !dtor);
1614 gcc_assert (ctor
1615 ? (DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (decl)
1616 && DECL_NAME (decl) == ctor_identifier)
1617 : (DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (decl)
1618 && DECL_NAME (decl) == dtor_identifier));
1620 while (decl && DECL_NAME (decl) != identifier)
1622 decl = DECL_CHAIN (decl);
1623 if (decl && !DECL_CLONED_FUNCTION_P (decl))
1624 decl = NULL_TREE;
1626 gcc_assert (decl);
1628 record_decl_address (ctx, build_decl_addr_value (decl, address));
1630 return convert_out (decl);
1634 plugin_add_friend (cc1_plugin::connection * /* self */,
1635 gcc_decl decl_in,
1636 gcc_type type_in)
1638 tree decl = convert_in (decl_in);
1639 tree type = convert_in (type_in);
1641 gcc_assert (type || at_class_scope_p ());
1643 if (!type)
1644 type = current_class_type;
1645 else
1646 gcc_assert (TREE_CODE (type) == RECORD_TYPE);
1648 if (TYPE_P (decl))
1649 make_friend_class (type, TREE_TYPE (decl), true);
1650 else
1652 DECL_FRIEND_P (decl) = true;
1653 add_friend (type, decl, true);
1656 return 1;
1659 gcc_type
1660 plugin_build_pointer_type (cc1_plugin::connection *,
1661 gcc_type base_type)
1663 // No need to preserve a pointer type as the base type is preserved.
1664 return convert_out (build_pointer_type (convert_in (base_type)));
1667 gcc_type
1668 plugin_build_reference_type (cc1_plugin::connection *,
1669 gcc_type base_type_in,
1670 enum gcc_cp_ref_qualifiers rquals)
1672 bool rval;
1674 switch (rquals)
1676 case GCC_CP_REF_QUAL_LVALUE:
1677 rval = false;
1678 break;
1679 case GCC_CP_REF_QUAL_RVALUE:
1680 rval = true;
1681 break;
1682 case GCC_CP_REF_QUAL_NONE:
1683 default:
1684 gcc_unreachable ();
1687 tree rtype = cp_build_reference_type (convert_in (base_type_in), rval);
1689 return convert_out (rtype);
1692 static tree
1693 start_class_def (tree type,
1694 const gcc_vbase_array *base_classes)
1696 tree bases = NULL;
1697 if (base_classes)
1699 for (int i = 0; i < base_classes->n_elements; i++)
1701 tree access;
1703 gcc_assert ((base_classes->flags[i] & GCC_CP_SYMBOL_MASK)
1704 == GCC_CP_SYMBOL_BASECLASS);
1706 switch (base_classes->flags[i] & GCC_CP_ACCESS_MASK)
1708 case GCC_CP_ACCESS_PRIVATE:
1709 access = ridpointers[(int)RID_PRIVATE];
1710 break;
1712 case GCC_CP_ACCESS_PROTECTED:
1713 access = ridpointers[(int)RID_PROTECTED];
1714 break;
1716 case GCC_CP_ACCESS_PUBLIC:
1717 access = ridpointers[(int)RID_PUBLIC];
1718 break;
1720 default:
1721 gcc_unreachable ();
1724 tree base = finish_base_specifier
1725 (convert_in (base_classes->elements[i]), access,
1726 (base_classes->flags[i] & GCC_CP_FLAG_BASECLASS_VIRTUAL) != 0);
1727 TREE_CHAIN (base) = bases;
1728 bases = base;
1730 bases = nreverse (bases);
1732 xref_basetypes (type, bases);
1733 begin_class_definition (type);
1734 return type;
1737 gcc_type
1738 plugin_start_class_type (cc1_plugin::connection *self,
1739 gcc_decl typedecl_in,
1740 const gcc_vbase_array *base_classes,
1741 const char *filename,
1742 unsigned int line_number)
1744 plugin_context *ctx = static_cast<plugin_context *> (self);
1745 source_location loc = ctx->get_source_location (filename, line_number);
1746 tree typedecl = convert_in (typedecl_in);
1747 tree type = TREE_TYPE (typedecl);
1749 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (type)));
1750 gcc_assert (!COMPLETE_TYPE_P (type));
1752 DECL_SOURCE_LOCATION (typedecl) = loc;
1754 tree result = start_class_def (type, base_classes);
1756 return convert_out (ctx->preserve (result));
1759 gcc_type
1760 plugin_start_closure_class_type (cc1_plugin::connection *self,
1761 int discriminator,
1762 gcc_decl extra_scope_in,
1763 enum gcc_cp_symbol_kind flags,
1764 const char *filename,
1765 unsigned int line_number)
1767 plugin_context *ctx = static_cast<plugin_context *> (self);
1768 tree extra_scope = convert_in (extra_scope_in);
1770 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_LAMBDA_CLOSURE);
1771 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK))) == 0);
1773 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !at_class_scope_p ());
1775 /* See at_fake_function_scope_p. */
1776 gcc_assert (!at_function_scope_p ());
1778 if (extra_scope)
1780 if (TREE_CODE (extra_scope) == PARM_DECL)
1782 gcc_assert (at_fake_function_scope_p ());
1783 /* Check that the given extra_scope is one of the parameters of
1784 the current function. */
1785 for (tree parm = DECL_ARGUMENTS (current_function_decl);
1786 ; parm = DECL_CHAIN (parm))
1788 gcc_assert (parm);
1789 if (parm == extra_scope)
1790 break;
1793 else if (TREE_CODE (extra_scope) == FIELD_DECL)
1795 gcc_assert (at_class_scope_p ());
1796 gcc_assert (DECL_CONTEXT (extra_scope) == current_class_type);
1798 else
1799 /* FIXME: does this ever really occur? */
1800 gcc_assert (TREE_CODE (extra_scope) == VAR_DECL);
1803 tree lambda_expr = build_lambda_expr ();
1805 LAMBDA_EXPR_LOCATION (lambda_expr) = ctx->get_source_location (filename,
1806 line_number);
1808 tree type = begin_lambda_type (lambda_expr);
1810 /* Instead of calling record_lambda_scope, do this: */
1811 LAMBDA_EXPR_EXTRA_SCOPE (lambda_expr) = extra_scope;
1812 LAMBDA_EXPR_DISCRIMINATOR (lambda_expr) = discriminator;
1814 tree decl = TYPE_NAME (type);
1815 determine_visibility (decl);
1816 set_access_flags (decl, flags);
1818 return convert_out (ctx->preserve (type));
1821 gcc_expr
1822 plugin_build_lambda_expr (cc1_plugin::connection *self,
1823 gcc_type closure_type_in)
1825 plugin_context *ctx = static_cast<plugin_context *> (self);
1826 tree closure_type = convert_in (closure_type_in);
1828 gcc_assert (LAMBDA_TYPE_P (closure_type));
1830 tree lambda_expr = CLASSTYPE_LAMBDA_EXPR (closure_type);
1832 tree lambda_object = build_lambda_object (lambda_expr);
1834 return convert_out (ctx->preserve (lambda_object));
1837 gcc_decl
1838 plugin_build_field (cc1_plugin::connection *,
1839 const char *field_name,
1840 gcc_type field_type_in,
1841 enum gcc_cp_symbol_kind flags,
1842 unsigned long bitsize,
1843 unsigned long bitpos)
1845 tree record_or_union_type = current_class_type;
1846 tree field_type = convert_in (field_type_in);
1848 gcc_assert (at_class_scope_p ());
1849 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type)));
1850 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_FIELD);
1851 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK
1852 | GCC_CP_FLAG_MASK_FIELD))) == 0);
1853 gcc_assert ((flags & GCC_CP_ACCESS_MASK));
1855 /* Note that gdb does not preserve the location of field decls, so
1856 we can't provide a decent location here. */
1857 tree decl = build_decl (BUILTINS_LOCATION, FIELD_DECL,
1858 get_identifier (field_name), field_type);
1859 DECL_FIELD_CONTEXT (decl) = record_or_union_type;
1861 set_access_flags (decl, flags);
1863 if ((flags & GCC_CP_FLAG_FIELD_MUTABLE) != 0)
1864 DECL_MUTABLE_P (decl) = 1;
1866 if (TREE_CODE (field_type) == INTEGER_TYPE
1867 && TYPE_PRECISION (field_type) != bitsize)
1869 DECL_BIT_FIELD_TYPE (decl) = field_type;
1870 TREE_TYPE (decl)
1871 = c_build_bitfield_integer_type (bitsize, TYPE_UNSIGNED (field_type));
1874 SET_DECL_MODE (decl, TYPE_MODE (TREE_TYPE (decl)));
1876 // There's no way to recover this from DWARF.
1877 SET_DECL_OFFSET_ALIGN (decl, TYPE_PRECISION (pointer_sized_int_node));
1879 tree pos = bitsize_int (bitpos);
1880 pos_from_bit (&DECL_FIELD_OFFSET (decl), &DECL_FIELD_BIT_OFFSET (decl),
1881 DECL_OFFSET_ALIGN (decl), pos);
1883 DECL_SIZE (decl) = bitsize_int (bitsize);
1884 DECL_SIZE_UNIT (decl) = size_int ((bitsize + BITS_PER_UNIT - 1)
1885 / BITS_PER_UNIT);
1887 DECL_CHAIN (decl) = TYPE_FIELDS (record_or_union_type);
1888 TYPE_FIELDS (record_or_union_type) = decl;
1890 return convert_out (decl);
1894 plugin_finish_class_type (cc1_plugin::connection *,
1895 unsigned long size_in_bytes)
1897 tree record_or_union_type = current_class_type;
1899 gcc_assert (RECORD_OR_UNION_CODE_P (TREE_CODE (record_or_union_type)));
1901 finish_struct (record_or_union_type, NULL);
1903 gcc_assert (compare_tree_int (TYPE_SIZE_UNIT (record_or_union_type),
1904 size_in_bytes) == 0);
1906 return 1;
1909 gcc_type
1910 plugin_start_enum_type (cc1_plugin::connection *self,
1911 const char *name,
1912 gcc_type underlying_int_type_in,
1913 enum gcc_cp_symbol_kind flags,
1914 const char *filename,
1915 unsigned int line_number)
1917 plugin_context *ctx = static_cast<plugin_context *> (self);
1918 tree underlying_int_type = convert_in (underlying_int_type_in);
1920 gcc_assert ((flags & GCC_CP_SYMBOL_MASK) == GCC_CP_SYMBOL_ENUM);
1921 gcc_assert ((flags & (~(GCC_CP_SYMBOL_MASK | GCC_CP_ACCESS_MASK
1922 | GCC_CP_FLAG_MASK_ENUM))) == 0);
1923 gcc_assert (!(flags & GCC_CP_ACCESS_MASK) == !at_class_scope_p ());
1925 if (underlying_int_type == error_mark_node)
1926 return convert_out (error_mark_node);
1928 bool is_new_type = false;
1930 tree id = name ? get_identifier (name) : make_anon_name ();
1932 tree type = start_enum (id, NULL_TREE,
1933 underlying_int_type,
1934 /* attributes = */ NULL_TREE,
1935 !!(flags & GCC_CP_FLAG_ENUM_SCOPED), &is_new_type);
1937 gcc_assert (is_new_type);
1939 source_location loc = ctx->get_source_location (filename, line_number);
1940 tree type_decl = TYPE_NAME (type);
1941 DECL_SOURCE_LOCATION (type_decl) = loc;
1942 SET_OPAQUE_ENUM_P (type, false);
1944 set_access_flags (type_decl, flags);
1946 return convert_out (ctx->preserve (type));
1949 gcc_decl
1950 plugin_build_enum_constant (cc1_plugin::connection *,
1951 gcc_type enum_type_in,
1952 const char *name,
1953 unsigned long value)
1955 tree enum_type = convert_in (enum_type_in);
1957 gcc_assert (TREE_CODE (enum_type) == ENUMERAL_TYPE);
1959 build_enumerator (get_identifier (name), build_int_cst (enum_type, value),
1960 enum_type, NULL_TREE, BUILTINS_LOCATION);
1962 return convert_out (TREE_VALUE (TYPE_VALUES (enum_type)));
1966 plugin_finish_enum_type (cc1_plugin::connection *,
1967 gcc_type enum_type_in)
1969 tree enum_type = convert_in (enum_type_in);
1971 finish_enum_value_list (enum_type);
1972 finish_enum (enum_type);
1974 return 1;
1977 gcc_type
1978 plugin_build_function_type (cc1_plugin::connection *self,
1979 gcc_type return_type_in,
1980 const struct gcc_type_array *argument_types_in,
1981 int is_varargs)
1983 tree *argument_types;
1984 tree return_type = convert_in (return_type_in);
1985 tree result;
1987 argument_types = new tree[argument_types_in->n_elements];
1988 for (int i = 0; i < argument_types_in->n_elements; ++i)
1989 argument_types[i] = convert_in (argument_types_in->elements[i]);
1991 if (is_varargs)
1992 result = build_varargs_function_type_array (return_type,
1993 argument_types_in->n_elements,
1994 argument_types);
1995 else
1996 result = build_function_type_array (return_type,
1997 argument_types_in->n_elements,
1998 argument_types);
2000 delete[] argument_types;
2002 plugin_context *ctx = static_cast<plugin_context *> (self);
2003 return convert_out (ctx->preserve (result));
2006 #if 0
2008 gcc_type
2009 plugin_add_function_default_args (cc1_plugin::connection *self,
2010 gcc_type function_type_in,
2011 const struct gcc_cp_function_args *defaults)
2013 tree function_type = convert_in (function_type_in);
2015 gcc_assert (TREE_CODE (function_type) == FUNCTION_TYPE);
2017 if (!defaults || !defaults->n_elements)
2018 return function_type_in;
2020 tree pargs = TYPE_ARG_TYPES (function_type);
2021 tree nargs = NULL_TREE;
2023 /* Build a reversed copy of the list of default-less arguments in
2024 NARGS. At the end of the loop, PARGS will point to the end of
2025 the argument list, or to the first argument that had a default
2026 value. */
2027 while (pargs && TREE_VALUE (pargs) != void_list_node
2028 && !TREE_PURPOSE (pargs))
2030 nargs = tree_cons (NULL_TREE, TREE_VALUE (pargs), nargs);
2031 pargs = TREE_CHAIN (pargs);
2034 /* Set the defaults in the now-leading NARGS, taking into account
2035 that NARGS is reversed but DEFAULTS->elements isn't. */
2036 tree ndargs = nargs;
2037 int i = defaults->n_elements;
2038 while (i--)
2040 gcc_assert (ndargs);
2041 tree deflt = convert_in (defaults->elements[i]);
2042 if (!deflt)
2043 deflt = error_mark_node;
2044 TREE_PURPOSE (ndargs) = deflt;
2045 ndargs = TREE_CHAIN (ndargs);
2048 /* Finally, reverse NARGS, and append the remaining PARGS that
2049 already had defaults. */
2050 nargs = nreverse (nargs);
2051 nargs = chainon (nargs, pargs);
2053 tree result = build_function_type (TREE_TYPE (function_type), nargs);
2055 /* Copy exceptions, attributes and whatnot. */
2056 result = build_exception_variant (result,
2057 TYPE_RAISES_EXCEPTIONS (function_type));
2058 result = cp_build_type_attribute_variant (result,
2059 TYPE_ATTRIBUTES (function_type));
2061 plugin_context *ctx = static_cast<plugin_context *> (self);
2062 return convert_out (ctx->preserve (result));
2066 plugin_set_deferred_function_default_args (cc1_plugin::connection *,
2067 gcc_decl function_in,
2068 const struct gcc_cp_function_args
2069 *defaults)
2071 tree function = convert_in (function_in);
2073 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
2075 if (!defaults || !defaults->n_elements)
2076 return 1;
2078 tree arg = FUNCTION_FIRST_USER_PARMTYPE (function);
2080 for (int i = 0; i < defaults->n_elements; i++)
2082 while (arg && TREE_PURPOSE (arg) != error_mark_node)
2083 arg = TREE_CHAIN (arg);
2085 if (!arg)
2086 return 0;
2088 TREE_PURPOSE (arg) = convert_in (defaults->elements[i]);
2089 arg = TREE_CHAIN (arg);
2092 return 1;
2095 #endif
2097 gcc_decl
2098 plugin_get_function_parameter_decl (cc1_plugin::connection *,
2099 gcc_decl function_in,
2100 int index)
2102 tree function = convert_in (function_in);
2104 gcc_assert (TREE_CODE (function) == FUNCTION_DECL);
2106 if (index == -1)
2108 gcc_assert (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE);
2110 return convert_out (DECL_ARGUMENTS (function));
2113 gcc_assert (index >= 0);
2115 tree args = FUNCTION_FIRST_USER_PARM (function);
2117 for (int i = 0; args && i < index; i++)
2118 args = DECL_CHAIN (args);
2120 return convert_out (args);
2123 gcc_type
2124 plugin_build_exception_spec_variant (cc1_plugin::connection *self,
2125 gcc_type function_type_in,
2126 const struct gcc_type_array *except_types_in)
2128 tree function_type = convert_in (function_type_in);
2129 tree except_types = NULL_TREE;
2131 if (!except_types_in)
2132 except_types = noexcept_false_spec;
2133 else if (!except_types_in->n_elements)
2134 except_types = empty_except_spec;
2135 else
2136 for (int i = 0; i < except_types_in->n_elements; i++)
2137 except_types = add_exception_specifier (except_types,
2138 convert_in
2139 (except_types_in->elements[i]),
2142 function_type = build_exception_variant (function_type,
2143 except_types);
2145 plugin_context *ctx = static_cast<plugin_context *> (self);
2146 return convert_out (ctx->preserve (function_type));
2149 gcc_type
2150 plugin_build_method_type (cc1_plugin::connection *self,
2151 gcc_type class_type_in,
2152 gcc_type func_type_in,
2153 enum gcc_cp_qualifiers quals_in,
2154 enum gcc_cp_ref_qualifiers rquals_in)
2156 tree class_type = convert_in (class_type_in);
2157 tree func_type = convert_in (func_type_in);
2158 cp_cv_quals quals = 0;
2159 cp_ref_qualifier rquals;
2161 if ((quals_in & GCC_CP_QUALIFIER_CONST) != 0)
2162 quals |= TYPE_QUAL_CONST;
2163 if ((quals_in & GCC_CP_QUALIFIER_VOLATILE) != 0)
2164 quals |= TYPE_QUAL_VOLATILE;
2165 gcc_assert ((quals_in & GCC_CP_QUALIFIER_RESTRICT) == 0);
2167 switch (rquals_in)
2169 case GCC_CP_REF_QUAL_NONE:
2170 rquals = REF_QUAL_NONE;
2171 break;
2172 case GCC_CP_REF_QUAL_LVALUE:
2173 rquals = REF_QUAL_LVALUE;
2174 break;
2175 case GCC_CP_REF_QUAL_RVALUE:
2176 rquals = REF_QUAL_RVALUE;
2177 break;
2178 default:
2179 gcc_unreachable ();
2182 tree method_type = class_type
2183 ? build_memfn_type (func_type, class_type, quals, rquals)
2184 : apply_memfn_quals (func_type, quals, rquals);
2186 plugin_context *ctx = static_cast<plugin_context *> (self);
2187 return convert_out (ctx->preserve (method_type));
2190 gcc_type
2191 plugin_build_pointer_to_member_type (cc1_plugin::connection *self,
2192 gcc_type class_type_in,
2193 gcc_type member_type_in)
2195 tree class_type = convert_in (class_type_in);
2196 tree member_type = convert_in (member_type_in);
2198 tree memptr_type = build_ptrmem_type (class_type, member_type);
2200 plugin_context *ctx = static_cast<plugin_context *> (self);
2201 return convert_out (ctx->preserve (memptr_type));
2205 plugin_start_template_decl (cc1_plugin::connection *)
2207 begin_template_parm_list ();
2209 TP_PARM_LIST = NULL_TREE;
2211 return 1;
2214 gcc_decl
2215 plugin_get_type_decl (cc1_plugin::connection *,
2216 gcc_type type_in)
2218 tree type = convert_in (type_in);
2220 tree name = TYPE_NAME (type);
2221 gcc_assert (name);
2223 return convert_out (name);
2226 gcc_type
2227 plugin_get_decl_type (cc1_plugin::connection *,
2228 gcc_decl decl_in)
2230 tree decl = convert_in (decl_in);
2232 tree type = TREE_TYPE (decl);
2233 gcc_assert (type);
2235 return convert_out (type);
2238 gcc_type
2239 plugin_build_type_template_parameter (cc1_plugin::connection *self,
2240 const char *id,
2241 int /* bool */ pack_p,
2242 gcc_type default_type,
2243 const char *filename,
2244 unsigned int line_number)
2246 plugin_context *ctx = static_cast<plugin_context *> (self);
2247 source_location loc = ctx->get_source_location (filename, line_number);
2249 gcc_assert (template_parm_scope_p ());
2251 tree parm = finish_template_type_parm (class_type_node, get_identifier (id));
2252 parm = build_tree_list (convert_in (default_type), parm);
2254 gcc_assert (!(pack_p && default_type));
2256 /* Create a type and a decl for the type parm, and add the decl to
2257 TP_PARM_LIST. */
2258 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm,
2259 /* is_non_type = */ false, pack_p);
2261 /* Locate the decl of the newly-added, processed template parm. */
2262 parm = TREE_VALUE (tree_last (TP_PARM_LIST));
2264 /* Return its type. */
2265 return convert_out (ctx->preserve (TREE_TYPE (parm)));
2268 gcc_utempl
2269 plugin_build_template_template_parameter (cc1_plugin::connection *self,
2270 const char *id,
2271 int /* bool */ pack_p,
2272 gcc_utempl default_templ,
2273 const char *filename,
2274 unsigned int line_number)
2276 plugin_context *ctx = static_cast<plugin_context *> (self);
2277 source_location loc = ctx->get_source_location (filename, line_number);
2279 gcc_assert (template_parm_scope_p ());
2281 /* Finish the template parm list that started this template parm. */
2282 end_template_parm_list (TP_PARM_LIST);
2284 gcc_assert (template_parm_scope_p ());
2286 tree parm = finish_template_template_parm (class_type_node,
2287 get_identifier (id));
2288 parm = build_tree_list (convert_in (default_templ), parm);
2290 gcc_assert (!(pack_p && default_templ));
2292 /* Create a type and a decl for the template parm, and add the decl
2293 to TP_PARM_LIST. */
2294 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm,
2295 /* is_non_type = */ false, pack_p);
2297 /* Locate the decl of the newly-added, processed template parm. */
2298 parm = TREE_VALUE (tree_last (TP_PARM_LIST));
2300 return convert_out (ctx->preserve (parm));
2303 gcc_decl
2304 plugin_build_value_template_parameter (cc1_plugin::connection *self,
2305 gcc_type type,
2306 const char *id,
2307 gcc_expr default_value,
2308 const char *filename,
2309 unsigned int line_number)
2311 plugin_context *ctx = static_cast<plugin_context *> (self);
2312 source_location loc = ctx->get_source_location (filename, line_number);
2314 gcc_assert (template_parm_scope_p ());
2316 cp_declarator declarator;
2317 memset (&declarator, 0, sizeof (declarator));
2318 // &declarator = make_id_declarator (NULL, get_identifier (id), sfk_none):
2319 declarator.kind = cdk_id;
2320 declarator.u.id.qualifying_scope = NULL;
2321 declarator.u.id.unqualified_name = get_identifier (id);
2322 declarator.u.id.sfk = sfk_none;
2324 cp_decl_specifier_seq declspec;
2325 memset (&declspec, 0, sizeof (declspec));
2326 // cp_parser_set_decl_spec_type (&declspec, convert_in (type), -token-, false):
2327 declspec.any_specifiers_p = declspec.any_type_specifiers_p = true;
2328 declspec.type = convert_in (type);
2329 declspec.locations[ds_type_spec] = loc;
2331 tree parm = grokdeclarator (&declarator, &declspec, TPARM, 0, 0);
2332 parm = build_tree_list (convert_in (default_value), parm);
2334 /* Create a type and a decl for the template parm, and add the decl
2335 to TP_PARM_LIST. */
2336 TP_PARM_LIST = process_template_parm (TP_PARM_LIST, loc, parm,
2337 /* is_non_type = */ true, false);
2339 /* Locate the decl of the newly-added, processed template parm. */
2340 parm = TREE_VALUE (tree_last (TP_PARM_LIST));
2342 return convert_out (ctx->preserve (parm));
2345 static tree
2346 targlist (const gcc_cp_template_args *targs)
2348 int n = targs->n_elements;
2349 tree vec = make_tree_vec (n);
2350 while (n--)
2352 switch (targs->kinds[n])
2354 case GCC_CP_TPARG_VALUE:
2355 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].value);
2356 break;
2357 case GCC_CP_TPARG_CLASS:
2358 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].type);
2359 break;
2360 case GCC_CP_TPARG_TEMPL:
2361 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].templ);
2362 break;
2363 case GCC_CP_TPARG_PACK:
2364 TREE_VEC_ELT (vec, n) = convert_in (targs->elements[n].pack);
2365 break;
2366 default:
2367 gcc_unreachable ();
2370 return vec;
2373 gcc_type
2374 plugin_build_dependent_typename (cc1_plugin::connection *self,
2375 gcc_type enclosing_type,
2376 const char *id,
2377 const gcc_cp_template_args *targs)
2379 plugin_context *ctx = static_cast<plugin_context *> (self);
2380 tree type = convert_in (enclosing_type);
2381 tree name = get_identifier (id);
2382 if (targs)
2383 name = build_min_nt_loc (/*loc=*/0, TEMPLATE_ID_EXPR,
2384 name, targlist (targs));
2385 tree res = make_typename_type (type, name, typename_type,
2386 /*complain=*/tf_error);
2387 return convert_out (ctx->preserve (res));
2390 gcc_utempl
2391 plugin_build_dependent_class_template (cc1_plugin::connection *self,
2392 gcc_type enclosing_type,
2393 const char *id)
2395 plugin_context *ctx = static_cast<plugin_context *> (self);
2396 tree type = convert_in (enclosing_type);
2397 tree name = get_identifier (id);
2398 tree res = make_unbound_class_template (type, name, NULL_TREE,
2399 /*complain=*/tf_error);
2400 return convert_out (ctx->preserve (res));
2403 gcc_type
2404 plugin_build_dependent_type_template_id (cc1_plugin::connection *self,
2405 gcc_utempl template_decl,
2406 const gcc_cp_template_args *targs)
2408 plugin_context *ctx = static_cast<plugin_context *> (self);
2409 tree type = convert_in (template_decl);
2410 tree decl = finish_template_type (type, targlist (targs),
2411 /*entering_scope=*/false);
2412 return convert_out (ctx->preserve (TREE_TYPE (decl)));
2415 gcc_expr
2416 plugin_build_dependent_expr (cc1_plugin::connection *self,
2417 gcc_decl enclosing_scope,
2418 enum gcc_cp_symbol_kind flags,
2419 const char *name,
2420 gcc_type conv_type_in,
2421 const gcc_cp_template_args *targs)
2423 plugin_context *ctx = static_cast<plugin_context *> (self);
2424 tree scope = convert_in (enclosing_scope);
2425 tree conv_type = convert_in (conv_type_in);
2426 tree identifier;
2428 if (TREE_CODE (scope) != NAMESPACE_DECL)
2430 tree type = TREE_TYPE (scope);
2431 gcc_assert (TYPE_NAME (type) == scope);
2432 scope = type;
2435 if (flags == (GCC_CP_SYMBOL_FUNCTION | GCC_CP_FLAG_SPECIAL_FUNCTION))
2437 bool assop = false, convop = false;
2438 tree_code opcode = ERROR_MARK;
2440 switch (CHARS2 (name[0], name[1]))
2442 case CHARS2 ('C', 0x0): // ctor base declaration
2443 case CHARS2 ('C', ' '):
2444 case CHARS2 ('C', '1'):
2445 case CHARS2 ('C', '2'):
2446 case CHARS2 ('C', '4'):
2447 identifier = ctor_identifier;
2448 break;
2449 case CHARS2 ('D', 0x0): // dtor base declaration
2450 case CHARS2 ('D', ' '):
2451 case CHARS2 ('D', '0'):
2452 case CHARS2 ('D', '1'):
2453 case CHARS2 ('D', '2'):
2454 case CHARS2 ('D', '4'):
2455 gcc_assert (!targs);
2456 identifier = dtor_identifier;
2457 break;
2458 case CHARS2 ('n', 'w'): // operator new
2459 opcode = NEW_EXPR;
2460 break;
2461 case CHARS2 ('n', 'a'): // operator new[]
2462 opcode = VEC_NEW_EXPR;
2463 break;
2464 case CHARS2 ('d', 'l'): // operator delete
2465 opcode = DELETE_EXPR;
2466 break;
2467 case CHARS2 ('d', 'a'): // operator delete[]
2468 opcode = VEC_DELETE_EXPR;
2469 break;
2470 case CHARS2 ('p', 's'): // operator + (unary)
2471 opcode = PLUS_EXPR;
2472 break;
2473 case CHARS2 ('n', 'g'): // operator - (unary)
2474 opcode = MINUS_EXPR;
2475 break;
2476 case CHARS2 ('a', 'd'): // operator & (unary)
2477 opcode = BIT_AND_EXPR;
2478 break;
2479 case CHARS2 ('d', 'e'): // operator * (unary)
2480 opcode = MULT_EXPR;
2481 break;
2482 case CHARS2 ('c', 'o'): // operator ~
2483 opcode = BIT_NOT_EXPR;
2484 break;
2485 case CHARS2 ('p', 'l'): // operator +
2486 opcode = PLUS_EXPR;
2487 break;
2488 case CHARS2 ('m', 'i'): // operator -
2489 opcode = MINUS_EXPR;
2490 break;
2491 case CHARS2 ('m', 'l'): // operator *
2492 opcode = MULT_EXPR;
2493 break;
2494 case CHARS2 ('d', 'v'): // operator /
2495 opcode = TRUNC_DIV_EXPR;
2496 break;
2497 case CHARS2 ('r', 'm'): // operator %
2498 opcode = TRUNC_MOD_EXPR;
2499 break;
2500 case CHARS2 ('a', 'n'): // operator &
2501 opcode = BIT_AND_EXPR;
2502 break;
2503 case CHARS2 ('o', 'r'): // operator |
2504 opcode = BIT_IOR_EXPR;
2505 break;
2506 case CHARS2 ('e', 'o'): // operator ^
2507 opcode = BIT_XOR_EXPR;
2508 break;
2509 case CHARS2 ('a', 'S'): // operator =
2510 opcode = NOP_EXPR;
2511 assop = true;
2512 break;
2513 case CHARS2 ('p', 'L'): // operator +=
2514 opcode = PLUS_EXPR;
2515 assop = true;
2516 break;
2517 case CHARS2 ('m', 'I'): // operator -=
2518 opcode = MINUS_EXPR;
2519 assop = true;
2520 break;
2521 case CHARS2 ('m', 'L'): // operator *=
2522 opcode = MULT_EXPR;
2523 assop = true;
2524 break;
2525 case CHARS2 ('d', 'V'): // operator /=
2526 opcode = TRUNC_DIV_EXPR;
2527 assop = true;
2528 break;
2529 case CHARS2 ('r', 'M'): // operator %=
2530 opcode = TRUNC_MOD_EXPR;
2531 assop = true;
2532 break;
2533 case CHARS2 ('a', 'N'): // operator &=
2534 opcode = BIT_AND_EXPR;
2535 assop = true;
2536 break;
2537 case CHARS2 ('o', 'R'): // operator |=
2538 opcode = BIT_IOR_EXPR;
2539 assop = true;
2540 break;
2541 case CHARS2 ('e', 'O'): // operator ^=
2542 opcode = BIT_XOR_EXPR;
2543 assop = true;
2544 break;
2545 case CHARS2 ('l', 's'): // operator <<
2546 opcode = LSHIFT_EXPR;
2547 break;
2548 case CHARS2 ('r', 's'): // operator >>
2549 opcode = RSHIFT_EXPR;
2550 break;
2551 case CHARS2 ('l', 'S'): // operator <<=
2552 opcode = LSHIFT_EXPR;
2553 assop = true;
2554 break;
2555 case CHARS2 ('r', 'S'): // operator >>=
2556 opcode = RSHIFT_EXPR;
2557 assop = true;
2558 break;
2559 case CHARS2 ('e', 'q'): // operator ==
2560 opcode = EQ_EXPR;
2561 break;
2562 case CHARS2 ('n', 'e'): // operator !=
2563 opcode = NE_EXPR;
2564 break;
2565 case CHARS2 ('l', 't'): // operator <
2566 opcode = LT_EXPR;
2567 break;
2568 case CHARS2 ('g', 't'): // operator >
2569 opcode = GT_EXPR;
2570 break;
2571 case CHARS2 ('l', 'e'): // operator <=
2572 opcode = LE_EXPR;
2573 break;
2574 case CHARS2 ('g', 'e'): // operator >=
2575 opcode = GE_EXPR;
2576 break;
2577 case CHARS2 ('n', 't'): // operator !
2578 opcode = TRUTH_NOT_EXPR;
2579 break;
2580 case CHARS2 ('a', 'a'): // operator &&
2581 opcode = TRUTH_ANDIF_EXPR;
2582 break;
2583 case CHARS2 ('o', 'o'): // operator ||
2584 opcode = TRUTH_ORIF_EXPR;
2585 break;
2586 case CHARS2 ('p', 'p'): // operator ++
2587 opcode = POSTINCREMENT_EXPR;
2588 break;
2589 case CHARS2 ('m', 'm'): // operator --
2590 opcode = PREDECREMENT_EXPR;
2591 break;
2592 case CHARS2 ('c', 'm'): // operator ,
2593 opcode = COMPOUND_EXPR;
2594 break;
2595 case CHARS2 ('p', 'm'): // operator ->*
2596 opcode = MEMBER_REF;
2597 break;
2598 case CHARS2 ('p', 't'): // operator ->
2599 opcode = COMPONENT_REF;
2600 break;
2601 case CHARS2 ('c', 'l'): // operator ()
2602 opcode = CALL_EXPR;
2603 break;
2604 case CHARS2 ('i', 'x'): // operator []
2605 opcode = ARRAY_REF;
2606 break;
2607 case CHARS2 ('c', 'v'): // operator <T> (conversion operator)
2608 convop = true;
2609 identifier = make_conv_op_name (conv_type);
2610 break;
2611 // C++11-only:
2612 case CHARS2 ('l', 'i'): // operator "" <id>
2614 char *id = (char *)name + 2;
2615 bool freeid = false;
2616 if (*id >= '0' && *id <= '9')
2618 unsigned len = 0;
2621 len *= 10;
2622 len += id[0] - '0';
2623 id++;
2625 while (*id && *id >= '0' && *id <= '9');
2626 id = xstrndup (id, len);
2627 freeid = true;
2629 identifier = cp_literal_operator_id (id);
2630 if (freeid)
2631 free (id);
2633 break;
2634 case CHARS2 ('q', 'u'): // ternary operator, not overloadable.
2635 default:
2636 gcc_unreachable ();
2639 gcc_assert (convop || !conv_type);
2641 if (opcode != ERROR_MARK)
2642 identifier = ovl_op_identifier (assop, opcode);
2644 gcc_assert (identifier);
2646 else
2648 gcc_assert (flags == GCC_CP_SYMBOL_MASK);
2649 gcc_assert (!conv_type);
2650 identifier = get_identifier (name);
2652 tree res = identifier;
2653 if (!scope)
2654 res = lookup_name_real (res, 0, 0, true, 0, 0);
2655 else if (!TYPE_P (scope) || !dependent_scope_p (scope))
2657 res = lookup_qualified_name (scope, res, false, true);
2658 /* We've already resolved the name in the scope, so skip the
2659 build_qualified_name call below. */
2660 scope = NULL;
2662 if (targs)
2663 res = lookup_template_function (res, targlist (targs));
2664 if (scope)
2665 res = build_qualified_name (NULL_TREE, scope, res, !!targs);
2666 return convert_out (ctx->preserve (res));
2669 gcc_expr
2670 plugin_build_literal_expr (cc1_plugin::connection *self,
2671 gcc_type type, unsigned long value)
2673 plugin_context *ctx = static_cast<plugin_context *> (self);
2674 tree t = convert_in (type);
2675 tree val = build_int_cst_type (t, (unsigned HOST_WIDE_INT) value);
2676 return convert_out (ctx->preserve (val));
2679 gcc_expr
2680 plugin_build_decl_expr (cc1_plugin::connection *self,
2681 gcc_decl decl_in,
2682 int qualified_p)
2684 plugin_context *ctx = static_cast<plugin_context *> (self);
2685 tree decl = convert_in (decl_in);
2686 gcc_assert (DECL_P (decl));
2687 tree result = decl;
2688 if (qualified_p)
2690 gcc_assert (DECL_CLASS_SCOPE_P (decl));
2691 result = build_offset_ref (DECL_CONTEXT (decl), decl,
2692 /*address_p=*/true, tf_error);
2694 return convert_out (ctx->preserve (result));
2697 gcc_expr
2698 plugin_build_unary_expr (cc1_plugin::connection *self,
2699 const char *unary_op,
2700 gcc_expr operand)
2702 plugin_context *ctx = static_cast<plugin_context *> (self);
2703 tree op0 = convert_in (operand);
2704 tree_code opcode = ERROR_MARK;
2705 bool global_scope_p = false;
2707 once_more:
2708 switch (CHARS2 (unary_op[0], unary_op[1]))
2710 case CHARS2 ('p', 's'): // operator + (unary)
2711 opcode = UNARY_PLUS_EXPR;
2712 break;
2713 case CHARS2 ('n', 'g'): // operator - (unary)
2714 opcode = NEGATE_EXPR;
2715 break;
2716 case CHARS2 ('a', 'd'): // operator & (unary)
2717 opcode = ADDR_EXPR;
2718 break;
2719 case CHARS2 ('d', 'e'): // operator * (unary)
2720 opcode = INDIRECT_REF;
2721 break;
2722 case CHARS2 ('c', 'o'): // operator ~
2723 opcode = BIT_NOT_EXPR;
2724 break;
2725 case CHARS2 ('n', 't'): // operator !
2726 opcode = TRUTH_NOT_EXPR;
2727 break;
2728 case CHARS2 ('p', 'p'): // operator ++
2729 opcode = unary_op[2] == '_' ? PREINCREMENT_EXPR : POSTINCREMENT_EXPR;
2730 break;
2731 case CHARS2 ('m', 'm'): // operator --
2732 opcode = unary_op[2] == '_' ? PREDECREMENT_EXPR : POSTDECREMENT_EXPR;
2733 break;
2734 case CHARS2 ('n', 'x'): // noexcept
2735 opcode = NOEXCEPT_EXPR;
2736 break;
2737 case CHARS2 ('t', 'w'): // throw
2738 gcc_assert (op0);
2739 opcode = THROW_EXPR;
2740 break;
2741 case CHARS2 ('t', 'r'): // rethrow
2742 gcc_assert (!op0);
2743 opcode = THROW_EXPR;
2744 break;
2745 case CHARS2 ('t', 'e'): // typeid (value)
2746 opcode = TYPEID_EXPR;
2747 break;
2748 case CHARS2 ('s', 'z'): // sizeof (value)
2749 opcode = SIZEOF_EXPR;
2750 break;
2751 case CHARS2 ('a', 'z'): // alignof (value)
2752 opcode = ALIGNOF_EXPR;
2753 break;
2754 case CHARS2 ('g', 's'): // global scope (for delete, delete[])
2755 gcc_assert (!global_scope_p);
2756 global_scope_p = true;
2757 unary_op += 2;
2758 goto once_more;
2759 case CHARS2 ('d', 'l'): // delete
2760 opcode = DELETE_EXPR;
2761 break;
2762 case CHARS2 ('d', 'a'): // delete[]
2763 opcode = VEC_DELETE_EXPR;
2764 break;
2765 case CHARS2 ('s', 'p'): // pack...
2766 opcode = EXPR_PACK_EXPANSION;
2767 break;
2768 case CHARS2 ('s', 'Z'): // sizeof...(pack)
2769 opcode = TYPE_PACK_EXPANSION; // Not really, but let's use its code.
2770 break;
2772 /* FIXME: __real__, __imag__? */
2774 default:
2775 gcc_unreachable ();
2778 gcc_assert (!global_scope_p
2779 || opcode == DELETE_EXPR || opcode == VEC_DELETE_EXPR);
2781 processing_template_decl++;
2782 bool template_dependent_p = op0
2783 && (type_dependent_expression_p (op0)
2784 || value_dependent_expression_p (op0));
2785 if (!template_dependent_p)
2786 processing_template_decl--;
2788 tree result;
2790 gcc_assert (op0 || opcode == THROW_EXPR);
2792 switch (opcode)
2794 case NOEXCEPT_EXPR:
2795 result = finish_noexcept_expr (op0, tf_error);
2796 break;
2798 case THROW_EXPR:
2799 result = build_throw (op0);
2800 break;
2802 case TYPEID_EXPR:
2803 result = build_typeid (op0, tf_error);
2804 break;
2806 case SIZEOF_EXPR:
2807 case ALIGNOF_EXPR:
2808 result = cxx_sizeof_or_alignof_expr (op0, opcode, true);
2809 break;
2811 case DELETE_EXPR:
2812 case VEC_DELETE_EXPR:
2813 result = delete_sanity (op0, NULL_TREE, opcode == VEC_DELETE_EXPR,
2814 global_scope_p, tf_error);
2815 break;
2817 case EXPR_PACK_EXPANSION:
2818 result = make_pack_expansion (op0);
2819 break;
2821 // We're using this for sizeof...(pack). */
2822 case TYPE_PACK_EXPANSION:
2823 result = make_pack_expansion (op0);
2824 PACK_EXPANSION_SIZEOF_P (result) = true;
2825 break;
2827 default:
2828 result = build_x_unary_op (/*loc=*/0, opcode, op0, tf_error);
2829 break;
2832 if (template_dependent_p)
2833 processing_template_decl--;
2835 return convert_out (ctx->preserve (result));
2838 gcc_expr
2839 plugin_build_binary_expr (cc1_plugin::connection *self,
2840 const char *binary_op,
2841 gcc_expr operand1,
2842 gcc_expr operand2)
2844 plugin_context *ctx = static_cast<plugin_context *> (self);
2845 tree op0 = convert_in (operand1);
2846 tree op1 = convert_in (operand2);
2847 tree_code opcode = ERROR_MARK;
2849 switch (CHARS2 (binary_op[0], binary_op[1]))
2851 case CHARS2 ('p', 'l'): // operator +
2852 opcode = PLUS_EXPR;
2853 break;
2854 case CHARS2 ('m', 'i'): // operator -
2855 opcode = MINUS_EXPR;
2856 break;
2857 case CHARS2 ('m', 'l'): // operator *
2858 opcode = MULT_EXPR;
2859 break;
2860 case CHARS2 ('d', 'v'): // operator /
2861 opcode = TRUNC_DIV_EXPR;
2862 break;
2863 case CHARS2 ('r', 'm'): // operator %
2864 opcode = TRUNC_MOD_EXPR;
2865 break;
2866 case CHARS2 ('a', 'n'): // operator &
2867 opcode = BIT_AND_EXPR;
2868 break;
2869 case CHARS2 ('o', 'r'): // operator |
2870 opcode = BIT_IOR_EXPR;
2871 break;
2872 case CHARS2 ('e', 'o'): // operator ^
2873 opcode = BIT_XOR_EXPR;
2874 break;
2875 case CHARS2 ('l', 's'): // operator <<
2876 opcode = LSHIFT_EXPR;
2877 break;
2878 case CHARS2 ('r', 's'): // operator >>
2879 opcode = RSHIFT_EXPR;
2880 break;
2881 case CHARS2 ('e', 'q'): // operator ==
2882 opcode = EQ_EXPR;
2883 break;
2884 case CHARS2 ('n', 'e'): // operator !=
2885 opcode = NE_EXPR;
2886 break;
2887 case CHARS2 ('l', 't'): // operator <
2888 opcode = LT_EXPR;
2889 break;
2890 case CHARS2 ('g', 't'): // operator >
2891 opcode = GT_EXPR;
2892 break;
2893 case CHARS2 ('l', 'e'): // operator <=
2894 opcode = LE_EXPR;
2895 break;
2896 case CHARS2 ('g', 'e'): // operator >=
2897 opcode = GE_EXPR;
2898 break;
2899 case CHARS2 ('a', 'a'): // operator &&
2900 opcode = TRUTH_ANDIF_EXPR;
2901 break;
2902 case CHARS2 ('o', 'o'): // operator ||
2903 opcode = TRUTH_ORIF_EXPR;
2904 break;
2905 case CHARS2 ('c', 'm'): // operator ,
2906 opcode = COMPOUND_EXPR;
2907 break;
2908 case CHARS2 ('p', 'm'): // operator ->*
2909 opcode = MEMBER_REF;
2910 break;
2911 case CHARS2 ('p', 't'): // operator ->
2912 opcode = INDIRECT_REF; // Not really! This will stand for
2913 // INDIRECT_REF followed by COMPONENT_REF
2914 // later on.
2915 break;
2916 case CHARS2 ('i', 'x'): // operator []
2917 opcode = ARRAY_REF;
2918 break;
2919 case CHARS2 ('d', 's'): // operator .*
2920 opcode = DOTSTAR_EXPR;
2921 break;
2922 case CHARS2 ('d', 't'): // operator .
2923 opcode = COMPONENT_REF;
2924 break;
2926 default:
2927 gcc_unreachable ();
2930 processing_template_decl++;
2931 bool template_dependent_p = type_dependent_expression_p (op0)
2932 || value_dependent_expression_p (op0)
2933 || type_dependent_expression_p (op1)
2934 || value_dependent_expression_p (op1);
2935 if (!template_dependent_p)
2936 processing_template_decl--;
2938 tree result;
2940 switch (opcode)
2942 case INDIRECT_REF: // This is actually a "->".
2943 op0 = build_x_arrow (/*loc=*/0, op0, tf_error);
2944 /* Fall through. */
2945 case COMPONENT_REF:
2946 result = finish_class_member_access_expr (op0, op1,
2947 /*template_p=*/false,
2948 tf_error);
2949 break;
2951 default:
2952 result = build_x_binary_op (/*loc=*/0, opcode, op0, ERROR_MARK,
2953 op1, ERROR_MARK, NULL, tf_error);
2954 break;
2957 if (template_dependent_p)
2958 processing_template_decl--;
2960 return convert_out (ctx->preserve (result));
2963 gcc_expr
2964 plugin_build_ternary_expr (cc1_plugin::connection *self,
2965 const char *ternary_op,
2966 gcc_expr operand1,
2967 gcc_expr operand2,
2968 gcc_expr operand3)
2970 plugin_context *ctx = static_cast<plugin_context *> (self);
2971 tree op0 = convert_in (operand1);
2972 tree op1 = convert_in (operand2);
2973 tree op2 = convert_in (operand3);
2974 gcc_assert (CHARS2 (ternary_op[0], ternary_op[1])
2975 == CHARS2 ('q', 'u')); // ternary operator
2977 processing_template_decl++;
2978 bool template_dependent_p = type_dependent_expression_p (op0)
2979 || value_dependent_expression_p (op0)
2980 || type_dependent_expression_p (op1)
2981 || value_dependent_expression_p (op1)
2982 || type_dependent_expression_p (op2)
2983 || value_dependent_expression_p (op2);
2984 if (!template_dependent_p)
2985 processing_template_decl--;
2987 tree val = build_x_conditional_expr (/*loc=*/0, op0, op1, op2, tf_error);
2989 if (template_dependent_p)
2990 processing_template_decl--;
2992 return convert_out (ctx->preserve (val));
2995 gcc_expr
2996 plugin_build_unary_type_expr (cc1_plugin::connection *self,
2997 const char *unary_op,
2998 gcc_type operand)
3000 plugin_context *ctx = static_cast<plugin_context *> (self);
3001 tree type = convert_in (operand);
3002 tree_code opcode = ERROR_MARK;
3004 switch (CHARS2 (unary_op[0], unary_op[1]))
3006 case CHARS2 ('t', 'i'): // typeid (type)
3007 opcode = TYPEID_EXPR;
3008 break;
3010 case CHARS2 ('s', 't'): // sizeof (type)
3011 opcode = SIZEOF_EXPR;
3012 break;
3013 case CHARS2 ('a', 't'): // alignof (type)
3014 opcode = ALIGNOF_EXPR;
3015 break;
3017 case CHARS2 ('s', 'Z'): // sizeof...(pack)
3018 opcode = TYPE_PACK_EXPANSION; // Not really, but let's use its code.
3019 break;
3021 // FIXME: do we have to handle "sp", for the size of a captured
3022 // template parameter pack from an alias template, taking
3023 // multiple template arguments?
3025 default:
3026 gcc_unreachable ();
3029 processing_template_decl++;
3030 bool template_dependent_p = dependent_type_p (type);
3031 if (!template_dependent_p)
3032 processing_template_decl--;
3034 tree result;
3036 switch (opcode)
3038 case TYPEID_EXPR:
3039 result = get_typeid (type, tf_error);
3040 break;
3042 // We're using this for sizeof...(pack). */
3043 case TYPE_PACK_EXPANSION:
3044 result = make_pack_expansion (type);
3045 PACK_EXPANSION_SIZEOF_P (result) = true;
3046 break;
3048 default:
3049 result = cxx_sizeof_or_alignof_type (type, opcode, true);
3052 if (template_dependent_p)
3053 processing_template_decl--;
3055 return convert_out (ctx->preserve (result));
3058 gcc_expr
3059 plugin_build_cast_expr (cc1_plugin::connection *self,
3060 const char *binary_op,
3061 gcc_type operand1,
3062 gcc_expr operand2)
3064 plugin_context *ctx = static_cast<plugin_context *> (self);
3065 tree (*build_cast)(tree type, tree expr, tsubst_flags_t complain) = NULL;
3066 tree type = convert_in (operand1);
3067 tree expr = convert_in (operand2);
3069 switch (CHARS2 (binary_op[0], binary_op[1]))
3071 case CHARS2 ('d', 'c'): // dynamic_cast
3072 build_cast = build_dynamic_cast;
3073 break;
3075 case CHARS2 ('s', 'c'): // static_cast
3076 build_cast = build_static_cast;
3077 break;
3079 case CHARS2 ('c', 'c'): // const_cast
3080 build_cast = build_const_cast;
3081 break;
3083 case CHARS2 ('r', 'c'): // reinterpret_cast
3084 build_cast = build_reinterpret_cast;
3085 break;
3087 case CHARS2 ('c', 'v'): // C cast, conversion with one argument
3088 build_cast = cp_build_c_cast;
3089 break;
3091 default:
3092 gcc_unreachable ();
3095 processing_template_decl++;
3096 bool template_dependent_p = dependent_type_p (type)
3097 || type_dependent_expression_p (expr)
3098 || value_dependent_expression_p (expr);
3099 if (!template_dependent_p)
3100 processing_template_decl--;
3102 tree val = build_cast (type, expr, tf_error);
3104 if (template_dependent_p)
3105 processing_template_decl--;
3107 return convert_out (ctx->preserve (val));
3110 static inline vec<tree, va_gc> *
3111 args_to_tree_vec (const struct gcc_cp_function_args *args_in)
3113 vec<tree, va_gc> *args = make_tree_vector ();
3114 for (int i = 0; i < args_in->n_elements; i++)
3115 vec_safe_push (args, convert_in (args_in->elements[i]));
3116 return args;
3119 static inline tree
3120 args_to_tree_list (const struct gcc_cp_function_args *args_in)
3122 tree args, *tail = &args;
3123 for (int i = 0; i < args_in->n_elements; i++)
3125 *tail = build_tree_list (NULL, convert_in (args_in->elements[i]));
3126 tail = &TREE_CHAIN (*tail);
3128 return args;
3131 static inline vec<constructor_elt, va_gc> *
3132 args_to_ctor_elts (const struct gcc_cp_function_args *args_in)
3134 vec<constructor_elt, va_gc> *args = NULL;
3135 for (int i = 0; i < args_in->n_elements; i++)
3136 CONSTRUCTOR_APPEND_ELT (args, NULL_TREE, convert_in (args_in->elements[i]));
3137 return args;
3140 gcc_expr
3141 plugin_build_expression_list_expr (cc1_plugin::connection *self,
3142 const char *conv_op,
3143 gcc_type type_in,
3144 const struct gcc_cp_function_args *values_in)
3146 plugin_context *ctx = static_cast<plugin_context *> (self);
3147 tree type = convert_in (type_in);
3148 tree args;
3149 tree result;
3151 switch (CHARS2 (conv_op[0], conv_op[1]))
3153 case CHARS2 ('c', 'v'): // conversion with parenthesized expression list
3154 gcc_assert (TYPE_P (type));
3155 args = args_to_tree_list (values_in);
3156 result = build_functional_cast (type, args, tf_error);
3157 break;
3159 case CHARS2 ('t', 'l'): // conversion with braced expression list
3160 gcc_assert (type);
3161 gcc_assert (TYPE_P (type));
3162 args = make_node (CONSTRUCTOR);
3163 CONSTRUCTOR_ELTS (args) = args_to_ctor_elts (values_in);
3164 CONSTRUCTOR_IS_DIRECT_INIT (args) = 1;
3165 result = finish_compound_literal (type, args, tf_error);
3166 break;
3168 case CHARS2 ('i', 'l'): // untyped braced expression list
3169 gcc_assert (!type);
3170 result = make_node (CONSTRUCTOR);
3171 CONSTRUCTOR_ELTS (result) = args_to_ctor_elts (values_in);
3172 break;
3174 default:
3175 gcc_unreachable ();
3178 return convert_out (ctx->preserve (result));
3181 gcc_expr
3182 plugin_build_new_expr (cc1_plugin::connection *self,
3183 const char *new_op,
3184 const struct gcc_cp_function_args *placement_in,
3185 gcc_type type_in,
3186 const struct gcc_cp_function_args *initializer_in)
3188 plugin_context *ctx = static_cast<plugin_context *> (self);
3189 tree type = convert_in (type_in);
3190 vec<tree, va_gc> *placement = NULL, *initializer = NULL;
3191 bool global_scope_p = false;
3192 tree nelts = NULL;
3194 if (placement_in)
3195 placement = args_to_tree_vec (placement_in);
3196 if (initializer_in)
3197 initializer = args_to_tree_vec (initializer_in);
3199 gcc_assert (TYPE_P (type));
3201 once_more:
3202 switch (CHARS2 (new_op[0], new_op[1]))
3204 case CHARS2 ('g', 's'):
3205 gcc_assert (!global_scope_p);
3206 global_scope_p = true;
3207 new_op += 2;
3208 goto once_more;
3210 case CHARS2 ('n', 'w'): // non-array new
3211 gcc_assert (TREE_CODE (type) != ARRAY_TYPE);
3212 break;
3214 case CHARS2 ('n', 'a'): // array new
3215 gcc_assert (TREE_CODE (type) == ARRAY_TYPE);
3216 gcc_assert (TYPE_DOMAIN (type));
3218 // Compute the length of the outermost array type, then discard it.
3219 tree maxelt = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
3220 tree eltype = TREE_TYPE (maxelt);
3221 tree onecst = integer_one_node;
3223 processing_template_decl++;
3224 bool template_dependent_p = value_dependent_expression_p (maxelt)
3225 || type_dependent_expression_p (maxelt);
3226 if (!template_dependent_p)
3228 processing_template_decl--;
3229 onecst = fold_convert (eltype, onecst);
3232 nelts = fold_build2 (PLUS_EXPR, eltype, nelts, onecst);
3234 if (template_dependent_p)
3235 processing_template_decl--;
3237 type = TREE_TYPE (type);
3239 break;
3241 default:
3242 gcc_unreachable ();
3245 processing_template_decl++;
3246 bool template_dependent_p = dependent_type_p (type)
3247 || value_dependent_expression_p (nelts)
3248 || (placement
3249 && any_type_dependent_arguments_p (placement))
3250 || (initializer
3251 && any_type_dependent_arguments_p (initializer));
3252 if (!template_dependent_p)
3253 processing_template_decl--;
3255 tree result = build_new (&placement, type, nelts, &initializer,
3256 global_scope_p, tf_error);
3258 if (template_dependent_p)
3259 processing_template_decl--;
3261 if (placement != NULL)
3262 release_tree_vector (placement);
3263 if (initializer != NULL)
3264 release_tree_vector (initializer);
3266 return convert_out (ctx->preserve (result));
3269 gcc_expr
3270 plugin_build_call_expr (cc1_plugin::connection *self,
3271 gcc_expr callable_in, int qualified_p,
3272 const struct gcc_cp_function_args *args_in)
3274 plugin_context *ctx = static_cast<plugin_context *> (self);
3275 tree callable = convert_in (callable_in);
3276 tree call_expr;
3278 vec<tree, va_gc> *args = args_to_tree_vec (args_in);
3280 bool koenig_p = false;
3281 if (!qualified_p && !args->is_empty ())
3283 if (identifier_p (callable))
3284 koenig_p = true;
3285 else if (is_overloaded_fn (callable))
3287 tree fn = get_first_fn (callable);
3288 fn = STRIP_TEMPLATE (fn);
3290 if (!DECL_FUNCTION_MEMBER_P (fn)
3291 && !DECL_LOCAL_FUNCTION_P (fn))
3292 koenig_p = true;
3296 if (koenig_p && !any_type_dependent_arguments_p (args))
3297 callable = perform_koenig_lookup (callable, args, tf_none);
3299 if (TREE_CODE (callable) == COMPONENT_REF)
3301 tree object = TREE_OPERAND (callable, 0);
3302 tree memfn = TREE_OPERAND (callable, 1);
3304 if (type_dependent_expression_p (object)
3305 || (!BASELINK_P (memfn) && TREE_CODE (memfn) != FIELD_DECL)
3306 || type_dependent_expression_p (memfn)
3307 || any_type_dependent_arguments_p (args))
3308 call_expr = build_nt_call_vec (callable, args);
3309 else if (BASELINK_P (memfn))
3310 call_expr = build_new_method_call (object, memfn, &args, NULL_TREE,
3311 qualified_p
3312 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
3313 : LOOKUP_NORMAL,
3314 NULL, tf_none);
3315 else
3316 call_expr = finish_call_expr (callable, &args, false, false, tf_none);
3318 else if (TREE_CODE (callable) == OFFSET_REF
3319 || TREE_CODE (callable) == MEMBER_REF
3320 || TREE_CODE (callable) == DOTSTAR_EXPR)
3321 call_expr = build_offset_ref_call_from_tree (callable, &args, tf_none);
3322 else
3323 call_expr = finish_call_expr (callable, &args,
3324 !!qualified_p, koenig_p, tf_none);
3326 release_tree_vector (args);
3327 return convert_out (ctx->preserve (call_expr));
3330 gcc_type
3331 plugin_get_expr_type (cc1_plugin::connection *self,
3332 gcc_expr operand)
3334 plugin_context *ctx = static_cast<plugin_context *> (self);
3335 tree op0 = convert_in (operand);
3336 tree type;
3337 if (op0)
3338 type = TREE_TYPE (op0);
3339 else
3341 type = make_decltype_auto ();
3342 AUTO_IS_DECLTYPE (type) = true;
3344 return convert_out (ctx->preserve (type));
3347 gcc_decl
3348 plugin_build_function_template_specialization (cc1_plugin::connection *self,
3349 gcc_decl template_decl,
3350 const gcc_cp_template_args *targs,
3351 gcc_address address,
3352 const char *filename,
3353 unsigned int line_number)
3355 plugin_context *ctx = static_cast<plugin_context *> (self);
3356 source_location loc = ctx->get_source_location (filename, line_number);
3357 tree name = convert_in (template_decl);
3358 tree targsl = targlist (targs);
3360 tree decl = tsubst (name, targsl, tf_error, NULL_TREE);
3361 DECL_SOURCE_LOCATION (decl) = loc;
3363 record_decl_address (ctx, build_decl_addr_value (decl, address));
3365 return convert_out (ctx->preserve (decl));
3368 gcc_decl
3369 plugin_build_class_template_specialization (cc1_plugin::connection *self,
3370 gcc_decl template_decl,
3371 const gcc_cp_template_args *args,
3372 const char *filename,
3373 unsigned int line_number)
3375 plugin_context *ctx = static_cast<plugin_context *> (self);
3376 source_location loc = ctx->get_source_location (filename, line_number);
3377 tree name = convert_in (template_decl);
3379 tree tdecl = finish_template_type (name, targlist (args), false);;
3380 DECL_SOURCE_LOCATION (tdecl) = loc;
3382 return convert_out (ctx->preserve (tdecl));
3385 /* Return a builtin type associated with BUILTIN_NAME. */
3387 static tree
3388 safe_lookup_builtin_type (const char *builtin_name)
3390 tree result = NULL_TREE;
3392 if (!builtin_name)
3393 return result;
3395 result = identifier_global_value (get_identifier (builtin_name));
3397 if (!result)
3398 return result;
3400 gcc_assert (TREE_CODE (result) == TYPE_DECL);
3401 result = TREE_TYPE (result);
3402 return result;
3405 gcc_type
3406 plugin_get_int_type (cc1_plugin::connection *self,
3407 int is_unsigned, unsigned long size_in_bytes,
3408 const char *builtin_name)
3410 tree result;
3412 if (builtin_name)
3414 result = safe_lookup_builtin_type (builtin_name);
3415 gcc_assert (!result || TREE_CODE (result) == INTEGER_TYPE);
3417 else
3418 result = c_common_type_for_size (BITS_PER_UNIT * size_in_bytes,
3419 is_unsigned);
3421 if (result == NULL_TREE)
3422 result = error_mark_node;
3423 else
3425 gcc_assert (!TYPE_UNSIGNED (result) == !is_unsigned);
3426 gcc_assert (TREE_CODE (TYPE_SIZE (result)) == INTEGER_CST);
3427 gcc_assert (TYPE_PRECISION (result) == BITS_PER_UNIT * size_in_bytes);
3429 plugin_context *ctx = static_cast<plugin_context *> (self);
3430 ctx->preserve (result);
3432 return convert_out (result);
3435 gcc_type
3436 plugin_get_char_type (cc1_plugin::connection *)
3438 return convert_out (char_type_node);
3441 gcc_type
3442 plugin_get_float_type (cc1_plugin::connection *,
3443 unsigned long size_in_bytes,
3444 const char *builtin_name)
3446 if (builtin_name)
3448 tree result = safe_lookup_builtin_type (builtin_name);
3450 if (!result)
3451 return convert_out (error_mark_node);
3453 gcc_assert (TREE_CODE (result) == REAL_TYPE);
3454 gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result));
3456 return convert_out (result);
3459 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (float_type_node))
3460 return convert_out (float_type_node);
3461 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (double_type_node))
3462 return convert_out (double_type_node);
3463 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (long_double_type_node))
3464 return convert_out (long_double_type_node);
3465 return convert_out (error_mark_node);
3468 gcc_type
3469 plugin_get_void_type (cc1_plugin::connection *)
3471 return convert_out (void_type_node);
3474 gcc_type
3475 plugin_get_bool_type (cc1_plugin::connection *)
3477 return convert_out (boolean_type_node);
3480 gcc_type
3481 plugin_get_nullptr_type (cc1_plugin::connection *)
3483 return convert_out (nullptr_type_node);
3486 gcc_expr
3487 plugin_get_nullptr_constant (cc1_plugin::connection *)
3489 return convert_out (nullptr_node);
3492 gcc_type
3493 plugin_build_array_type (cc1_plugin::connection *self,
3494 gcc_type element_type_in, int num_elements)
3496 tree element_type = convert_in (element_type_in);
3497 tree result;
3499 if (num_elements == -1)
3500 result = build_array_type (element_type, NULL_TREE);
3501 else
3502 result = build_array_type_nelts (element_type, num_elements);
3504 plugin_context *ctx = static_cast<plugin_context *> (self);
3505 return convert_out (ctx->preserve (result));
3508 gcc_type
3509 plugin_build_dependent_array_type (cc1_plugin::connection *self,
3510 gcc_type element_type_in,
3511 gcc_expr num_elements_in)
3513 plugin_context *ctx = static_cast<plugin_context *> (self);
3514 tree element_type = convert_in (element_type_in);
3515 tree size = convert_in (num_elements_in);
3516 tree name = get_identifier ("dependent array type");
3518 processing_template_decl++;
3519 bool template_dependent_p = dependent_type_p (element_type)
3520 || type_dependent_expression_p (size)
3521 || value_dependent_expression_p (size);
3522 if (!template_dependent_p)
3523 processing_template_decl--;
3525 tree itype = compute_array_index_type (name, size, tf_error);
3526 tree type = build_cplus_array_type (element_type, itype);
3528 if (template_dependent_p)
3529 processing_template_decl--;
3531 return convert_out (ctx->preserve (type));
3534 gcc_type
3535 plugin_build_vla_array_type (cc1_plugin::connection *self,
3536 gcc_type element_type_in,
3537 const char *upper_bound_name)
3539 tree element_type = convert_in (element_type_in);
3540 tree upper_bound = lookup_name (get_identifier (upper_bound_name));
3541 tree size = fold_build2 (PLUS_EXPR, TREE_TYPE (upper_bound), upper_bound,
3542 build_one_cst (TREE_TYPE (upper_bound)));
3543 tree range = compute_array_index_type (NULL_TREE, size,
3544 tf_error);
3546 tree result = build_cplus_array_type (element_type, range);
3548 plugin_context *ctx = static_cast<plugin_context *> (self);
3549 return convert_out (ctx->preserve (result));
3552 gcc_type
3553 plugin_build_qualified_type (cc1_plugin::connection *,
3554 gcc_type unqualified_type_in,
3555 enum gcc_cp_qualifiers qualifiers)
3557 tree unqualified_type = convert_in (unqualified_type_in);
3558 cp_cv_quals quals = 0;
3560 if ((qualifiers & GCC_CP_QUALIFIER_CONST) != 0)
3561 quals |= TYPE_QUAL_CONST;
3562 if ((qualifiers & GCC_CP_QUALIFIER_VOLATILE) != 0)
3563 quals |= TYPE_QUAL_VOLATILE;
3564 if ((qualifiers & GCC_CP_QUALIFIER_RESTRICT) != 0)
3565 quals |= TYPE_QUAL_RESTRICT;
3567 gcc_assert ((TREE_CODE (unqualified_type) != METHOD_TYPE
3568 && TREE_CODE (unqualified_type) != REFERENCE_TYPE)
3569 || quals == 0);
3571 return convert_out (build_qualified_type (unqualified_type, quals));
3574 gcc_type
3575 plugin_build_complex_type (cc1_plugin::connection *self,
3576 gcc_type base_type)
3578 plugin_context *ctx = static_cast<plugin_context *> (self);
3579 return convert_out (ctx->preserve (build_complex_type (convert_in (base_type))));
3582 gcc_type
3583 plugin_build_vector_type (cc1_plugin::connection *self,
3584 gcc_type base_type, int nunits)
3586 plugin_context *ctx = static_cast<plugin_context *> (self);
3587 return convert_out (ctx->preserve (build_vector_type (convert_in (base_type),
3588 nunits)));
3592 plugin_build_constant (cc1_plugin::connection *self, gcc_type type_in,
3593 const char *name, unsigned long value,
3594 const char *filename, unsigned int line_number)
3596 plugin_context *ctx = static_cast<plugin_context *> (self);
3597 tree cst, decl;
3598 tree type = convert_in (type_in);
3600 cst = build_int_cst (type, value);
3601 if (!TYPE_READONLY (type))
3602 type = build_qualified_type (type, TYPE_QUAL_CONST);
3603 decl = build_decl (ctx->get_source_location (filename, line_number),
3604 VAR_DECL, get_identifier (name), type);
3605 TREE_STATIC (decl) = 1;
3606 TREE_READONLY (decl) = 1;
3607 cp_finish_decl (decl, cst, true, NULL, LOOKUP_ONLYCONVERTING);
3608 safe_pushdecl_maybe_friend (decl, false);
3610 return 1;
3613 gcc_type
3614 plugin_error (cc1_plugin::connection *,
3615 const char *message)
3617 error ("%s", message);
3618 return convert_out (error_mark_node);
3622 plugin_add_static_assert (cc1_plugin::connection *self,
3623 gcc_expr condition_in,
3624 const char *errormsg,
3625 const char *filename,
3626 unsigned int line_number)
3628 plugin_context *ctx = static_cast<plugin_context *> (self);
3629 tree condition = convert_in (condition_in);
3631 if (!errormsg)
3632 errormsg = "";
3634 tree message = build_string (strlen (errormsg) + 1, errormsg);
3636 TREE_TYPE (message) = char_array_type_node;
3637 fix_string_type (message);
3639 source_location loc = ctx->get_source_location (filename, line_number);
3641 bool member_p = at_class_scope_p ();
3643 finish_static_assert (condition, message, loc, member_p);
3645 return 1;
3650 // Perform GC marking.
3652 static void
3653 gc_mark (void *, void *)
3655 if (current_context != NULL)
3656 current_context->mark ();
3659 #ifdef __GNUC__
3660 #pragma GCC visibility push(default)
3661 #endif
3664 plugin_init (struct plugin_name_args *plugin_info,
3665 struct plugin_gcc_version *)
3667 long fd = -1;
3668 for (int i = 0; i < plugin_info->argc; ++i)
3670 if (strcmp (plugin_info->argv[i].key, "fd") == 0)
3672 char *tail;
3673 errno = 0;
3674 fd = strtol (plugin_info->argv[i].value, &tail, 0);
3675 if (*tail != '\0' || errno != 0)
3676 fatal_error (input_location,
3677 "%s: invalid file descriptor argument to plugin",
3678 plugin_info->base_name);
3679 break;
3682 if (fd == -1)
3683 fatal_error (input_location,
3684 "%s: required plugin argument %<fd%> is missing",
3685 plugin_info->base_name);
3687 current_context = new plugin_context (fd);
3689 // Handshake.
3690 cc1_plugin::protocol_int version;
3691 if (!current_context->require ('H')
3692 || ! ::cc1_plugin::unmarshall (current_context, &version))
3693 fatal_error (input_location,
3694 "%s: handshake failed", plugin_info->base_name);
3695 if (version != GCC_CP_FE_VERSION_0)
3696 fatal_error (input_location,
3697 "%s: unknown version in handshake", plugin_info->base_name);
3699 register_callback (plugin_info->base_name, PLUGIN_PRAGMAS,
3700 plugin_init_extra_pragmas, NULL);
3701 register_callback (plugin_info->base_name, PLUGIN_PRE_GENERICIZE,
3702 rewrite_decls_to_addresses, NULL);
3703 register_callback (plugin_info->base_name, PLUGIN_GGC_MARKING,
3704 gc_mark, NULL);
3706 lang_hooks.print_error_function = plugin_print_error_function;
3708 #define GCC_METHOD0(R, N) \
3710 cc1_plugin::callback_ftype *fun \
3711 = cc1_plugin::callback<R, plugin_ ## N>; \
3712 current_context->add_callback (# N, fun); \
3714 #define GCC_METHOD1(R, N, A) \
3716 cc1_plugin::callback_ftype *fun \
3717 = cc1_plugin::callback<R, A, plugin_ ## N>; \
3718 current_context->add_callback (# N, fun); \
3720 #define GCC_METHOD2(R, N, A, B) \
3722 cc1_plugin::callback_ftype *fun \
3723 = cc1_plugin::callback<R, A, B, plugin_ ## N>; \
3724 current_context->add_callback (# N, fun); \
3726 #define GCC_METHOD3(R, N, A, B, C) \
3728 cc1_plugin::callback_ftype *fun \
3729 = cc1_plugin::callback<R, A, B, C, plugin_ ## N>; \
3730 current_context->add_callback (# N, fun); \
3732 #define GCC_METHOD4(R, N, A, B, C, D) \
3734 cc1_plugin::callback_ftype *fun \
3735 = cc1_plugin::callback<R, A, B, C, D, \
3736 plugin_ ## N>; \
3737 current_context->add_callback (# N, fun); \
3739 #define GCC_METHOD5(R, N, A, B, C, D, E) \
3741 cc1_plugin::callback_ftype *fun \
3742 = cc1_plugin::callback<R, A, B, C, D, E, \
3743 plugin_ ## N>; \
3744 current_context->add_callback (# N, fun); \
3746 #define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
3748 cc1_plugin::callback_ftype *fun \
3749 = cc1_plugin::callback<R, A, B, C, D, E, F, G, \
3750 plugin_ ## N>; \
3751 current_context->add_callback (# N, fun); \
3754 #include "gcc-cp-fe.def"
3756 #undef GCC_METHOD0
3757 #undef GCC_METHOD1
3758 #undef GCC_METHOD2
3759 #undef GCC_METHOD3
3760 #undef GCC_METHOD4
3761 #undef GCC_METHOD5
3762 #undef GCC_METHOD7
3764 return 0;