gdb/compile/compile-c-symbols.c

   1 /* Convert symbols from GDB to GCC
   2
   3    Copyright (C) 2014-2018 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20
  21 #include "defs.h"
  22 #include "compile-internal.h"
  23 #include "compile-c.h"
  24 #include "symtab.h"
  25 #include "parser-defs.h"
  26 #include "block.h"
  27 #include "objfiles.h"
  28 #include "compile.h"
  29 #include "value.h"
  30 #include "exceptions.h"
  31 #include "gdbtypes.h"
  32 #include "dwarf2loc.h"
  33
  34 \f
  35
  36 /* Compute the name of the pointer representing a local symbol's
  37    address.  */
  38
  39 gdb::unique_xmalloc_ptr<char>
  40 c_symbol_substitution_name (struct symbol *sym)
  41 {
  42   return gdb::unique_xmalloc_ptr<char>
  43     (concat ("__", SYMBOL_NATURAL_NAME (sym), "_ptr", (char *) NULL));
  44 }
  45
  46 /* Convert a given symbol, SYM, to the compiler's representation.
  47    CONTEXT is the compiler instance.  IS_GLOBAL is true if the
  48    symbol came from the global scope.  IS_LOCAL is true if the symbol
  49    came from a local scope.  (Note that the two are not strictly
  50    inverses because the symbol might have come from the static
  51    scope.)  */
  52
  53 static void
  54 convert_one_symbol (compile_c_instance *context,
  55                     struct block_symbol sym,
  56                     int is_global,
  57                     int is_local)
  58 {
  59   gcc_type sym_type;
  60   const char *filename = symbol_symtab (sym.symbol)->filename;
  61   unsigned short line = SYMBOL_LINE (sym.symbol);
  62
  63   context->error_symbol_once (sym.symbol);
  64
  65   if (SYMBOL_CLASS (sym.symbol) == LOC_LABEL)
  66     sym_type = 0;
  67   else
  68     sym_type = context->convert_type (SYMBOL_TYPE (sym.symbol));
  69
  70   if (SYMBOL_DOMAIN (sym.symbol) == STRUCT_DOMAIN)
  71     {
  72       /* Binding a tag, so we don't need to build a decl.  */
  73       context->plugin ().tagbind (SYMBOL_NATURAL_NAME (sym.symbol),
  74                                   sym_type, filename, line);
  75     }
  76   else
  77     {
  78       gcc_decl decl;
  79       enum gcc_c_symbol_kind kind;
  80       CORE_ADDR addr = 0;
  81       gdb::unique_xmalloc_ptr<char> symbol_name;
  82
  83       switch (SYMBOL_CLASS (sym.symbol))
  84         {
  85         case LOC_TYPEDEF:
  86           kind = GCC_C_SYMBOL_TYPEDEF;
  87           break;
  88
  89         case LOC_LABEL:
  90           kind = GCC_C_SYMBOL_LABEL;
  91           addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
  92           break;
  93
  94         case LOC_BLOCK:
  95           kind = GCC_C_SYMBOL_FUNCTION;
  96           addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym.symbol));
  97           if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym.symbol)))
  98             addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
  99           break;
 100
 101         case LOC_CONST:
 102           if (TYPE_CODE (SYMBOL_TYPE (sym.symbol)) == TYPE_CODE_ENUM)
 103             {
 104               /* Already handled by convert_enum.  */
 105               return;
 106             }
 107           context->plugin ().build_constant
 108             (sym_type, SYMBOL_NATURAL_NAME (sym.symbol),
 109              SYMBOL_VALUE (sym.symbol),
 110              filename, line);
 111           return;
 112
 113         case LOC_CONST_BYTES:
 114           error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."),
 115                  SYMBOL_PRINT_NAME (sym.symbol));
 116
 117         case LOC_UNDEF:
 118           internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."),
 119                           SYMBOL_PRINT_NAME (sym.symbol));
 120
 121         case LOC_COMMON_BLOCK:
 122           error (_("Fortran common block is unsupported for compilation "
 123                    "evaluaton of symbol \"%s\"."),
 124                  SYMBOL_PRINT_NAME (sym.symbol));
 125
 126         case LOC_OPTIMIZED_OUT:
 127           error (_("Symbol \"%s\" cannot be used for compilation evaluation "
 128                    "as it is optimized out."),
 129                  SYMBOL_PRINT_NAME (sym.symbol));
 130
 131         case LOC_COMPUTED:
 132           if (is_local)
 133             goto substitution;
 134           /* Probably TLS here.  */
 135           warning (_("Symbol \"%s\" is thread-local and currently can only "
 136                      "be referenced from the current thread in "
 137                      "compiled code."),
 138                    SYMBOL_PRINT_NAME (sym.symbol));
 139           /* FALLTHROUGH */
 140         case LOC_UNRESOLVED:
 141           /* 'symbol_name' cannot be used here as that one is used only for
 142              local variables from compile_dwarf_expr_to_c.
 143              Global variables can be accessed by GCC only by their address, not
 144              by their name.  */
 145           {
 146             struct value *val;
 147             struct frame_info *frame = NULL;
 148
 149             if (symbol_read_needs_frame (sym.symbol))
 150               {
 151                 frame = get_selected_frame (NULL);
 152                 if (frame == NULL)
 153                   error (_("Symbol \"%s\" cannot be used because "
 154                            "there is no selected frame"),
 155                          SYMBOL_PRINT_NAME (sym.symbol));
 156               }
 157
 158             val = read_var_value (sym.symbol, sym.block, frame);
 159             if (VALUE_LVAL (val) != lval_memory)
 160               error (_("Symbol \"%s\" cannot be used for compilation "
 161                        "evaluation as its address has not been found."),
 162                      SYMBOL_PRINT_NAME (sym.symbol));
 163
 164             kind = GCC_C_SYMBOL_VARIABLE;
 165             addr = value_address (val);
 166           }
 167           break;
 168
 169
 170         case LOC_REGISTER:
 171         case LOC_ARG:
 172         case LOC_REF_ARG:
 173         case LOC_REGPARM_ADDR:
 174         case LOC_LOCAL:
 175         substitution:
 176           kind = GCC_C_SYMBOL_VARIABLE;
 177           symbol_name = c_symbol_substitution_name (sym.symbol);
 178           break;
 179
 180         case LOC_STATIC:
 181           kind = GCC_C_SYMBOL_VARIABLE;
 182           addr = SYMBOL_VALUE_ADDRESS (sym.symbol);
 183           break;
 184
 185         case LOC_FINAL_VALUE:
 186         default:
 187           gdb_assert_not_reached ("Unreachable case in convert_one_symbol.");
 188
 189         }
 190
 191       /* Don't emit local variable decls for a raw expression.  */
 192       if (context->scope () != COMPILE_I_RAW_SCOPE
 193           || symbol_name == NULL)
 194         {
 195           decl = context->plugin ().build_decl
 196             (SYMBOL_NATURAL_NAME (sym.symbol),
 197              kind,
 198              sym_type,
 199              symbol_name.get (), addr,
 200              filename, line);
 201
 202           context->plugin ().bind (decl, is_global);
 203         }
 204     }
 205 }
 206
 207 /* Convert a full symbol to its gcc form.  CONTEXT is the compiler to
 208    use, IDENTIFIER is the name of the symbol, SYM is the symbol
 209    itself, and DOMAIN is the domain which was searched.  */
 210
 211 static void
 212 convert_symbol_sym (compile_c_instance *context, const char *identifier,
 213                     struct block_symbol sym, domain_enum domain)
 214 {
 215   const struct block *static_block;
 216   int is_local_symbol;
 217
 218   /* If we found a symbol and it is not in the  static or global
 219      scope, then we should first convert any static or global scope
 220      symbol of the same name.  This lets this unusual case work:
 221
 222      int x; // Global.
 223      int func(void)
 224      {
 225      int x;
 226      // At this spot, evaluate "extern int x; x"
 227      }
 228   */
 229
 230   static_block = block_static_block (sym.block);
 231   /* STATIC_BLOCK is NULL if FOUND_BLOCK is the global block.  */
 232   is_local_symbol = (sym.block != static_block && static_block != NULL);
 233   if (is_local_symbol)
 234     {
 235       struct block_symbol global_sym;
 236
 237       global_sym = lookup_symbol (identifier, NULL, domain, NULL);
 238       /* If the outer symbol is in the static block, we ignore it, as
 239          it cannot be referenced.  */
 240       if (global_sym.symbol != NULL
 241           && global_sym.block != block_static_block (global_sym.block))
 242         {
 243           if (compile_debug)
 244             fprintf_unfiltered (gdb_stdlog,
 245                                 "gcc_convert_symbol \"%s\": global symbol\n",
 246                                 identifier);
 247           convert_one_symbol (context, global_sym, 1, 0);
 248         }
 249     }
 250
 251   if (compile_debug)
 252     fprintf_unfiltered (gdb_stdlog,
 253                         "gcc_convert_symbol \"%s\": local symbol\n",
 254                         identifier);
 255   convert_one_symbol (context, sym, 0, is_local_symbol);
 256 }
 257
 258 /* Convert a minimal symbol to its gcc form.  CONTEXT is the compiler
 259    to use and BMSYM is the minimal symbol to convert.  */
 260
 261 static void
 262 convert_symbol_bmsym (compile_c_instance *context,
 263                       struct bound_minimal_symbol bmsym)
 264 {
 265   struct minimal_symbol *msym = bmsym.minsym;
 266   struct objfile *objfile = bmsym.objfile;
 267   struct type *type;
 268   enum gcc_c_symbol_kind kind;
 269   gcc_type sym_type;
 270   gcc_decl decl;
 271   CORE_ADDR addr;
 272
 273   addr = MSYMBOL_VALUE_ADDRESS (objfile, msym);
 274
 275   /* Conversion copied from write_exp_msymbol.  */
 276   switch (MSYMBOL_TYPE (msym))
 277     {
 278     case mst_text:
 279     case mst_file_text:
 280     case mst_solib_trampoline:
 281       type = objfile_type (objfile)->nodebug_text_symbol;
 282       kind = GCC_C_SYMBOL_FUNCTION;
 283       break;
 284
 285     case mst_text_gnu_ifunc:
 286       type = objfile_type (objfile)->nodebug_text_gnu_ifunc_symbol;
 287       kind = GCC_C_SYMBOL_FUNCTION;
 288       addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
 289       break;
 290
 291     case mst_data:
 292     case mst_file_data:
 293     case mst_bss:
 294     case mst_file_bss:
 295       type = objfile_type (objfile)->nodebug_data_symbol;
 296       kind = GCC_C_SYMBOL_VARIABLE;
 297       break;
 298
 299     case mst_slot_got_plt:
 300       type = objfile_type (objfile)->nodebug_got_plt_symbol;
 301       kind = GCC_C_SYMBOL_FUNCTION;
 302       break;
 303
 304     default:
 305       type = objfile_type (objfile)->nodebug_unknown_symbol;
 306       kind = GCC_C_SYMBOL_VARIABLE;
 307       break;
 308     }
 309
 310   sym_type = context->convert_type (type);
 311   decl = context->plugin ().build_decl (MSYMBOL_NATURAL_NAME (msym),
 312                                         kind, sym_type, NULL, addr,
 313                                         NULL, 0);
 314   context->plugin ().bind (decl, 1 /* is_global */);
 315 }
 316
 317 /* See compile-internal.h.  */
 318
 319 void
 320 gcc_convert_symbol (void *datum,
 321                     struct gcc_c_context *gcc_context,
 322                     enum gcc_c_oracle_request request,
 323                     const char *identifier)
 324 {
 325   compile_c_instance *context
 326     = static_cast<compile_c_instance *> (datum);
 327   domain_enum domain;
 328   int found = 0;
 329
 330   switch (request)
 331     {
 332     case GCC_C_ORACLE_SYMBOL:
 333       domain = VAR_DOMAIN;
 334       break;
 335     case GCC_C_ORACLE_TAG:
 336       domain = STRUCT_DOMAIN;
 337       break;
 338     case GCC_C_ORACLE_LABEL:
 339       domain = LABEL_DOMAIN;
 340       break;
 341     default:
 342       gdb_assert_not_reached ("Unrecognized oracle request.");
 343     }
 344
 345   /* We can't allow exceptions to escape out of this callback.  Safest
 346      is to simply emit a gcc error.  */
 347   TRY
 348     {
 349       struct block_symbol sym;
 350
 351       sym = lookup_symbol (identifier, context->block (), domain, NULL);
 352       if (sym.symbol != NULL)
 353         {
 354           convert_symbol_sym (context, identifier, sym, domain);
 355           found = 1;
 356         }
 357       else if (domain == VAR_DOMAIN)
 358         {
 359           struct bound_minimal_symbol bmsym;
 360
 361           bmsym = lookup_minimal_symbol (identifier, NULL, NULL);
 362           if (bmsym.minsym != NULL)
 363             {
 364               convert_symbol_bmsym (context, bmsym);
 365               found = 1;
 366             }
 367         }
 368     }
 369
 370   CATCH (e, RETURN_MASK_ALL)
 371     {
 372       context->plugin ().error (e.message);
 373     }
 374   END_CATCH
 375
 376   if (compile_debug && !found)
 377     fprintf_unfiltered (gdb_stdlog,
 378                         "gcc_convert_symbol \"%s\": lookup_symbol failed\n",
 379                         identifier);
 380   return;
 381 }
 382
 383 /* See compile-internal.h.  */
 384
 385 gcc_address
 386 gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
 387                     const char *identifier)
 388 {
 389   compile_c_instance *context
 390     = static_cast<compile_c_instance *> (datum);
 391   gcc_address result = 0;
 392   int found = 0;
 393
 394   /* We can't allow exceptions to escape out of this callback.  Safest
 395      is to simply emit a gcc error.  */
 396   TRY
 397     {
 398       struct symbol *sym;
 399
 400       /* We only need global functions here.  */
 401       sym = lookup_symbol (identifier, NULL, VAR_DOMAIN, NULL).symbol;
 402       if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)
 403         {
 404           if (compile_debug)
 405             fprintf_unfiltered (gdb_stdlog,
 406                                 "gcc_symbol_address \"%s\": full symbol\n",
 407                                 identifier);
 408           result = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
 409           if (TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
 410             result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
 411           found = 1;
 412         }
 413       else
 414         {
 415           struct bound_minimal_symbol msym;
 416
 417           msym = lookup_bound_minimal_symbol (identifier);
 418           if (msym.minsym != NULL)
 419             {
 420               if (compile_debug)
 421                 fprintf_unfiltered (gdb_stdlog,
 422                                     "gcc_symbol_address \"%s\": minimal "
 423                                     "symbol\n",
 424                                     identifier);
 425               result = BMSYMBOL_VALUE_ADDRESS (msym);
 426               if (MSYMBOL_TYPE (msym.minsym) == mst_text_gnu_ifunc)
 427                 result = gnu_ifunc_resolve_addr (target_gdbarch (), result);
 428               found = 1;
 429             }
 430         }
 431     }
 432
 433   CATCH (e, RETURN_MASK_ERROR)
 434     {
 435       context->plugin ().error (e.message);
 436     }
 437   END_CATCH
 438
 439   if (compile_debug && !found)
 440     fprintf_unfiltered (gdb_stdlog,
 441                         "gcc_symbol_address \"%s\": failed\n",
 442                         identifier);
 443   return result;
 444 }
 445
 446 \f
 447
 448 /* A hash function for symbol names.  */
 449
 450 static hashval_t
 451 hash_symname (const void *a)
 452 {
 453   const struct symbol *sym = (const struct symbol *) a;
 454
 455   return htab_hash_string (SYMBOL_NATURAL_NAME (sym));
 456 }
 457
 458 /* A comparison function for hash tables that just looks at symbol
 459    names.  */
 460
 461 static int
 462 eq_symname (const void *a, const void *b)
 463 {
 464   const struct symbol *syma = (const struct symbol *) a;
 465   const struct symbol *symb = (const struct symbol *) b;
 466
 467   return strcmp (SYMBOL_NATURAL_NAME (syma), SYMBOL_NATURAL_NAME (symb)) == 0;
 468 }
 469
 470 /* If a symbol with the same name as SYM is already in HASHTAB, return
 471    1.  Otherwise, add SYM to HASHTAB and return 0.  */
 472
 473 static int
 474 symbol_seen (htab_t hashtab, struct symbol *sym)
 475 {
 476   void **slot;
 477
 478   slot = htab_find_slot (hashtab, sym, INSERT);
 479   if (*slot != NULL)
 480     return 1;
 481
 482   *slot = sym;
 483   return 0;
 484 }
 485
 486 /* Generate C code to compute the length of a VLA.  */
 487
 488 static void
 489 generate_vla_size (compile_instance *compiler,
 490                    string_file &stream,
 491                    struct gdbarch *gdbarch,
 492                    unsigned char *registers_used,
 493                    CORE_ADDR pc,
 494                    struct type *type,
 495                    struct symbol *sym)
 496 {
 497   type = check_typedef (type);
 498
 499   if (TYPE_IS_REFERENCE (type))
 500     type = check_typedef (TYPE_TARGET_TYPE (type));
 501
 502   switch (TYPE_CODE (type))
 503     {
 504     case TYPE_CODE_RANGE:
 505       {
 506         if (TYPE_HIGH_BOUND_KIND (type) == PROP_LOCEXPR
 507             || TYPE_HIGH_BOUND_KIND (type) == PROP_LOCLIST)
 508           {
 509             const struct dynamic_prop *prop = &TYPE_RANGE_DATA (type)->high;
 510             std::string name = c_get_range_decl_name (prop);
 511
 512             dwarf2_compile_property_to_c (stream, name.c_str (),
 513                                           gdbarch, registers_used,
 514                                           prop, pc, sym);
 515           }
 516       }
 517       break;
 518
 519     case TYPE_CODE_ARRAY:
 520       generate_vla_size (compiler, stream, gdbarch, registers_used, pc,
 521                          TYPE_INDEX_TYPE (type), sym);
 522       generate_vla_size (compiler, stream, gdbarch, registers_used, pc,
 523                          TYPE_TARGET_TYPE (type), sym);
 524       break;
 525
 526     case TYPE_CODE_UNION:
 527     case TYPE_CODE_STRUCT:
 528       {
 529         int i;
 530
 531         for (i = 0; i < TYPE_NFIELDS (type); ++i)
 532           if (!field_is_static (&TYPE_FIELD (type, i)))
 533             generate_vla_size (compiler, stream, gdbarch, registers_used, pc,
 534                                TYPE_FIELD_TYPE (type, i), sym);
 535       }
 536       break;
 537     }
 538 }
 539
 540 /* Generate C code to compute the address of SYM.  */
 541
 542 static void
 543 generate_c_for_for_one_variable (compile_instance *compiler,
 544                                  string_file &stream,
 545                                  struct gdbarch *gdbarch,
 546                                  unsigned char *registers_used,
 547                                  CORE_ADDR pc,
 548                                  struct symbol *sym)
 549 {
 550
 551   TRY
 552     {
 553       if (is_dynamic_type (SYMBOL_TYPE (sym)))
 554         {
 555           /* We need to emit to a temporary buffer in case an error
 556              occurs in the middle.  */
 557           string_file local_file;
 558
 559           generate_vla_size (compiler, local_file, gdbarch, registers_used, pc,
 560                              SYMBOL_TYPE (sym), sym);
 561
 562           stream.write (local_file.c_str (), local_file.size ());
 563         }
 564
 565       if (SYMBOL_COMPUTED_OPS (sym) != NULL)
 566         {
 567           gdb::unique_xmalloc_ptr<char> generated_name
 568             = c_symbol_substitution_name (sym);
 569           /* We need to emit to a temporary buffer in case an error
 570              occurs in the middle.  */
 571           string_file local_file;
 572
 573           SYMBOL_COMPUTED_OPS (sym)->generate_c_location (sym, local_file,
 574                                                           gdbarch,
 575                                                           registers_used,
 576                                                           pc,
 577                                                           generated_name.get ());
 578           stream.write (local_file.c_str (), local_file.size ());
 579         }
 580       else
 581         {
 582           switch (SYMBOL_CLASS (sym))
 583             {
 584             case LOC_REGISTER:
 585             case LOC_ARG:
 586             case LOC_REF_ARG:
 587             case LOC_REGPARM_ADDR:
 588             case LOC_LOCAL:
 589               error (_("Local symbol unhandled when generating C code."));
 590
 591             case LOC_COMPUTED:
 592               gdb_assert_not_reached (_("LOC_COMPUTED variable "
 593                                         "missing a method."));
 594
 595             default:
 596               /* Nothing to do for all other cases, as they don't represent
 597                  local variables.  */
 598               break;
 599             }
 600         }
 601     }
 602
 603   CATCH (e, RETURN_MASK_ERROR)
 604     {
 605       compiler->insert_symbol_error (sym, e.message);
 606     }
 607   END_CATCH
 608 }
 609
 610 /* See compile-c.h.  */
 611
 612 gdb::unique_xmalloc_ptr<unsigned char>
 613 generate_c_for_variable_locations (compile_instance *compiler,
 614                                    string_file &stream,
 615                                    struct gdbarch *gdbarch,
 616                                    const struct block *block,
 617                                    CORE_ADDR pc)
 618 {
 619   const struct block *static_block = block_static_block (block);
 620
 621   /* If we're already in the static or global block, there is nothing
 622      to write.  */
 623   if (static_block == NULL || block == static_block)
 624     return NULL;
 625
 626   gdb::unique_xmalloc_ptr<unsigned char> registers_used
 627     (XCNEWVEC (unsigned char, gdbarch_num_regs (gdbarch)));
 628
 629   /* Ensure that a given name is only entered once.  This reflects the
 630      reality of shadowing.  */
 631   htab_up symhash (htab_create_alloc (1, hash_symname, eq_symname, NULL,
 632                                       xcalloc, xfree));
 633
 634   while (1)
 635     {
 636       struct symbol *sym;
 637       struct block_iterator iter;
 638
 639       /* Iterate over symbols in this block, generating code to
 640          compute the location of each local variable.  */
 641       for (sym = block_iterator_first (block, &iter);
 642            sym != NULL;
 643            sym = block_iterator_next (&iter))
 644         {
 645           if (!symbol_seen (symhash.get (), sym))
 646             generate_c_for_for_one_variable (compiler, stream, gdbarch,
 647                                              registers_used.get (), pc, sym);
 648         }
 649
 650       /* If we just finished the outermost block of a function, we're
 651          done.  */
 652       if (BLOCK_FUNCTION (block) != NULL)
 653         break;
 654       block = BLOCK_SUPERBLOCK (block);
 655     }
 656
 657   return registers_used;
 658 }