gdb/compile/compile-c-symbols.c

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