1/* Library interface to C front end
2 Copyright (C) 2014-2017 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20#include <cc1plugin-config.h>
21
22#undef PACKAGE_NAME
23#undef PACKAGE_STRING
24#undef PACKAGE_TARNAME
25#undef PACKAGE_VERSION
26
27#include "../gcc/config.h"
28
29#undef PACKAGE_NAME
30#undef PACKAGE_STRING
31#undef PACKAGE_TARNAME
32#undef PACKAGE_VERSION
33
34#include "gcc-plugin.h"
35#include "system.h"
36#include "coretypes.h"
37#include "stringpool.h"
38
39#include "gcc-interface.h"
40#include "hash-set.h"
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 "c-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
64#include "callbacks.hh"
65#include "connection.hh"
66#include "marshall-c.hh"
67#include "rpc.hh"
68
69#ifdef __GNUC__
70#pragma GCC visibility push(default)
71#endif
72int plugin_is_GPL_compatible;
73#ifdef __GNUC__
74#pragma GCC visibility pop
75#endif
76
77
78
79// This is put into the lang hooks when the plugin starts.
80
81static void
82plugin_print_error_function (diagnostic_context *context, const char *file,
83 diagnostic_info *diagnostic)
84{
85 if (current_function_decl != NULL_TREE
86 && DECL_NAME (current_function_decl) != NULL_TREE
87 && strcmp (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
88 GCC_FE_WRAPPER_FUNCTION) == 0)
89 return;
90 lhd_print_error_function (context, file, diagnostic);
91}
92
93
94
95static unsigned long long
96convert_out (tree t)
97{
98 return (unsigned long long) (uintptr_t) t;
99}
100
101static tree
102convert_in (unsigned long long v)
103{
104 return (tree) (uintptr_t) v;
105}
106
107
108
109struct decl_addr_value
110{
111 tree decl;
112 tree address;
113};
114
115struct decl_addr_hasher : free_ptr_hash<decl_addr_value>
116{
117 static inline hashval_t hash (const decl_addr_value *);
118 static inline bool equal (const decl_addr_value *, const decl_addr_value *);
119};
120
121inline hashval_t
122decl_addr_hasher::hash (const decl_addr_value *e)
123{
124 return IDENTIFIER_HASH_VALUE (DECL_NAME (e->decl));
125}
126
127inline bool
128decl_addr_hasher::equal (const decl_addr_value *p1, const decl_addr_value *p2)
129{
130 return p1->decl == p2->decl;
131}
132
133
134
135struct string_hasher : nofree_ptr_hash<const char>
136{
137 static inline hashval_t hash (const char *s)
138 {
139 return htab_hash_string (s);
140 }
141
142 static inline bool equal (const char *p1, const char *p2)
143 {
144 return strcmp (p1, p2) == 0;
145 }
146};
147
148
149
150// A wrapper for pushdecl that doesn't let gdb have a chance to
151// instantiate a symbol.
152
153static void
154pushdecl_safe (tree decl)
155{
156 void (*save) (enum c_oracle_request, tree identifier);
157
158 save = c_binding_oracle;
159 c_binding_oracle = NULL;
160 pushdecl (decl);
161 c_binding_oracle = save;
162}
163
164
165
166struct plugin_context : public cc1_plugin::connection
167{
168 plugin_context (int fd);
169
170 // Map decls to addresses.
171 hash_table<decl_addr_hasher> address_map;
172
173 // A collection of trees that are preserved for the GC.
174 hash_table< nofree_ptr_hash<tree_node> > preserved;
175
176 // File name cache.
177 hash_table<string_hasher> file_names;
178
179 // Perform GC marking.
180 void mark ();
181
182 // Preserve a tree during the plugin's operation.
183 tree preserve (tree t)
184 {
185 tree_node **slot = preserved.find_slot (t, INSERT);
186 *slot = t;
187 return t;
188 }
189
190 source_location get_source_location (const char *filename,
191 unsigned int line_number)
192 {
193 if (filename == NULL)
194 return UNKNOWN_LOCATION;
195
196 filename = intern_filename (filename);
197 linemap_add (line_table, LC_ENTER, false, filename, line_number);
198 source_location loc = linemap_line_start (line_table, line_number, 0);
199 linemap_add (line_table, LC_LEAVE, false, NULL, 0);
200 return loc;
201 }
202
203private:
204
205 // Add a file name to FILE_NAMES and return the canonical copy.
206 const char *intern_filename (const char *filename)
207 {
208 const char **slot = file_names.find_slot (filename, INSERT);
209 if (*slot == NULL)
210 {
211 /* The file name must live as long as the line map, which
212 effectively means as long as this compilation. So, we copy
213 the string here but never free it. */
214 *slot = xstrdup (filename);
215 }
216 return *slot;
217 }
218};
219
220static plugin_context *current_context;
221
222
223
224plugin_context::plugin_context (int fd)
225 : cc1_plugin::connection (fd),
226 address_map (30),
227 preserved (30),
228 file_names (30)
229{
230}
231
232void
233plugin_context::mark ()
234{
235 for (hash_table<decl_addr_hasher>::iterator it = address_map.begin ();
236 it != address_map.end ();
237 ++it)
238 {
239 ggc_mark ((*it)->decl);
240 ggc_mark ((*it)->address);
241 }
242
243 for (hash_table< nofree_ptr_hash<tree_node> >::iterator
244 it = preserved.begin (); it != preserved.end (); ++it)
245 ggc_mark (&*it);
246}
247
248static void
249plugin_binding_oracle (enum c_oracle_request kind, tree identifier)
250{
251 enum gcc_c_oracle_request request;
252
253 gcc_assert (current_context != NULL);
254
255 switch (kind)
256 {
257 case C_ORACLE_SYMBOL:
258 request = GCC_C_ORACLE_SYMBOL;
259 break;
260 case C_ORACLE_TAG:
261 request = GCC_C_ORACLE_TAG;
262 break;
263 case C_ORACLE_LABEL:
264 request = GCC_C_ORACLE_LABEL;
265 break;
266 default:
267 abort ();
268 }
269
270 int ignore;
271 cc1_plugin::call (current_context, "binding_oracle", &ignore,
272 request, IDENTIFIER_POINTER (identifier));
273}
274
275static void
276plugin_pragma_user_expression (cpp_reader *)
277{
278 c_binding_oracle = plugin_binding_oracle;
279}
280
281static void
282plugin_init_extra_pragmas (void *, void *)
283{
284 c_register_pragma ("GCC", "user_expression", plugin_pragma_user_expression);
285}
286
287
288
289// Maybe rewrite a decl to its address.
290static tree
291address_rewriter (tree *in, int *walk_subtrees, void *arg)
292{
293 plugin_context *ctx = (plugin_context *) arg;
294
295 if (!DECL_P (*in) || DECL_NAME (*in) == NULL_TREE)
296 return NULL_TREE;
297
298 decl_addr_value value;
299 value.decl = *in;
300 decl_addr_value *found_value = ctx->address_map.find (&value);
301 if (found_value != NULL)
302 ;
303 else if (DECL_IS_BUILTIN (*in))
304 {
305 gcc_address address;
306
307 if (!cc1_plugin::call (ctx, "address_oracle", &address,
308 IDENTIFIER_POINTER (DECL_NAME (*in))))
309 return NULL_TREE;
310 if (address == 0)
311 return NULL_TREE;
312
313 // Insert the decl into the address map in case it is referenced
314 // again.
315 value.address = build_int_cst_type (ptr_type_node, address);
316 decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT);
317 gcc_assert (*slot == NULL);
318 *slot
319 = static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value)));
320 **slot = value;
321 found_value = *slot;
322 }
323 else
324 return NULL_TREE;
325
326 if (found_value->address != error_mark_node)
327 {
328 // We have an address for the decl, so rewrite the tree.
329 tree ptr_type = build_pointer_type (TREE_TYPE (*in));
330 *in = fold_build1 (INDIRECT_REF, TREE_TYPE (*in),
331 fold_build1 (CONVERT_EXPR, ptr_type,
332 found_value->address));
333 }
334
335 *walk_subtrees = 0;
336
337 return NULL_TREE;
338}
339
340// When generating code for gdb, we want to be able to use absolute
341// addresses to refer to otherwise external objects that gdb knows
342// about. gdb passes in these addresses when building decls, and then
343// before gimplification we go through the trees, rewriting uses to
344// the equivalent of "*(TYPE *) ADDR".
345static void
346rewrite_decls_to_addresses (void *function_in, void *)
347{
348 tree function = (tree) function_in;
349
350 // Do nothing if we're not in gdb.
351 if (current_context == NULL)
352 return;
353
354 walk_tree (&DECL_SAVED_TREE (function), address_rewriter, current_context,
355 NULL);
356}
357
358
359
360gcc_decl
361plugin_build_decl (cc1_plugin::connection *self,
362 const char *name,
363 enum gcc_c_symbol_kind sym_kind,
364 gcc_type sym_type_in,
365 const char *substitution_name,
366 gcc_address address,
367 const char *filename,
368 unsigned int line_number)
369{
370 plugin_context *ctx = static_cast<plugin_context *> (self);
371 tree identifier = get_identifier (name);
372 enum tree_code code;
373 tree decl;
374 tree sym_type = convert_in (sym_type_in);
375
376 switch (sym_kind)
377 {
378 case GCC_C_SYMBOL_FUNCTION:
379 code = FUNCTION_DECL;
380 break;
381
382 case GCC_C_SYMBOL_VARIABLE:
383 code = VAR_DECL;
384 break;
385
386 case GCC_C_SYMBOL_TYPEDEF:
387 code = TYPE_DECL;
388 break;
389
390 case GCC_C_SYMBOL_LABEL:
391 // FIXME: we aren't ready to handle labels yet.
392 // It isn't clear how to translate them properly
393 // and in any case a "goto" isn't likely to work.
394 return convert_out (error_mark_node);
395
396 default:
397 abort ();
398 }
399
400 source_location loc = ctx->get_source_location (filename, line_number);
401
402 decl = build_decl (loc, code, identifier, sym_type);
403 TREE_USED (decl) = 1;
404 TREE_ADDRESSABLE (decl) = 1;
405
406 if (sym_kind != GCC_C_SYMBOL_TYPEDEF)
407 {
408 decl_addr_value value;
409
410 DECL_EXTERNAL (decl) = 1;
411 value.decl = decl;
412 if (substitution_name != NULL)
413 {
414 // If the translator gave us a name without a binding,
415 // we can just substitute error_mark_node, since we know the
416 // translator will be reporting an error anyhow.
417 value.address
418 = lookup_name (get_identifier (substitution_name));
419 if (value.address == NULL_TREE)
420 value.address = error_mark_node;
421 }
422 else
423 value.address = build_int_cst_type (ptr_type_node, address);
424 decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT);
425 gcc_assert (*slot == NULL);
426 *slot
427 = static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value)));
428 **slot = value;
429 }
430
431 return convert_out (ctx->preserve (decl));
432}
433
434int
435plugin_bind (cc1_plugin::connection *,
436 gcc_decl decl_in, int is_global)
437{
438 tree decl = convert_in (decl_in);
439 c_bind (DECL_SOURCE_LOCATION (decl), decl, is_global);
440 rest_of_decl_compilation (decl, is_global, 0);
441 return 1;
442}
443
444int
445plugin_tagbind (cc1_plugin::connection *self,
446 const char *name, gcc_type tagged_type,
447 const char *filename, unsigned int line_number)
448{
449 plugin_context *ctx = static_cast<plugin_context *> (self);
450 tree t = convert_in (tagged_type), x;
451 c_pushtag (ctx->get_source_location (filename, line_number),
452 get_identifier (name), t);
453
454 /* Propagate the newly-added type name so that previously-created
455 variant types are not disconnected from their main variants. */
456 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
457 TYPE_NAME (x) = TYPE_NAME (t);
458
459 return 1;
460}
461
462gcc_type
463plugin_build_pointer_type (cc1_plugin::connection *,
464 gcc_type base_type)
465{
466 // No need to preserve a pointer type as the base type is preserved.
467 return convert_out (build_pointer_type (convert_in (base_type)));
468}
469
470// TYPE_NAME needs to be a valid pointer, even if there is no name available.
471
472static tree
473build_anonymous_node (enum tree_code code)
474{
475 tree node = make_node (code);
476 tree type_decl = build_decl (input_location, TYPE_DECL, NULL_TREE, node);
477 TYPE_NAME (node) = type_decl;
478 TYPE_STUB_DECL (node) = type_decl;
479 return node;
480}
481
482gcc_type
483plugin_build_record_type (cc1_plugin::connection *self)
484{
485 plugin_context *ctx = static_cast<plugin_context *> (self);
486 return convert_out (ctx->preserve (build_anonymous_node (RECORD_TYPE)));
487}
488
489gcc_type
490plugin_build_union_type (cc1_plugin::connection *self)
491{
492 plugin_context *ctx = static_cast<plugin_context *> (self);
493 return convert_out (ctx->preserve (build_anonymous_node (UNION_TYPE)));
494}
495
496int
497plugin_build_add_field (cc1_plugin::connection *,
498 gcc_type record_or_union_type_in,
499 const char *field_name,
500 gcc_type field_type_in,
501 unsigned long bitsize,
502 unsigned long bitpos)
503{
504 tree record_or_union_type = convert_in (record_or_union_type_in);
505 tree field_type = convert_in (field_type_in);
506
507 gcc_assert (TREE_CODE (record_or_union_type) == RECORD_TYPE
508 || TREE_CODE (record_or_union_type) == UNION_TYPE);
509
510 /* Note that gdb does not preserve the location of field decls, so
511 we can't provide a decent location here. */
512 tree decl = build_decl (BUILTINS_LOCATION, FIELD_DECL,
513 get_identifier (field_name), field_type);
514 DECL_FIELD_CONTEXT (decl) = record_or_union_type;
515
516 if (TREE_CODE (field_type) == INTEGER_TYPE
517 && TYPE_PRECISION (field_type) != bitsize)
518 {
519 DECL_BIT_FIELD_TYPE (decl) = field_type;
520 TREE_TYPE (decl)
521 = c_build_bitfield_integer_type (bitsize, TYPE_UNSIGNED (field_type));
522 }
523
524 SET_DECL_MODE (decl, TYPE_MODE (TREE_TYPE (decl)));
525
526 // There's no way to recover this from DWARF.
527 SET_DECL_OFFSET_ALIGN (decl, TYPE_PRECISION (pointer_sized_int_node));
528
529 tree pos = bitsize_int (bitpos);
530 pos_from_bit (&DECL_FIELD_OFFSET (decl), &DECL_FIELD_BIT_OFFSET (decl),
531 DECL_OFFSET_ALIGN (decl), pos);
532
533 DECL_SIZE (decl) = bitsize_int (bitsize);
534 DECL_SIZE_UNIT (decl) = size_int ((bitsize + BITS_PER_UNIT - 1)
535 / BITS_PER_UNIT);
536
537 DECL_CHAIN (decl) = TYPE_FIELDS (record_or_union_type);
538 TYPE_FIELDS (record_or_union_type) = decl;
539
540 return 1;
541}
542
543int
544plugin_finish_record_or_union (cc1_plugin::connection *,
545 gcc_type record_or_union_type_in,
546 unsigned long size_in_bytes)
547{
548 tree record_or_union_type = convert_in (record_or_union_type_in);
549
550 gcc_assert (TREE_CODE (record_or_union_type) == RECORD_TYPE
551 || TREE_CODE (record_or_union_type) == UNION_TYPE);
552
553 /* We built the field list in reverse order, so fix it now. */
554 TYPE_FIELDS (record_or_union_type)
555 = nreverse (TYPE_FIELDS (record_or_union_type));
556
557 if (TREE_CODE (record_or_union_type) == UNION_TYPE)
558 {
559 /* Unions can just be handled by the generic code. */
560 layout_type (record_or_union_type);
561 }
562 else
563 {
564 // FIXME there's no way to get this from DWARF,
565 // or even, it seems, a particularly good way to deduce it.
566 SET_TYPE_ALIGN (record_or_union_type,
567 TYPE_PRECISION (pointer_sized_int_node));
568
569 TYPE_SIZE (record_or_union_type) = bitsize_int (size_in_bytes
570 * BITS_PER_UNIT);
571 TYPE_SIZE_UNIT (record_or_union_type) = size_int (size_in_bytes);
572
573 compute_record_mode (record_or_union_type);
574 finish_bitfield_layout (record_or_union_type);
575 // FIXME we have no idea about TYPE_PACKED
576 }
577
578 tree t = record_or_union_type, x;
579 for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
580 {
581 /* Like finish_struct, update the qualified variant types. */
582 TYPE_FIELDS (x) = TYPE_FIELDS (t);
583 TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
584 C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
585 C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
586 C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
587 /* We copy these fields too. */
588 SET_TYPE_ALIGN (x, TYPE_ALIGN (t));
589 TYPE_SIZE (x) = TYPE_SIZE (t);
590 TYPE_SIZE_UNIT (x) = TYPE_SIZE_UNIT (t);
591 if (x != record_or_union_type)
592 compute_record_mode (x);
593 }
594
595 return 1;
596}
597
598gcc_type
599plugin_build_enum_type (cc1_plugin::connection *self,
600 gcc_type underlying_int_type_in)
601{
602 tree underlying_int_type = convert_in (underlying_int_type_in);
603
604 if (underlying_int_type == error_mark_node)
605 return convert_out (error_mark_node);
606
607 tree result = build_anonymous_node (ENUMERAL_TYPE);
608
609 TYPE_PRECISION (result) = TYPE_PRECISION (underlying_int_type);
610 TYPE_UNSIGNED (result) = TYPE_UNSIGNED (underlying_int_type);
611
612 plugin_context *ctx = static_cast<plugin_context *> (self);
613 return convert_out (ctx->preserve (result));
614}
615
616int
617plugin_build_add_enum_constant (cc1_plugin::connection *,
618 gcc_type enum_type_in,
619 const char *name,
620 unsigned long value)
621{
622 tree cst, decl, cons;
623 tree enum_type = convert_in (enum_type_in);
624
625 gcc_assert (TREE_CODE (enum_type) == ENUMERAL_TYPE);
626
627 cst = build_int_cst (enum_type, value);
628 /* Note that gdb does not preserve the location of enum constants,
629 so we can't provide a decent location here. */
630 decl = build_decl (BUILTINS_LOCATION, CONST_DECL,
631 get_identifier (name), enum_type);
632 DECL_INITIAL (decl) = cst;
633 pushdecl_safe (decl);
634
635 cons = tree_cons (DECL_NAME (decl), cst, TYPE_VALUES (enum_type));
636 TYPE_VALUES (enum_type) = cons;
637
638 return 1;
639}
640
641int
642plugin_finish_enum_type (cc1_plugin::connection *,
643 gcc_type enum_type_in)
644{
645 tree enum_type = convert_in (enum_type_in);
646 tree minnode, maxnode, iter;
647
648 iter = TYPE_VALUES (enum_type);
649 minnode = maxnode = TREE_VALUE (iter);
650 for (iter = TREE_CHAIN (iter);
651 iter != NULL_TREE;
652 iter = TREE_CHAIN (iter))
653 {
654 tree value = TREE_VALUE (iter);
655 if (tree_int_cst_lt (maxnode, value))
656 maxnode = value;
657 if (tree_int_cst_lt (value, minnode))
658 minnode = value;
659 }
660 TYPE_MIN_VALUE (enum_type) = minnode;
661 TYPE_MAX_VALUE (enum_type) = maxnode;
662
663 layout_type (enum_type);
664
665 return 1;
666}
667
668gcc_type
669plugin_build_function_type (cc1_plugin::connection *self,
670 gcc_type return_type_in,
671 const struct gcc_type_array *argument_types_in,
672 int is_varargs)
673{
674 tree *argument_types;
675 tree return_type = convert_in (return_type_in);
676 tree result;
677
678 argument_types = new tree[argument_types_in->n_elements];
679 for (int i = 0; i < argument_types_in->n_elements; ++i)
680 argument_types[i] = convert_in (argument_types_in->elements[i]);
681
682 if (is_varargs)
683 result = build_varargs_function_type_array (return_type,
684 argument_types_in->n_elements,
685 argument_types);
686 else
687 result = build_function_type_array (return_type,
688 argument_types_in->n_elements,
689 argument_types);
690
691 delete[] argument_types;
692
693 plugin_context *ctx = static_cast<plugin_context *> (self);
694 return convert_out (ctx->preserve (result));
695}
696
697/* Return a builtin type associated with BUILTIN_NAME. */
698
699static tree
700safe_lookup_builtin_type (const char *builtin_name)
701{
702 tree result = NULL_TREE;
703
704 if (!builtin_name)
705 return result;
706
707 result = identifier_global_value (get_identifier (builtin_name));
708
709 if (!result)
710 return result;
711
712 gcc_assert (TREE_CODE (result) == TYPE_DECL);
713 result = TREE_TYPE (result);
714 return result;
715}
716
717static gcc_type
718plugin_int_check (cc1_plugin::connection *self,
719 int is_unsigned, unsigned long size_in_bytes,
720 tree result)
721{
722 if (result == NULL_TREE)
723 result = error_mark_node;
724 else
725 {
726 gcc_assert (!TYPE_UNSIGNED (result) == !is_unsigned);
727 gcc_assert (TREE_CODE (TYPE_SIZE (result)) == INTEGER_CST);
728 gcc_assert (TYPE_PRECISION (result) == BITS_PER_UNIT * size_in_bytes);
729
730 plugin_context *ctx = static_cast<plugin_context *> (self);
731 ctx->preserve (result);
732 }
733 return convert_out (result);
734}
735
736gcc_type
737plugin_int_type_v0 (cc1_plugin::connection *self,
738 int is_unsigned, unsigned long size_in_bytes)
739{
740 tree result = c_common_type_for_size (BITS_PER_UNIT * size_in_bytes,
741 is_unsigned);
742
743 return plugin_int_check (self, is_unsigned, size_in_bytes, result);
744}
745
746gcc_type
747plugin_int_type (cc1_plugin::connection *self,
748 int is_unsigned, unsigned long size_in_bytes,
749 const char *builtin_name)
750{
751 if (!builtin_name)
752 return plugin_int_type_v0 (self, is_unsigned, size_in_bytes);
753
754 tree result = safe_lookup_builtin_type (builtin_name);
755 gcc_assert (!result || TREE_CODE (result) == INTEGER_TYPE);
756
757 return plugin_int_check (self, is_unsigned, size_in_bytes, result);
758}
759
760gcc_type
761plugin_char_type (cc1_plugin::connection *)
762{
763 return convert_out (char_type_node);
764}
765
766gcc_type
767plugin_float_type_v0 (cc1_plugin::connection *,
768 unsigned long size_in_bytes)
769{
770 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (float_type_node))
771 return convert_out (float_type_node);
772 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (double_type_node))
773 return convert_out (double_type_node);
774 if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (long_double_type_node))
775 return convert_out (long_double_type_node);
776 return convert_out (error_mark_node);
777}
778
779gcc_type
780plugin_float_type (cc1_plugin::connection *self,
781 unsigned long size_in_bytes,
782 const char *builtin_name)
783{
784 if (!builtin_name)
785 return plugin_float_type_v0 (self, size_in_bytes);
786
787 tree result = safe_lookup_builtin_type (builtin_name);
788
789 if (!result)
790 return convert_out (error_mark_node);
791
792 gcc_assert (TREE_CODE (result) == REAL_TYPE);
793 gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result));
794
795 return convert_out (result);
796}
797
798gcc_type
799plugin_void_type (cc1_plugin::connection *)
800{
801 return convert_out (void_type_node);
802}
803
804gcc_type
805plugin_bool_type (cc1_plugin::connection *)
806{
807 return convert_out (boolean_type_node);
808}
809
810gcc_type
811plugin_build_array_type (cc1_plugin::connection *self,
812 gcc_type element_type_in, int num_elements)
813{
814 tree element_type = convert_in (element_type_in);
815 tree result;
816
817 if (num_elements == -1)
818 result = build_array_type (element_type, NULL_TREE);
819 else
820 result = build_array_type_nelts (element_type, num_elements);
821
822 plugin_context *ctx = static_cast<plugin_context *> (self);
823 return convert_out (ctx->preserve (result));
824}
825
826gcc_type
827plugin_build_vla_array_type (cc1_plugin::connection *self,
828 gcc_type element_type_in,
829 const char *upper_bound_name)
830{
831 tree element_type = convert_in (element_type_in);
832 tree upper_bound = lookup_name (get_identifier (upper_bound_name));
833 tree range = build_index_type (upper_bound);
834
835 tree result = build_array_type (element_type, range);
836 C_TYPE_VARIABLE_SIZE (result) = 1;
837
838 plugin_context *ctx = static_cast<plugin_context *> (self);
839 return convert_out (ctx->preserve (result));
840}
841
842gcc_type
843plugin_build_qualified_type (cc1_plugin::connection *,
844 gcc_type unqualified_type_in,
845 enum gcc_qualifiers qualifiers)
846{
847 tree unqualified_type = convert_in (unqualified_type_in);
848 int quals = 0;
849
850 if ((qualifiers & GCC_QUALIFIER_CONST) != 0)
851 quals |= TYPE_QUAL_CONST;
852 if ((qualifiers & GCC_QUALIFIER_VOLATILE) != 0)
853 quals |= TYPE_QUAL_VOLATILE;
854 if ((qualifiers & GCC_QUALIFIER_RESTRICT) != 0)
855 quals |= TYPE_QUAL_RESTRICT;
856
857 return convert_out (build_qualified_type (unqualified_type, quals));
858}
859
860gcc_type
861plugin_build_complex_type (cc1_plugin::connection *self,
862 gcc_type base_type)
863{
864 plugin_context *ctx = static_cast<plugin_context *> (self);
865 return convert_out (ctx->preserve (build_complex_type (convert_in (base_type))));
866}
867
868gcc_type
869plugin_build_vector_type (cc1_plugin::connection *self,
870 gcc_type base_type, int nunits)
871{
872 plugin_context *ctx = static_cast<plugin_context *> (self);
873 return convert_out (ctx->preserve (build_vector_type (convert_in (base_type),
874 nunits)));
875}
876
877int
878plugin_build_constant (cc1_plugin::connection *self, gcc_type type_in,
879 const char *name, unsigned long value,
880 const char *filename, unsigned int line_number)
881{
882 plugin_context *ctx = static_cast<plugin_context *> (self);
883 tree cst, decl;
884 tree type = convert_in (type_in);
885
886 cst = build_int_cst (type, value);
887 decl = build_decl (ctx->get_source_location (filename, line_number),
888 CONST_DECL, get_identifier (name), type);
889 DECL_INITIAL (decl) = cst;
890 pushdecl_safe (decl);
891
892 return 1;
893}
894
895gcc_type
896plugin_error (cc1_plugin::connection *,
897 const char *message)
898{
899 error ("%s", message);
900 return convert_out (error_mark_node);
901}
902
903
904
905// Perform GC marking.
906
907static void
908gc_mark (void *, void *)
909{
910 if (current_context != NULL)
911 current_context->mark ();
912}
913
914#ifdef __GNUC__
915#pragma GCC visibility push(default)
916#endif
917
918int
919plugin_init (struct plugin_name_args *plugin_info,
920 struct plugin_gcc_version *)
921{
922 long fd = -1;
923 for (int i = 0; i < plugin_info->argc; ++i)
924 {
925 if (strcmp (plugin_info->argv[i].key, "fd") == 0)
926 {
927 char *tail;
928 errno = 0;
929 fd = strtol (plugin_info->argv[i].value, &tail, 0);
930 if (*tail != '\0' || errno != 0)
931 fatal_error (input_location,
932 "%s: invalid file descriptor argument to plugin",
933 plugin_info->base_name);
934 break;
935 }
936 }
937 if (fd == -1)
938 fatal_error (input_location,
939 "%s: required plugin argument %<fd%> is missing",
940 plugin_info->base_name);
941
942 current_context = new plugin_context (fd);
943
944 // Handshake.
945 cc1_plugin::protocol_int version;
946 if (!current_context->require ('H')
947 || ! ::cc1_plugin::unmarshall (current_context, &version))
948 fatal_error (input_location,
949 "%s: handshake failed", plugin_info->base_name);
950 if (version != GCC_C_FE_VERSION_1)
951 fatal_error (input_location,
952 "%s: unknown version in handshake", plugin_info->base_name);
953
954 register_callback (plugin_info->base_name, PLUGIN_PRAGMAS,
955 plugin_init_extra_pragmas, NULL);
956 register_callback (plugin_info->base_name, PLUGIN_PRE_GENERICIZE,
957 rewrite_decls_to_addresses, NULL);
958 register_callback (plugin_info->base_name, PLUGIN_GGC_MARKING,
959 gc_mark, NULL);
960
961 lang_hooks.print_error_function = plugin_print_error_function;
962
963#define GCC_METHOD0(R, N) \
964 { \
965 cc1_plugin::callback_ftype *fun \
966 = cc1_plugin::callback<R, plugin_ ## N>; \
967 current_context->add_callback (# N, fun); \
968 }
969#define GCC_METHOD1(R, N, A) \
970 { \
971 cc1_plugin::callback_ftype *fun \
972 = cc1_plugin::callback<R, A, plugin_ ## N>; \
973 current_context->add_callback (# N, fun); \
974 }
975#define GCC_METHOD2(R, N, A, B) \
976 { \
977 cc1_plugin::callback_ftype *fun \
978 = cc1_plugin::callback<R, A, B, plugin_ ## N>; \
979 current_context->add_callback (# N, fun); \
980 }
981#define GCC_METHOD3(R, N, A, B, C) \
982 { \
983 cc1_plugin::callback_ftype *fun \
984 = cc1_plugin::callback<R, A, B, C, plugin_ ## N>; \
985 current_context->add_callback (# N, fun); \
986 }
987#define GCC_METHOD4(R, N, A, B, C, D) \
988 { \
989 cc1_plugin::callback_ftype *fun \
990 = cc1_plugin::callback<R, A, B, C, D, \
991 plugin_ ## N>; \
992 current_context->add_callback (# N, fun); \
993 }
994#define GCC_METHOD5(R, N, A, B, C, D, E) \
995 { \
996 cc1_plugin::callback_ftype *fun \
997 = cc1_plugin::callback<R, A, B, C, D, E, \
998 plugin_ ## N>; \
999 current_context->add_callback (# N, fun); \
1000 }
1001#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
1002 { \
1003 cc1_plugin::callback_ftype *fun \
1004 = cc1_plugin::callback<R, A, B, C, D, E, F, G, \
1005 plugin_ ## N>; \
1006 current_context->add_callback (# N, fun); \
1007 }
1008
1009#include "gcc-c-fe.def"
1010
1011#undef GCC_METHOD0
1012#undef GCC_METHOD1
1013#undef GCC_METHOD2
1014#undef GCC_METHOD3
1015#undef GCC_METHOD4
1016#undef GCC_METHOD5
1017#undef GCC_METHOD7
1018
1019 return 0;
1020}
1021