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