gdb/compile/compile-c-symbols.c

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