libcc1/libcc1plugin.cc

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