GDB (xrefs)
compile-c-symbols.c
Go to the documentation of this file.
1 /* Convert symbols from GDB to GCC
2 
3  Copyright (C) 2014-2015 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 
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 = 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 = a;
65  const struct symbol_error *seb = b;
66 
67  return sea->sym == seb->sym;
68 }
69 
70 /* Deletion function for struct symbol_error. */
71 
72 static void
74 {
75  struct symbol_error *se = 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
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 = 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 *
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
146  struct symbol *sym,
147  int is_global,
148  int is_local)
149 {
150  gcc_type sym_type;
151  const char *filename = symbol_symtab (sym)->filename;
152  unsigned short line = SYMBOL_LINE (sym);
153 
154  error_symbol_once (context, sym);
155 
156  if (SYMBOL_CLASS (sym) == LOC_LABEL)
157  sym_type = 0;
158  else
159  sym_type = convert_type (context, SYMBOL_TYPE (sym));
160 
161  if (SYMBOL_DOMAIN (sym) == 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),
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))
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);
184  break;
185 
186  case LOC_BLOCK:
187  kind = GCC_C_SYMBOL_FUNCTION;
188  addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
189  if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym)))
190  addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr);
191  break;
192 
193  case LOC_CONST:
194  if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM)
195  {
196  /* Already handled by convert_enum. */
197  return;
198  }
199  C_CTX (context)->c_ops->build_constant (C_CTX (context), sym_type,
200  SYMBOL_NATURAL_NAME (sym),
201  SYMBOL_VALUE (sym),
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));
208 
209  case LOC_UNDEF:
210  internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."),
211  SYMBOL_PRINT_NAME (sym));
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));
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));
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));
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))
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));
248  }
249 
250  val = read_var_value (sym, 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));
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);
270  break;
271 
272  case LOC_STATIC:
273  kind = GCC_C_SYMBOL_VARIABLE;
274  addr = SYMBOL_VALUE_ADDRESS (sym);
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 (C_CTX (context),
288  SYMBOL_NATURAL_NAME (sym),
289  kind,
290  sym_type,
291  symbol_name, addr,
292  filename, line);
293 
294  C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global);
295  }
296 
297  xfree (symbol_name);
298  }
299 }
300 
301 /* Convert a full symbol to its gcc form. CONTEXT is the compiler to
302  use, IDENTIFIER is the name of the symbol, SYM is the symbol
303  itself, and DOMAIN is the domain which was searched. */
304 
305 static void
306 convert_symbol_sym (struct compile_c_instance *context, const char *identifier,
307  struct symbol *sym, domain_enum domain)
308 {
309  const struct block *static_block, *found_block;
310  int is_local_symbol;
311 
312  found_block = block_found;
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 (found_block);
327  /* STATIC_BLOCK is NULL if FOUND_BLOCK is the global block. */
328  is_local_symbol = (found_block != static_block && static_block != NULL);
329  if (is_local_symbol)
330  {
331  struct 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 != NULL
338  {
339  if (compile_debug)
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)
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
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:
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 = 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 symbol *sym;
448 
449  sym = lookup_symbol (identifier, context->base.block, domain, NULL);
450  if (sym != 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 
469  {
470  C_CTX (context)->c_ops->error (C_CTX (context), e.message);
471  }
472  END_CATCH
473 
474  if (compile_debug && !found)
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 = 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);
499  if (sym != NULL && SYMBOL_CLASS (sym) == LOC_BLOCK)
500  {
501  if (compile_debug)
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)
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 
531  {
532  C_CTX (context)->c_ops->error (C_CTX (context), e.message);
533  }
534  END_CATCH
535 
536  if (compile_debug && !found)
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 = 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 = a;
562  const struct symbol *symb = 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
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
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 
705  {
706  if (compiler->symbol_err_map == NULL)
707  compiler->symbol_err_map = htab_create_alloc (10,
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 *
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 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define TYPE_HIGH_BOUND_KIND(range_type)
Definition: gdbtypes.h:1254
struct symbol * block_iterator_next(struct block_iterator *iterator)
Definition: block.c:570
#define TYPE_RANGE_DATA(thistype)
Definition: gdbtypes.h:1245
static void convert_symbol_sym(struct compile_c_instance *context, const char *identifier, struct symbol *sym, domain_enum domain)
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
bfd_vma CORE_ADDR
Definition: common-types.h:41
void xfree(void *)
Definition: common-utils.c:97
struct compile_instance base
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void warning(const char *fmt,...)
Definition: errors.c:26
static hashval_t hash_symname(const void *a)
static void convert_one_symbol(struct compile_c_instance *context, struct symbol *sym, int is_global, int is_local)
static void insert_symbol_error(htab_t hash, const struct symbol *sym, const char *text)
void ui_file_put(struct ui_file *file, ui_file_put_method_ftype *write, void *dest)
Definition: ui-file.c:210
enum domain_enum_tag domain_enum
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:4909
static void generate_c_for_for_one_variable(struct compile_c_instance *compiler, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, struct symbol *sym)
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
int compile_debug
Definition: compile.c:55
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
struct value * read_var_value(struct symbol *var, struct frame_info *frame)
Definition: findvar.c:613
static int symbol_seen(htab_t hashtab, struct symbol *sym)
const struct symbol * sym
struct type * nodebug_data_symbol
Definition: gdbtypes.h:1597
const char * filename
Definition: symtab.h:943
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1367
#define BLOCK_START(bl)
Definition: block.h:116
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
#define END_CATCH
#define VALUE_LVAL(val)
Definition: value.h:411
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
static int eq_symname(const void *a, const void *b)
void gcc_convert_symbol(void *datum, struct gcc_c_context *gcc_context, enum gcc_c_oracle_request request, const char *identifier)
#define TRY
const char *const name
Definition: aarch64-tdep.c:68
#define C_CTX(I)
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define TYPE_GNU_IFUNC(t)
Definition: gdbtypes.h:318
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
#define CATCH(EXCEPTION, MASK)
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
int field_is_static(struct field *f)
Definition: gdbtypes.c:3797
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t err
Definition: gnu-nat.c:1816
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
int symbol_read_needs_frame(struct symbol *sym)
Definition: findvar.c:343
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
#define SYMBOL_COMPUTED_OPS(symbol)
Definition: symtab.h:801
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
Definition: gdbtypes.h:749
static hashval_t hash_symbol_error(const void *a)
const struct block * block_found
Definition: symtab.c:250
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
#define MSYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:407
static const char * type
Definition: language.c:103
#define SYMBOL_LINE(symbol)
Definition: symtab.h:800
struct type * nodebug_got_plt_symbol
Definition: gdbtypes.h:1596
static void convert_symbol_bmsym(struct compile_c_instance *context, struct bound_minimal_symbol bmsym)
static void error_symbol_once(struct compile_c_instance *context, const struct symbol *sym)
struct ui_file * gdb_stdlog
Definition: main.c:73
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
void ui_file_write_for_put(void *data, const char *buffer, long length_buffer)
Definition: ui-file.c:226
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
Definition: block.h:60
Definition: value.c:172
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
gcc_address gcc_symbol_address(void *datum, struct gcc_c_context *gcc_context, const char *identifier)
unsigned char * generate_c_for_variable_locations(struct compile_c_instance *compiler, struct ui_file *stream, struct gdbarch *gdbarch, const struct block *block, CORE_ADDR pc)
struct type * nodebug_unknown_symbol
Definition: gdbtypes.h:1598
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
void dwarf2_compile_property_to_c(struct ui_file *stream, const char *result_name, struct gdbarch *gdbarch, unsigned char *registers_used, const struct dynamic_prop *prop, CORE_ADDR pc, struct symbol *sym)
Definition: dwarf2loc.c:2546
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
const struct block * block_static_block(const struct block *block)
Definition: block.c:365
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
#define TYPE_INDEX_TYPE(type)
Definition: gdbtypes.h:1244
enum compile_i_scope_types scope
static char * symbol_substitution_name(struct symbol *sym)
struct minimal_symbol * minsym
Definition: minsyms.h:32
static void generate_vla_size(struct compile_c_instance *compiler, struct ui_file *stream, struct gdbarch *gdbarch, unsigned char *registers_used, CORE_ADDR pc, struct type *type, struct symbol *sym)
struct symbol * lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1967
struct bound_minimal_symbol lookup_bound_minimal_symbol(const char *name)
Definition: minsyms.c:335
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
int line
Definition: symtab.h:1570
struct cleanup * make_cleanup_htab_delete(htab_t htab)
Definition: utils.c:343
struct type * nodebug_text_symbol
Definition: gdbtypes.h:1594
static int eq_symbol_error(const void *a, const void *b)
#define SYMBOL_NATURAL_NAME(symbol)
Definition: symtab.h:231
int is_dynamic_type(struct type *type)
Definition: gdbtypes.c:1852
const struct block * block
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
struct symbol * block_iterator_first(const struct block *block, struct block_iterator *iterator)
Definition: block.c:556
struct objfile * objfile
Definition: minsyms.h:37
gcc_type convert_type(struct compile_c_instance *context, struct type *type)
CORE_ADDR value_address(const struct value *value)
Definition: value.c:1440
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
struct symtab * symbol_symtab(const struct symbol *symbol)
Definition: symtab.c:6250
static void del_symbol_error(void *a)
void error(const char *fmt,...)
Definition: errors.c:38
char * c_get_range_decl_name(const struct dynamic_prop *prop)
#define gnu_ifunc_resolve_addr
Definition: symtab.h:1354
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389