GDB (xrefs)
compile-object-load.c
Go to the documentation of this file.
1 /* Load module for 'compile' command.
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 #include "defs.h"
21 #include "compile-object-load.h"
22 #include "compile-internal.h"
23 #include "command.h"
24 #include "objfiles.h"
25 #include "gdbcore.h"
26 #include "readline/tilde.h"
27 #include "bfdlink.h"
28 #include "gdbcmd.h"
29 #include "regcache.h"
30 #include "inferior.h"
31 #include "compile.h"
32 #include "block.h"
33 #include "arch-utils.h"
34 
35 /* Track inferior memory reserved by inferior mmap. */
36 
38 {
39  struct munmap_list *next;
41 };
42 
43 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
44  HEADP. *HEADP needs to be initialized to NULL. */
45 
46 static void
48 {
49  struct munmap_list *head_new = xmalloc (sizeof (*head_new));
50 
51  head_new->next = *headp;
52  *headp = head_new;
53  head_new->addr = addr;
54  head_new->size = size;
55 }
56 
57 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first
58  element of the list, it can be NULL. After calling this function
59  HEAD pointer is invalid and the possible list needs to be
60  reinitialized by caller to NULL. */
61 
62 void
64 {
65  while (head)
66  {
67  struct munmap_list *todo = head;
68 
69  head = todo->next;
71  xfree (todo);
72  }
73 }
74 
75 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to
76  munmap_list_free this function's parameter is a pointer to the first
77  list element pointer. */
78 
79 static void
80 munmap_listp_free_cleanup (void *headp_voidp)
81 {
82  struct munmap_list **headp = headp_voidp;
83 
84  munmap_list_free (*headp);
85 }
86 
87 /* Helper data for setup_sections. */
88 
90 {
91  /* Size of all recent sections with matching LAST_PROT. */
93 
94  /* First section matching LAST_PROT. */
95  asection *last_section_first;
96 
97  /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
98  unsigned last_prot;
99 
100  /* Maximum of alignments of all sections matching LAST_PROT.
101  This value is always at least 1. This value is always a power of 2. */
103 
104  /* List of inferior mmap ranges where setup_sections should add its
105  next range. */
107 };
108 
109 /* Place all ABFD sections next to each other obeying all constraints. */
110 
111 static void
112 setup_sections (bfd *abfd, asection *sect, void *data_voidp)
113 {
114  struct setup_sections_data *data = data_voidp;
115  CORE_ADDR alignment;
116  unsigned prot;
117 
118  if (sect != NULL)
119  {
120  /* It is required by later bfd_get_relocated_section_contents. */
121  if (sect->output_section == NULL)
122  sect->output_section = sect;
123 
124  if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
125  return;
126 
127  /* Make the memory always readable. */
128  prot = GDB_MMAP_PROT_READ;
129  if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0)
130  prot |= GDB_MMAP_PROT_WRITE;
131  if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0)
132  prot |= GDB_MMAP_PROT_EXEC;
133 
134  if (compile_debug)
136  "module \"%s\" section \"%s\" size %s prot %u\n",
137  bfd_get_filename (abfd),
138  bfd_get_section_name (abfd, sect),
140  bfd_get_section_size (sect)),
141  prot);
142  }
143  else
144  prot = -1;
145 
146  if (sect == NULL
147  || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
148  {
149  CORE_ADDR addr;
150  asection *sect_iter;
151 
152  if (data->last_size != 0)
153  {
155  data->last_prot);
156  munmap_list_add (data->munmap_list_headp, addr, data->last_size);
157  if (compile_debug)
159  "allocated %s bytes at %s prot %u\n",
160  paddress (target_gdbarch (), data->last_size),
161  paddress (target_gdbarch (), addr),
162  data->last_prot);
163  }
164  else
165  addr = 0;
166 
167  if ((addr & (data->last_max_alignment - 1)) != 0)
168  error (_("Inferior compiled module address %s "
169  "is not aligned to BFD required %s."),
170  paddress (target_gdbarch (), addr),
172 
173  for (sect_iter = data->last_section_first; sect_iter != sect;
174  sect_iter = sect_iter->next)
175  if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0)
176  bfd_set_section_vma (abfd, sect_iter,
177  addr + bfd_get_section_vma (abfd, sect_iter));
178 
179  data->last_size = 0;
180  data->last_section_first = sect;
181  data->last_prot = prot;
182  data->last_max_alignment = 1;
183  }
184 
185  if (sect == NULL)
186  return;
187 
188  alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
189  data->last_max_alignment = max (data->last_max_alignment, alignment);
190 
191  data->last_size = (data->last_size + alignment - 1) & -alignment;
192 
193  bfd_set_section_vma (abfd, sect, data->last_size);
194 
195  data->last_size += bfd_get_section_size (sect);
196  data->last_size = (data->last_size + alignment - 1) & -alignment;
197 }
198 
199 /* Helper for link_callbacks callbacks vector. */
200 
201 static bfd_boolean
202 link_callbacks_multiple_definition (struct bfd_link_info *link_info,
203  struct bfd_link_hash_entry *h, bfd *nbfd,
204  asection *nsec, bfd_vma nval)
205 {
206  bfd *abfd = link_info->input_bfds;
207 
208  if (link_info->allow_multiple_definition)
209  return TRUE;
210  warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
211  bfd_get_filename (abfd), h->root.string);
212  return FALSE;
213 }
214 
215 /* Helper for link_callbacks callbacks vector. */
216 
217 static bfd_boolean
218 link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning,
219  const char *symbol, bfd *abfd, asection *section,
220  bfd_vma address)
221 {
222  warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
223  bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
224  xwarning);
225  /* Maybe permit running as a module? */
226  return FALSE;
227 }
228 
229 /* Helper for link_callbacks callbacks vector. */
230 
231 static bfd_boolean
232 link_callbacks_undefined_symbol (struct bfd_link_info *link_info,
233  const char *name, bfd *abfd, asection *section,
234  bfd_vma address, bfd_boolean is_fatal)
235 {
236  warning (_("Cannot resolve relocation to \"%s\" "
237  "from compiled module \"%s\" section \"%s\"."),
238  name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
239  return FALSE;
240 }
241 
242 /* Helper for link_callbacks callbacks vector. */
243 
244 static bfd_boolean
245 link_callbacks_reloc_overflow (struct bfd_link_info *link_info,
246  struct bfd_link_hash_entry *entry,
247  const char *name, const char *reloc_name,
248  bfd_vma addend, bfd *abfd, asection *section,
249  bfd_vma address)
250 {
251  /* TRUE is required for intra-module relocations. */
252  return TRUE;
253 }
254 
255 /* Helper for link_callbacks callbacks vector. */
256 
257 static bfd_boolean
258 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
259  const char *message, bfd *abfd,
260  asection *section, bfd_vma address)
261 {
262  warning (_("Compiled module \"%s\" section \"%s\": dangerous "
263  "relocation: %s\n"),
264  bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
265  message);
266  return FALSE;
267 }
268 
269 /* Helper for link_callbacks callbacks vector. */
270 
271 static bfd_boolean
272 link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
273  const char *name, bfd *abfd, asection *section,
274  bfd_vma address)
275 {
276  warning (_("Compiled module \"%s\" section \"%s\": unattached "
277  "relocation: %s\n"),
278  bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
279  name);
280  return FALSE;
281 }
282 
283 /* Helper for link_callbacks callbacks vector. */
284 
285 static void link_callbacks_einfo (const char *fmt, ...)
286  ATTRIBUTE_PRINTF (1, 2);
287 
288 static void
289 link_callbacks_einfo (const char *fmt, ...)
290 {
291  struct cleanup *cleanups;
292  va_list ap;
293  char *str;
294 
295  va_start (ap, fmt);
296  str = xstrvprintf (fmt, ap);
297  va_end (ap);
298  cleanups = make_cleanup (xfree, str);
299 
300  warning (_("Compile module: warning: %s"), str);
301 
302  do_cleanups (cleanups);
303 }
304 
305 /* Helper for bfd_get_relocated_section_contents.
306  Only these symbols are set by bfd_simple_get_relocated_section_contents
307  but bfd/ seems to use even the NULL ones without checking them first. */
308 
309 static const struct bfd_link_callbacks link_callbacks =
310 {
311  NULL, /* add_archive_element */
312  link_callbacks_multiple_definition, /* multiple_definition */
313  NULL, /* multiple_common */
314  NULL, /* add_to_set */
315  NULL, /* constructor */
316  link_callbacks_warning, /* warning */
317  link_callbacks_undefined_symbol, /* undefined_symbol */
318  link_callbacks_reloc_overflow, /* reloc_overflow */
319  link_callbacks_reloc_dangerous, /* reloc_dangerous */
320  link_callbacks_unattached_reloc, /* unattached_reloc */
321  NULL, /* notice */
322  link_callbacks_einfo, /* einfo */
323  NULL, /* info */
324  NULL, /* minfo */
325  NULL, /* override_segment_assignment */
326 };
327 
329 {
330  bfd *abfd;
331  bfd *link_next;
332 };
333 
334 /* Cleanup callback for struct bfd_link_info. */
335 
336 static void
338 {
339  struct link_hash_table_cleanup_data *data = d;
340 
341  if (data->abfd->is_linker_output)
342  (*data->abfd->link.hash->hash_table_free) (data->abfd);
343  data->abfd->link.next = data->link_next;
344 }
345 
346 /* Relocate and store into inferior memory each section SECT of ABFD. */
347 
348 static void
349 copy_sections (bfd *abfd, asection *sect, void *data)
350 {
351  asymbol **symbol_table = data;
352  bfd_byte *sect_data, *sect_data_got;
353  struct cleanup *cleanups;
354  struct bfd_link_info link_info;
355  struct bfd_link_order link_order;
356  CORE_ADDR inferior_addr;
357  struct link_hash_table_cleanup_data cleanup_data;
358 
359  if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
360  != (SEC_ALLOC | SEC_LOAD))
361  return;
362 
363  if (bfd_get_section_size (sect) == 0)
364  return;
365 
366  /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
367  cannot use as it does not report relocations to undefined symbols. */
368  memset (&link_info, 0, sizeof (link_info));
369  link_info.output_bfd = abfd;
370  link_info.input_bfds = abfd;
371  link_info.input_bfds_tail = &abfd->link.next;
372 
373  cleanup_data.abfd = abfd;
374  cleanup_data.link_next = abfd->link.next;
375 
376  abfd->link.next = NULL;
377  link_info.hash = bfd_link_hash_table_create (abfd);
378 
379  cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
380  link_info.callbacks = &link_callbacks;
381 
382  memset (&link_order, 0, sizeof (link_order));
383  link_order.next = NULL;
384  link_order.type = bfd_indirect_link_order;
385  link_order.offset = 0;
386  link_order.size = bfd_get_section_size (sect);
387  link_order.u.indirect.section = sect;
388 
389  sect_data = xmalloc (bfd_get_section_size (sect));
390  make_cleanup (xfree, sect_data);
391 
392  sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
393  &link_order, sect_data,
394  FALSE, symbol_table);
395 
396  if (sect_data_got == NULL)
397  error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
398  bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
399  bfd_errmsg (bfd_get_error ()));
400  gdb_assert (sect_data_got == sect_data);
401 
402  inferior_addr = bfd_get_section_vma (abfd, sect);
403  if (0 != target_write_memory (inferior_addr, sect_data,
404  bfd_get_section_size (sect)))
405  error (_("Cannot write compiled module \"%s\" section \"%s\" "
406  "to inferior memory range %s-%s."),
407  bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
408  paddress (target_gdbarch (), inferior_addr),
410  inferior_addr + bfd_get_section_size (sect)));
411 
412  do_cleanups (cleanups);
413 }
414 
415 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
416  symbols in OBJFILE so we can calculate how much memory to allocate
417  for the out parameter. This avoids needing a malloc in the generated
418  code. Throw an error if anything fails.
419  GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
420  If it finds user tries to print an array type this function returns
421  NULL. Caller will then regenerate the code with
422  COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
423  This is because __auto_type array-to-pointer type conversion of
424  COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
425  preserving the array type. */
426 
427 static struct type *
428 get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
429  enum compile_i_scope_types scope)
430 {
431  struct symbol *gdb_ptr_type_sym;
432  /* Initialize it just to avoid a GCC false warning. */
433  struct symbol *gdb_val_sym = NULL;
434  struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval;
435  /* Initialize it just to avoid a GCC false warning. */
436  const struct block *block = NULL;
437  const struct blockvector *bv;
438  int nblocks = 0;
439  int block_loop = 0;
440 
441  bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab);
442  nblocks = BLOCKVECTOR_NBLOCKS (bv);
443 
444  gdb_ptr_type_sym = NULL;
445  for (block_loop = 0; block_loop < nblocks; block_loop++)
446  {
447  struct symbol *function = NULL;
448  const struct block *function_block;
449 
450  block = BLOCKVECTOR_BLOCK (bv, block_loop);
451  if (BLOCK_FUNCTION (block) != NULL)
452  continue;
453  gdb_val_sym = block_lookup_symbol (block, COMPILE_I_EXPR_VAL, VAR_DOMAIN);
454  if (gdb_val_sym == NULL)
455  continue;
456 
457  function_block = block;
458  while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
459  && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
460  {
461  function_block = BLOCK_SUPERBLOCK (function_block);
462  function = BLOCK_FUNCTION (function_block);
463  if (function != NULL)
464  break;
465  }
466  if (function != NULL
467  && (BLOCK_SUPERBLOCK (function_block)
469  && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
470  == 0))
471  break;
472  }
473  if (block_loop == nblocks)
474  error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
475 
476  gdb_type = SYMBOL_TYPE (gdb_val_sym);
477  CHECK_TYPEDEF (gdb_type);
478 
479  gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
480  VAR_DOMAIN);
481  if (gdb_ptr_type_sym == NULL)
482  error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
483  gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
484  CHECK_TYPEDEF (gdb_ptr_type);
485  if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
486  error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
487  gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
488 
489  if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
490  {
491  if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
492  error (_("Expected address scope in compiled module \"%s\"."),
493  objfile_name (objfile));
494  return gdb_type;
495  }
496 
497  if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
498  error (_("Invalid type code %d of symbol \"%s\" "
499  "in compiled module \"%s\"."),
500  TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
501  objfile_name (objfile));
502 
503  retval = gdb_type_from_ptr;
504  switch (TYPE_CODE (gdb_type_from_ptr))
505  {
506  case TYPE_CODE_ARRAY:
507  gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
508  break;
509  case TYPE_CODE_FUNC:
510  break;
511  default:
512  error (_("Invalid type code %d of symbol \"%s\" "
513  "in compiled module \"%s\"."),
514  TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
515  objfile_name (objfile));
516  }
517  if (!types_deeply_equal (gdb_type_from_ptr,
518  TYPE_TARGET_TYPE (gdb_type)))
519  error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
520  "in compiled module \"%s\"."),
522  objfile_name (objfile));
523  if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
524  return NULL;
525  return retval;
526 }
527 
528 /* Fetch the type of first parameter of FUNC_SYM.
529  Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
530 
531 static struct type *
532 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
533 {
534  struct type *func_type = SYMBOL_TYPE (func_sym);
535  struct type *regsp_type, *regs_type;
536 
537  /* No register parameter present. */
538  if (TYPE_NFIELDS (func_type) == 0)
539  return NULL;
540 
541  regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
542  if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
543  error (_("Invalid type code %d of first parameter of function \"%s\" "
544  "in compiled module \"%s\"."),
545  TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
546  objfile_name (objfile));
547 
548  regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
549  if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
550  error (_("Invalid type code %d of dereferenced first parameter "
551  "of function \"%s\" in compiled module \"%s\"."),
552  TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
553  objfile_name (objfile));
554 
555  return regs_type;
556 }
557 
558 /* Store all inferior registers required by REGS_TYPE to inferior memory
559  starting at inferior address REGS_BASE. */
560 
561 static void
562 store_regs (struct type *regs_type, CORE_ADDR regs_base)
563 {
564  struct gdbarch *gdbarch = target_gdbarch ();
566  int fieldno;
567 
568  for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
569  {
570  const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
571  ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
572  ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
574  struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
575  fieldno));
576  ULONGEST reg_size = TYPE_LENGTH (reg_type);
577  int regnum;
578  struct value *regval;
579  CORE_ADDR inferior_addr;
580 
581  if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
582  continue;
583 
584  if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
585  error (_("Invalid register \"%s\" position %s bits or size %s bits"),
586  reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
587  reg_offset = reg_bitpos / 8;
588 
589  if (TYPE_CODE (reg_type) != TYPE_CODE_INT
590  && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
591  error (_("Invalid register \"%s\" type code %d"), reg_name,
592  TYPE_CODE (reg_type));
593 
594  regnum = compile_register_name_demangle (gdbarch, reg_name);
595 
596  regval = value_from_register (reg_type, regnum, get_current_frame ());
597  if (value_optimized_out (regval))
598  error (_("Register \"%s\" is optimized out."), reg_name);
599  if (!value_entirely_available (regval))
600  error (_("Register \"%s\" is not available."), reg_name);
601 
602  inferior_addr = regs_base + reg_offset;
603  if (0 != target_write_memory (inferior_addr, value_contents (regval),
604  reg_size))
605  error (_("Cannot write register \"%s\" to inferior memory at %s."),
606  reg_name, paddress (gdbarch, inferior_addr));
607  }
608 }
609 
610 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
611  Caller must fully dispose the return value by calling compile_object_run.
612  SOURCE_FILE's copy is stored into the returned object.
613  Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
614  function returns.
615  Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when
616  COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */
617 
618 struct compile_module *
619 compile_object_load (const char *object_file, const char *source_file,
621 {
622  struct cleanup *cleanups, *cleanups_free_objfile;
623  bfd *abfd;
624  struct setup_sections_data setup_sections_data;
625  CORE_ADDR addr, regs_addr, out_value_addr = 0;
626  struct symbol *func_sym;
627  struct type *func_type;
628  struct bound_minimal_symbol bmsym;
629  long storage_needed;
630  asymbol **symbol_table, **symp;
631  long number_of_symbols, missing_symbols;
632  struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
633  unsigned dptr_type_len = TYPE_LENGTH (dptr_type);
634  struct compile_module *retval;
635  struct type *regs_type, *out_value_type = NULL;
636  char *filename, **matching;
637  struct objfile *objfile;
638  int expect_parameters;
639  struct type *expect_return_type;
640  struct munmap_list *munmap_list_head = NULL;
641 
642  filename = tilde_expand (object_file);
643  cleanups = make_cleanup (xfree, filename);
644 
645  abfd = gdb_bfd_open (filename, gnutarget, -1);
646  if (abfd == NULL)
647  error (_("\"%s\": could not open as compiled module: %s"),
648  filename, bfd_errmsg (bfd_get_error ()));
649  make_cleanup_bfd_unref (abfd);
650 
651  if (!bfd_check_format_matches (abfd, bfd_object, &matching))
652  error (_("\"%s\": not in loadable format: %s"),
653  filename, gdb_bfd_errmsg (bfd_get_error (), matching));
654 
655  if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0)
656  error (_("\"%s\": not in object format."), filename);
657 
658  setup_sections_data.last_size = 0;
659  setup_sections_data.last_section_first = abfd->sections;
660  setup_sections_data.last_prot = -1;
661  setup_sections_data.last_max_alignment = 1;
662  setup_sections_data.munmap_list_headp = &munmap_list_head;
663  make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
664  bfd_map_over_sections (abfd, setup_sections, &setup_sections_data);
665  setup_sections (abfd, NULL, &setup_sections_data);
666 
667  storage_needed = bfd_get_symtab_upper_bound (abfd);
668  if (storage_needed < 0)
669  error (_("Cannot read symbols of compiled module \"%s\": %s"),
670  filename, bfd_errmsg (bfd_get_error ()));
671 
672  /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
673  "Reading symbols from ..." message for automatically generated file. */
674  objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL);
675  cleanups_free_objfile = make_cleanup_free_objfile (objfile);
676 
677  func_sym = lookup_global_symbol_from_objfile (objfile,
678  GCC_FE_WRAPPER_FUNCTION,
679  VAR_DOMAIN);
680  if (func_sym == NULL)
681  error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
682  GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
683  func_type = SYMBOL_TYPE (func_sym);
684  if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
685  error (_("Invalid type code %d of function \"%s\" in compiled "
686  "module \"%s\"."),
687  TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
688  objfile_name (objfile));
689 
690  switch (scope)
691  {
693  expect_parameters = 1;
694  expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
695  break;
696  case COMPILE_I_RAW_SCOPE:
697  expect_parameters = 0;
698  expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
699  break;
702  expect_parameters = 2;
703  expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
704  break;
705  default:
706  internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
707  }
708  if (TYPE_NFIELDS (func_type) != expect_parameters)
709  error (_("Invalid %d parameters of function \"%s\" in compiled "
710  "module \"%s\"."),
711  TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
712  objfile_name (objfile));
713  if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
714  error (_("Invalid return type of function \"%s\" in compiled "
715  "module \"%s\"."),
716  GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
717 
718  /* The memory may be later needed
719  by bfd_generic_get_relocated_section_contents
720  called from default_symfile_relocate. */
721  symbol_table = obstack_alloc (&objfile->objfile_obstack, storage_needed);
722  number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
723  if (number_of_symbols < 0)
724  error (_("Cannot parse symbols of compiled module \"%s\": %s"),
725  filename, bfd_errmsg (bfd_get_error ()));
726 
727  missing_symbols = 0;
728  for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
729  {
730  asymbol *sym = *symp;
731 
732  if (sym->flags != 0)
733  continue;
734  sym->flags = BSF_GLOBAL;
735  sym->section = bfd_abs_section_ptr;
736  if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
737  {
738  if (compile_debug)
740  "ELF symbol \"%s\" relocated to zero\n",
741  sym->name);
742 
743  /* It seems to be a GCC bug, with -mcmodel=large there should be no
744  need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
745  remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
746  sym->value = 0;
747  continue;
748  }
749  bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
750  switch (bmsym.minsym == NULL
751  ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
752  {
753  case mst_text:
754  sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
755  if (compile_debug)
757  "ELF mst_text symbol \"%s\" relocated to %s\n",
758  sym->name,
759  paddress (target_gdbarch (), sym->value));
760  break;
761  case mst_text_gnu_ifunc:
762  sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
763  BMSYMBOL_VALUE_ADDRESS (bmsym));
764  if (compile_debug)
766  "ELF mst_text_gnu_ifunc symbol \"%s\" "
767  "relocated to %s\n",
768  sym->name,
769  paddress (target_gdbarch (), sym->value));
770  break;
771  default:
772  warning (_("Could not find symbol \"%s\" "
773  "for compiled module \"%s\"."),
774  sym->name, filename);
775  missing_symbols++;
776  }
777  }
778  if (missing_symbols)
779  error (_("%ld symbols were missing, cannot continue."), missing_symbols);
780 
781  bfd_map_over_sections (abfd, copy_sections, symbol_table);
782 
783  regs_type = get_regs_type (func_sym, objfile);
784  if (regs_type == NULL)
785  regs_addr = 0;
786  else
787  {
788  /* Use read-only non-executable memory protection. */
789  regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
790  TYPE_LENGTH (regs_type),
792  gdb_assert (regs_addr != 0);
793  munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
794  if (compile_debug)
796  "allocated %s bytes at %s for registers\n",
798  TYPE_LENGTH (regs_type)),
799  paddress (target_gdbarch (), regs_addr));
800  store_regs (regs_type, regs_addr);
801  }
802 
803  if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
804  || scope == COMPILE_I_PRINT_VALUE_SCOPE)
805  {
806  out_value_type = get_out_value_type (func_sym, objfile, scope);
807  if (out_value_type == NULL)
808  {
809  do_cleanups (cleanups);
810  return NULL;
811  }
812  check_typedef (out_value_type);
813  out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
814  TYPE_LENGTH (out_value_type),
817  gdb_assert (out_value_addr != 0);
818  munmap_list_add (&munmap_list_head, out_value_addr,
819  TYPE_LENGTH (out_value_type));
820  if (compile_debug)
822  "allocated %s bytes at %s for printed value\n",
824  TYPE_LENGTH (out_value_type)),
825  paddress (target_gdbarch (), out_value_addr));
826  }
827 
828  discard_cleanups (cleanups_free_objfile);
829 
830  retval = xmalloc (sizeof (*retval));
831  retval->objfile = objfile;
832  retval->source_file = xstrdup (source_file);
833  retval->func_sym = func_sym;
834  retval->regs_addr = regs_addr;
835  retval->scope = scope;
836  retval->scope_data = scope_data;
837  retval->out_value_type = out_value_type;
838  retval->out_value_addr = out_value_addr;
839 
840  /* CLEANUPS will free MUNMAP_LIST_HEAD. */
841  retval->munmap_list_head = munmap_list_head;
842  munmap_list_head = NULL;
843 
844  do_cleanups (cleanups);
845 
846  return retval;
847 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define COMPILE_I_EXPR_PTR_TYPE
void gdbarch_infcall_munmap(struct gdbarch *gdbarch, CORE_ADDR addr, CORE_ADDR size)
Definition: gdbarch.c:4689
static void copy_sections(bfd *abfd, asection *sect, void *data)
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
bfd_vma CORE_ADDR
Definition: common-types.h:41
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1369
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1474
struct compile_module * compile_object_load(const char *object_file, const char *source_file, enum compile_i_scope_types scope, void *scope_data)
struct regcache * get_thread_regcache(ptid_t ptid)
Definition: regcache.c:529
void xfree(void *)
Definition: common-utils.c:97
struct symtab * symtab
Definition: symtab.h:722
struct objfile * symbol_file_add_from_bfd(bfd *abfd, const char *name, int add_flags, struct section_addr_info *addrs, int flags, struct objfile *parent)
Definition: symfile.c:1276
char * xstrvprintf(const char *format, va_list ap)
Definition: common-utils.c:119
#define BMSYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:393
void warning(const char *fmt,...)
Definition: errors.c:26
struct type ** const(pascal_builtin_types[])
struct munmap_list * munmap_list_head
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
int compile_debug
Definition: compile.c:55
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
static int reg_offset[]
Definition: i386gnu-nat.c:42
static bfd_boolean link_callbacks_reloc_dangerous(struct bfd_link_info *link_info, const char *message, bfd *abfd, asection *section, bfd_vma address)
CORE_ADDR out_value_addr
compile_i_scope_types
Definition: defs.h:60
struct symbol * lookup_global_symbol_from_objfile(struct objfile *main_objfile, const char *name, const domain_enum domain)
Definition: symtab.c:2290
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
#define _(String)
Definition: gdb_locale.h:40
struct bfd * gdb_bfd_open(const char *name, const char *target, int fd)
Definition: gdb_bfd.c:320
static bfd_boolean link_callbacks_undefined_symbol(struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address, bfd_boolean is_fatal)
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1368
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
struct obstack objfile_obstack
Definition: objfiles.h:328
int types_deeply_equal(struct type *type1, struct type *type2)
Definition: gdbtypes.c:3321
struct munmap_list ** munmap_list_headp
const char *const name
Definition: aarch64-tdep.c:68
struct value * value_from_register(struct type *type, int regnum, struct frame_info *frame)
Definition: findvar.c:699
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:968
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1329
struct cleanup * make_cleanup_free_objfile(struct objfile *obj)
Definition: objfiles.c:667
char * gnutarget
Definition: corefile.c:437
static const struct bfd_link_callbacks link_callbacks
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
#define COMPILE_I_SIMPLE_REGISTER_DUMMY
int nblocks
Definition: block.h:126
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
#define COMPILE_I_EXPR_VAL
Definition: gdbtypes.h:749
CORE_ADDR gdbarch_infcall_mmap(struct gdbarch *gdbarch, CORE_ADDR size, unsigned prot)
Definition: gdbarch.c:4672
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
static void link_callbacks_einfo(const char *fmt,...) ATTRIBUTE_PRINTF(1
#define GDB_MMAP_PROT_READ
Definition: arch-utils.h:198
#define gdb_assert(expr)
Definition: gdb_assert.h:33
#define GDB_MMAP_PROT_WRITE
Definition: arch-utils.h:199
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
#define GDB_MMAP_PROT_EXEC
Definition: arch-utils.h:200
struct symbol * block_lookup_symbol(const struct block *block, const char *name, const domain_enum domain)
Definition: block.c:734
const char * gdb_bfd_errmsg(bfd_error_type error_tag, char **matching)
Definition: utils.c:3069
int regnum
Definition: aarch64-tdep.c:69
union symbol::@160 owner
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
struct cleanup * make_cleanup_bfd_unref(bfd *abfd)
Definition: utils.c:189
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1377
#define TYPE_FIELD_BITPOS(thistype, n)
Definition: gdbtypes.h:1371
Definition: block.h:60
Definition: value.c:172
enum compile_i_scope_types scope
int value_entirely_available(struct value *value)
Definition: value.c:368
static void store_regs(struct type *regs_type, CORE_ADDR regs_base)
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
int value_optimized_out(struct value *value)
Definition: value.c:1346
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1229
static bfd_boolean link_callbacks_multiple_definition(struct bfd_link_info *link_info, struct bfd_link_hash_entry *h, bfd *nbfd, asection *nsec, bfd_vma nval)
#define max(a, b)
Definition: defs.h:109
struct symbol * func_sym
static bfd_boolean link_callbacks_reloc_overflow(struct bfd_link_info *link_info, struct bfd_link_hash_entry *entry, const char *name, const char *reloc_name, bfd_vma addend, bfd *abfd, asection *section, bfd_vma address)
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
ptid_t inferior_ptid
Definition: infcmd.c:124
struct type * builtin_data_ptr
Definition: gdbtypes.h:1533
struct minimal_symbol * minsym
Definition: minsyms.h:32
void munmap_list_free(struct munmap_list *head)
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1241
static bfd_boolean link_callbacks_warning(struct bfd_link_info *link_info, const char *xwarning, const char *symbol, bfd *abfd, asection *section, bfd_vma address)
#define CHECK_TYPEDEF(TYPE)
Definition: gdbtypes.h:1817
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:135
static void setup_sections(bfd *abfd, asection *sect, void *data_voidp)
unsigned long long ULONGEST
Definition: common-types.h:53
static bfd_boolean link_callbacks_unattached_reloc(struct bfd_link_info *link_info, const char *name, bfd *abfd, asection *section, bfd_vma address)
static void ATTRIBUTE_PRINTF(6, 0)
Definition: cli-out.c:229
struct munmap_list * next
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static void munmap_list_add(struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
static struct type * get_regs_type(struct symbol *func_sym, struct objfile *objfile)
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:163
struct objfile * objfile
static void munmap_listp_free_cleanup(void *headp_voidp)
static void link_hash_table_free(void *d)
struct type * builtin_void
Definition: gdbtypes.h:1480
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
int compile_register_name_demangle(struct gdbarch *gdbarch, const char *reg_name)
Definition: compile.c:652
struct type * out_value_type
#define gnu_ifunc_resolve_addr
Definition: symtab.h:1354
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static struct type * get_out_value_type(struct symbol *func_sym, struct objfile *objfile, enum compile_i_scope_types scope)