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