xref: /netbsd-src/external/gpl3/gdb.old/dist/gdb/compile/compile-c-symbols.c (revision bdc22b2e01993381dcefeff2bc9b56ca75a4235c)
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 
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 
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 
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 }
773