libcc1/plugin.cc

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