1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2015 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
21 #include "compile-object-load.h"
22 #include "compile-internal.h"
26 #include "readline/tilde.h"
33 #include "arch-utils.h"
35 /* Track inferior memory reserved by inferior mmap. */
39 struct munmap_list *next;
43 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
44 HEADP. *HEADP needs to be initialized to NULL. */
47 munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
49 struct munmap_list *head_new = XNEW (struct munmap_list);
51 head_new->next = *headp;
53 head_new->addr = addr;
54 head_new->size = size;
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. */
63 munmap_list_free (struct munmap_list *head)
67 struct munmap_list *todo = head;
70 gdbarch_infcall_munmap (target_gdbarch (), todo->addr, todo->size);
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. */
80 munmap_listp_free_cleanup (void *headp_voidp)
82 struct munmap_list **headp = (struct munmap_list **) headp_voidp;
84 munmap_list_free (*headp);
87 /* Helper data for setup_sections. */
89 struct setup_sections_data
91 /* Size of all recent sections with matching LAST_PROT. */
94 /* First section matching LAST_PROT. */
95 asection *last_section_first;
97 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
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. */
102 CORE_ADDR last_max_alignment;
104 /* List of inferior mmap ranges where setup_sections should add its
106 struct munmap_list **munmap_list_headp;
109 /* Place all ABFD sections next to each other obeying all constraints. */
112 setup_sections (bfd *abfd, asection *sect, void *data_voidp)
114 struct setup_sections_data *data = (struct setup_sections_data *) data_voidp;
120 /* It is required by later bfd_get_relocated_section_contents. */
121 if (sect->output_section == NULL)
122 sect->output_section = sect;
124 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
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;
135 fprintf_unfiltered (gdb_stdlog,
136 "module \"%s\" section \"%s\" size %s prot %u\n",
137 bfd_get_filename (abfd),
138 bfd_get_section_name (abfd, sect),
139 paddress (target_gdbarch (),
140 bfd_get_section_size (sect)),
147 || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
152 if (data->last_size != 0)
154 addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size,
156 munmap_list_add (data->munmap_list_headp, addr, data->last_size);
158 fprintf_unfiltered (gdb_stdlog,
159 "allocated %s bytes at %s prot %u\n",
160 paddress (target_gdbarch (), data->last_size),
161 paddress (target_gdbarch (), addr),
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),
171 paddress (target_gdbarch (), data->last_max_alignment));
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));
180 data->last_section_first = sect;
181 data->last_prot = prot;
182 data->last_max_alignment = 1;
188 alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
189 data->last_max_alignment = max (data->last_max_alignment, alignment);
191 data->last_size = (data->last_size + alignment - 1) & -alignment;
193 bfd_set_section_vma (abfd, sect, data->last_size);
195 data->last_size += bfd_get_section_size (sect);
196 data->last_size = (data->last_size + alignment - 1) & -alignment;
199 /* Helper for link_callbacks callbacks vector. */
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)
206 bfd *abfd = link_info->input_bfds;
208 if (link_info->allow_multiple_definition)
210 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
211 bfd_get_filename (abfd), h->root.string);
215 /* Helper for link_callbacks callbacks vector. */
218 link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning,
219 const char *symbol, bfd *abfd, asection *section,
222 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
223 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
225 /* Maybe permit running as a module? */
229 /* Helper for link_callbacks callbacks vector. */
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)
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));
242 /* Helper for link_callbacks callbacks vector. */
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,
251 /* TRUE is required for intra-module relocations. */
255 /* Helper for link_callbacks callbacks vector. */
258 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
259 const char *message, bfd *abfd,
260 asection *section, bfd_vma address)
262 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
264 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
269 /* Helper for link_callbacks callbacks vector. */
272 link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
273 const char *name, bfd *abfd, asection *section,
276 warning (_("Compiled module \"%s\" section \"%s\": unattached "
278 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
283 /* Helper for link_callbacks callbacks vector. */
285 static void link_callbacks_einfo (const char *fmt, ...)
286 ATTRIBUTE_PRINTF (1, 2);
289 link_callbacks_einfo (const char *fmt, ...)
291 struct cleanup *cleanups;
296 str = xstrvprintf (fmt, ap);
298 cleanups = make_cleanup (xfree, str);
300 warning (_("Compile module: warning: %s"), str);
302 do_cleanups (cleanups);
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. */
309 static const struct bfd_link_callbacks link_callbacks =
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 */
322 link_callbacks_einfo, /* einfo */
325 NULL, /* override_segment_assignment */
328 struct link_hash_table_cleanup_data
334 /* Cleanup callback for struct bfd_link_info. */
337 link_hash_table_free (void *d)
339 struct link_hash_table_cleanup_data *data
340 = (struct link_hash_table_cleanup_data *) d;
342 if (data->abfd->is_linker_output)
343 (*data->abfd->link.hash->hash_table_free) (data->abfd);
344 data->abfd->link.next = data->link_next;
347 /* Relocate and store into inferior memory each section SECT of ABFD. */
350 copy_sections (bfd *abfd, asection *sect, void *data)
352 asymbol **symbol_table = (asymbol **) data;
353 bfd_byte *sect_data, *sect_data_got;
354 struct cleanup *cleanups;
355 struct bfd_link_info link_info;
356 struct bfd_link_order link_order;
357 CORE_ADDR inferior_addr;
358 struct link_hash_table_cleanup_data cleanup_data;
360 if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
361 != (SEC_ALLOC | SEC_LOAD))
364 if (bfd_get_section_size (sect) == 0)
367 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
368 cannot use as it does not report relocations to undefined symbols. */
369 memset (&link_info, 0, sizeof (link_info));
370 link_info.output_bfd = abfd;
371 link_info.input_bfds = abfd;
372 link_info.input_bfds_tail = &abfd->link.next;
374 cleanup_data.abfd = abfd;
375 cleanup_data.link_next = abfd->link.next;
377 abfd->link.next = NULL;
378 link_info.hash = bfd_link_hash_table_create (abfd);
380 cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
381 link_info.callbacks = &link_callbacks;
383 memset (&link_order, 0, sizeof (link_order));
384 link_order.next = NULL;
385 link_order.type = bfd_indirect_link_order;
386 link_order.offset = 0;
387 link_order.size = bfd_get_section_size (sect);
388 link_order.u.indirect.section = sect;
390 sect_data = (bfd_byte *) xmalloc (bfd_get_section_size (sect));
391 make_cleanup (xfree, sect_data);
393 sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
394 &link_order, sect_data,
395 FALSE, symbol_table);
397 if (sect_data_got == NULL)
398 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
399 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
400 bfd_errmsg (bfd_get_error ()));
401 gdb_assert (sect_data_got == sect_data);
403 inferior_addr = bfd_get_section_vma (abfd, sect);
404 if (0 != target_write_memory (inferior_addr, sect_data,
405 bfd_get_section_size (sect)))
406 error (_("Cannot write compiled module \"%s\" section \"%s\" "
407 "to inferior memory range %s-%s."),
408 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
409 paddress (target_gdbarch (), inferior_addr),
410 paddress (target_gdbarch (),
411 inferior_addr + bfd_get_section_size (sect)));
413 do_cleanups (cleanups);
416 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
417 symbols in OBJFILE so we can calculate how much memory to allocate
418 for the out parameter. This avoids needing a malloc in the generated
419 code. Throw an error if anything fails.
420 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
421 If it finds user tries to print an array type this function returns
422 NULL. Caller will then regenerate the code with
423 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
424 This is because __auto_type array-to-pointer type conversion of
425 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
426 preserving the array type. */
429 get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
430 enum compile_i_scope_types scope)
432 struct symbol *gdb_ptr_type_sym;
433 /* Initialize it just to avoid a GCC false warning. */
434 struct symbol *gdb_val_sym = NULL;
435 struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval;
436 /* Initialize it just to avoid a GCC false warning. */
437 const struct block *block = NULL;
438 const struct blockvector *bv;
442 bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab);
443 nblocks = BLOCKVECTOR_NBLOCKS (bv);
445 gdb_ptr_type_sym = NULL;
446 for (block_loop = 0; block_loop < nblocks; block_loop++)
448 struct symbol *function = NULL;
449 const struct block *function_block;
451 block = BLOCKVECTOR_BLOCK (bv, block_loop);
452 if (BLOCK_FUNCTION (block) != NULL)
454 gdb_val_sym = block_lookup_symbol (block, COMPILE_I_EXPR_VAL, VAR_DOMAIN);
455 if (gdb_val_sym == NULL)
458 function_block = block;
459 while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
460 && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
462 function_block = BLOCK_SUPERBLOCK (function_block);
463 function = BLOCK_FUNCTION (function_block);
464 if (function != NULL)
468 && (BLOCK_SUPERBLOCK (function_block)
469 == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
470 && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
474 if (block_loop == nblocks)
475 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
477 gdb_type = SYMBOL_TYPE (gdb_val_sym);
478 gdb_type = check_typedef (gdb_type);
480 gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
482 if (gdb_ptr_type_sym == NULL)
483 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
484 gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
485 gdb_ptr_type = check_typedef (gdb_ptr_type);
486 if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
487 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
488 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
490 if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
492 if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
493 error (_("Expected address scope in compiled module \"%s\"."),
494 objfile_name (objfile));
498 if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
499 error (_("Invalid type code %d of symbol \"%s\" "
500 "in compiled module \"%s\"."),
501 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
502 objfile_name (objfile));
504 retval = gdb_type_from_ptr;
505 switch (TYPE_CODE (gdb_type_from_ptr))
507 case TYPE_CODE_ARRAY:
508 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
513 error (_("Invalid type code %d of symbol \"%s\" "
514 "in compiled module \"%s\"."),
515 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
516 objfile_name (objfile));
518 if (!types_deeply_equal (gdb_type_from_ptr,
519 TYPE_TARGET_TYPE (gdb_type)))
520 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
521 "in compiled module \"%s\"."),
522 COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
523 objfile_name (objfile));
524 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
529 /* Fetch the type of first parameter of FUNC_SYM.
530 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
533 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
535 struct type *func_type = SYMBOL_TYPE (func_sym);
536 struct type *regsp_type, *regs_type;
538 /* No register parameter present. */
539 if (TYPE_NFIELDS (func_type) == 0)
542 regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
543 if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
544 error (_("Invalid type code %d of first parameter of function \"%s\" "
545 "in compiled module \"%s\"."),
546 TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
547 objfile_name (objfile));
549 regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
550 if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
551 error (_("Invalid type code %d of dereferenced first parameter "
552 "of function \"%s\" in compiled module \"%s\"."),
553 TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
554 objfile_name (objfile));
559 /* Store all inferior registers required by REGS_TYPE to inferior memory
560 starting at inferior address REGS_BASE. */
563 store_regs (struct type *regs_type, CORE_ADDR regs_base)
565 struct gdbarch *gdbarch = target_gdbarch ();
566 struct regcache *regcache = get_thread_regcache (inferior_ptid);
569 for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
571 const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
572 ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
573 ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
575 struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
577 ULONGEST reg_size = TYPE_LENGTH (reg_type);
579 struct value *regval;
580 CORE_ADDR inferior_addr;
582 if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
585 if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
586 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
587 reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
588 reg_offset = reg_bitpos / 8;
590 if (TYPE_CODE (reg_type) != TYPE_CODE_INT
591 && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
592 error (_("Invalid register \"%s\" type code %d"), reg_name,
593 TYPE_CODE (reg_type));
595 regnum = compile_register_name_demangle (gdbarch, reg_name);
597 regval = value_from_register (reg_type, regnum, get_current_frame ());
598 if (value_optimized_out (regval))
599 error (_("Register \"%s\" is optimized out."), reg_name);
600 if (!value_entirely_available (regval))
601 error (_("Register \"%s\" is not available."), reg_name);
603 inferior_addr = regs_base + reg_offset;
604 if (0 != target_write_memory (inferior_addr, value_contents (regval),
606 error (_("Cannot write register \"%s\" to inferior memory at %s."),
607 reg_name, paddress (gdbarch, inferior_addr));
611 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
612 Caller must fully dispose the return value by calling compile_object_run.
613 SOURCE_FILE's copy is stored into the returned object.
614 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
616 Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when
617 COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */
619 struct compile_module *
620 compile_object_load (const char *object_file, const char *source_file,
621 enum compile_i_scope_types scope, void *scope_data)
623 struct cleanup *cleanups, *cleanups_free_objfile;
625 struct setup_sections_data setup_sections_data;
626 CORE_ADDR addr, regs_addr, out_value_addr = 0;
627 struct symbol *func_sym;
628 struct type *func_type;
629 struct bound_minimal_symbol bmsym;
631 asymbol **symbol_table, **symp;
632 long number_of_symbols, missing_symbols;
633 struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
634 unsigned dptr_type_len = TYPE_LENGTH (dptr_type);
635 struct compile_module *retval;
636 struct type *regs_type, *out_value_type = NULL;
637 char *filename, **matching;
638 struct objfile *objfile;
639 int expect_parameters;
640 struct type *expect_return_type;
641 struct munmap_list *munmap_list_head = NULL;
643 filename = tilde_expand (object_file);
644 cleanups = make_cleanup (xfree, filename);
646 abfd = gdb_bfd_open (filename, gnutarget, -1);
648 error (_("\"%s\": could not open as compiled module: %s"),
649 filename, bfd_errmsg (bfd_get_error ()));
650 make_cleanup_bfd_unref (abfd);
652 if (!bfd_check_format_matches (abfd, bfd_object, &matching))
653 error (_("\"%s\": not in loadable format: %s"),
654 filename, gdb_bfd_errmsg (bfd_get_error (), matching));
656 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0)
657 error (_("\"%s\": not in object format."), filename);
659 setup_sections_data.last_size = 0;
660 setup_sections_data.last_section_first = abfd->sections;
661 setup_sections_data.last_prot = -1;
662 setup_sections_data.last_max_alignment = 1;
663 setup_sections_data.munmap_list_headp = &munmap_list_head;
664 make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
665 bfd_map_over_sections (abfd, setup_sections, &setup_sections_data);
666 setup_sections (abfd, NULL, &setup_sections_data);
668 storage_needed = bfd_get_symtab_upper_bound (abfd);
669 if (storage_needed < 0)
670 error (_("Cannot read symbols of compiled module \"%s\": %s"),
671 filename, bfd_errmsg (bfd_get_error ()));
673 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
674 "Reading symbols from ..." message for automatically generated file. */
675 objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL);
676 cleanups_free_objfile = make_cleanup_free_objfile (objfile);
678 func_sym = lookup_global_symbol_from_objfile (objfile,
679 GCC_FE_WRAPPER_FUNCTION,
681 if (func_sym == NULL)
682 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
683 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
684 func_type = SYMBOL_TYPE (func_sym);
685 if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
686 error (_("Invalid type code %d of function \"%s\" in compiled "
688 TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
689 objfile_name (objfile));
693 case COMPILE_I_SIMPLE_SCOPE:
694 expect_parameters = 1;
695 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
697 case COMPILE_I_RAW_SCOPE:
698 expect_parameters = 0;
699 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
701 case COMPILE_I_PRINT_ADDRESS_SCOPE:
702 case COMPILE_I_PRINT_VALUE_SCOPE:
703 expect_parameters = 2;
704 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
707 internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
709 if (TYPE_NFIELDS (func_type) != expect_parameters)
710 error (_("Invalid %d parameters of function \"%s\" in compiled "
712 TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
713 objfile_name (objfile));
714 if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
715 error (_("Invalid return type of function \"%s\" in compiled "
717 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
719 /* The memory may be later needed
720 by bfd_generic_get_relocated_section_contents
721 called from default_symfile_relocate. */
722 symbol_table = (asymbol **) obstack_alloc (&objfile->objfile_obstack,
724 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
725 if (number_of_symbols < 0)
726 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
727 filename, bfd_errmsg (bfd_get_error ()));
730 for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
732 asymbol *sym = *symp;
736 sym->flags = BSF_GLOBAL;
737 sym->section = bfd_abs_section_ptr;
738 if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
741 fprintf_unfiltered (gdb_stdlog,
742 "ELF symbol \"%s\" relocated to zero\n",
745 /* It seems to be a GCC bug, with -mcmodel=large there should be no
746 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
747 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
751 bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
752 switch (bmsym.minsym == NULL
753 ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
756 sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
758 fprintf_unfiltered (gdb_stdlog,
759 "ELF mst_text symbol \"%s\" relocated to %s\n",
761 paddress (target_gdbarch (), sym->value));
763 case mst_text_gnu_ifunc:
764 sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
765 BMSYMBOL_VALUE_ADDRESS (bmsym));
767 fprintf_unfiltered (gdb_stdlog,
768 "ELF mst_text_gnu_ifunc symbol \"%s\" "
771 paddress (target_gdbarch (), sym->value));
774 warning (_("Could not find symbol \"%s\" "
775 "for compiled module \"%s\"."),
776 sym->name, filename);
781 error (_("%ld symbols were missing, cannot continue."), missing_symbols);
783 bfd_map_over_sections (abfd, copy_sections, symbol_table);
785 regs_type = get_regs_type (func_sym, objfile);
786 if (regs_type == NULL)
790 /* Use read-only non-executable memory protection. */
791 regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
792 TYPE_LENGTH (regs_type),
794 gdb_assert (regs_addr != 0);
795 munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
797 fprintf_unfiltered (gdb_stdlog,
798 "allocated %s bytes at %s for registers\n",
799 paddress (target_gdbarch (),
800 TYPE_LENGTH (regs_type)),
801 paddress (target_gdbarch (), regs_addr));
802 store_regs (regs_type, regs_addr);
805 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
806 || scope == COMPILE_I_PRINT_VALUE_SCOPE)
808 out_value_type = get_out_value_type (func_sym, objfile, scope);
809 if (out_value_type == NULL)
811 do_cleanups (cleanups);
814 check_typedef (out_value_type);
815 out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
816 TYPE_LENGTH (out_value_type),
818 | GDB_MMAP_PROT_WRITE));
819 gdb_assert (out_value_addr != 0);
820 munmap_list_add (&munmap_list_head, out_value_addr,
821 TYPE_LENGTH (out_value_type));
823 fprintf_unfiltered (gdb_stdlog,
824 "allocated %s bytes at %s for printed value\n",
825 paddress (target_gdbarch (),
826 TYPE_LENGTH (out_value_type)),
827 paddress (target_gdbarch (), out_value_addr));
830 discard_cleanups (cleanups_free_objfile);
832 retval = XNEW (struct compile_module);
833 retval->objfile = objfile;
834 retval->source_file = xstrdup (source_file);
835 retval->func_sym = func_sym;
836 retval->regs_addr = regs_addr;
837 retval->scope = scope;
838 retval->scope_data = scope_data;
839 retval->out_value_type = out_value_type;
840 retval->out_value_addr = out_value_addr;
842 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
843 retval->munmap_list_head = munmap_list_head;
844 munmap_list_head = NULL;
846 do_cleanups (cleanups);