1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2018 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"
31 #include "gdbthread.h"
34 #include "arch-utils.h"
37 /* Track inferior memory reserved by inferior mmap. */
41 struct munmap_list *next;
45 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
46 HEADP. *HEADP needs to be initialized to NULL. */
49 munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
51 struct munmap_list *head_new = XNEW (struct munmap_list);
53 head_new->next = *headp;
55 head_new->addr = addr;
56 head_new->size = size;
59 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first
60 element of the list, it can be NULL. After calling this function
61 HEAD pointer is invalid and the possible list needs to be
62 reinitialized by caller to NULL. */
65 munmap_list_free (struct munmap_list *head)
69 struct munmap_list *todo = head;
72 gdbarch_infcall_munmap (target_gdbarch (), todo->addr, todo->size);
77 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to
78 munmap_list_free this function's parameter is a pointer to the first
79 list element pointer. */
82 munmap_listp_free_cleanup (void *headp_voidp)
84 struct munmap_list **headp = (struct munmap_list **) headp_voidp;
86 munmap_list_free (*headp);
89 /* Helper data for setup_sections. */
91 struct setup_sections_data
93 /* Size of all recent sections with matching LAST_PROT. */
96 /* First section matching LAST_PROT. */
97 asection *last_section_first;
99 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
102 /* Maximum of alignments of all sections matching LAST_PROT.
103 This value is always at least 1. This value is always a power of 2. */
104 CORE_ADDR last_max_alignment;
106 /* List of inferior mmap ranges where setup_sections should add its
108 struct munmap_list **munmap_list_headp;
111 /* Place all ABFD sections next to each other obeying all constraints. */
114 setup_sections (bfd *abfd, asection *sect, void *data_voidp)
116 struct setup_sections_data *data = (struct setup_sections_data *) data_voidp;
122 /* It is required by later bfd_get_relocated_section_contents. */
123 if (sect->output_section == NULL)
124 sect->output_section = sect;
126 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
129 /* Make the memory always readable. */
130 prot = GDB_MMAP_PROT_READ;
131 if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0)
132 prot |= GDB_MMAP_PROT_WRITE;
133 if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0)
134 prot |= GDB_MMAP_PROT_EXEC;
137 fprintf_unfiltered (gdb_stdlog,
138 "module \"%s\" section \"%s\" size %s prot %u\n",
139 bfd_get_filename (abfd),
140 bfd_get_section_name (abfd, sect),
141 paddress (target_gdbarch (),
142 bfd_get_section_size (sect)),
149 || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
154 if (data->last_size != 0)
156 addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size,
158 munmap_list_add (data->munmap_list_headp, addr, data->last_size);
160 fprintf_unfiltered (gdb_stdlog,
161 "allocated %s bytes at %s prot %u\n",
162 paddress (target_gdbarch (), data->last_size),
163 paddress (target_gdbarch (), addr),
169 if ((addr & (data->last_max_alignment - 1)) != 0)
170 error (_("Inferior compiled module address %s "
171 "is not aligned to BFD required %s."),
172 paddress (target_gdbarch (), addr),
173 paddress (target_gdbarch (), data->last_max_alignment));
175 for (sect_iter = data->last_section_first; sect_iter != sect;
176 sect_iter = sect_iter->next)
177 if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0)
178 bfd_set_section_vma (abfd, sect_iter,
179 addr + bfd_get_section_vma (abfd, sect_iter));
182 data->last_section_first = sect;
183 data->last_prot = prot;
184 data->last_max_alignment = 1;
190 alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
191 data->last_max_alignment = std::max (data->last_max_alignment, alignment);
193 data->last_size = (data->last_size + alignment - 1) & -alignment;
195 bfd_set_section_vma (abfd, sect, data->last_size);
197 data->last_size += bfd_get_section_size (sect);
198 data->last_size = (data->last_size + alignment - 1) & -alignment;
201 /* Helper for link_callbacks callbacks vector. */
204 link_callbacks_multiple_definition (struct bfd_link_info *link_info,
205 struct bfd_link_hash_entry *h, bfd *nbfd,
206 asection *nsec, bfd_vma nval)
208 bfd *abfd = link_info->input_bfds;
210 if (link_info->allow_multiple_definition)
212 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
213 bfd_get_filename (abfd), h->root.string);
216 /* Helper for link_callbacks callbacks vector. */
219 link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning,
220 const char *symbol, bfd *abfd, asection *section,
223 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
224 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
228 /* Helper for link_callbacks callbacks vector. */
231 link_callbacks_undefined_symbol (struct bfd_link_info *link_info,
232 const char *name, bfd *abfd, asection *section,
233 bfd_vma address, bfd_boolean is_fatal)
235 warning (_("Cannot resolve relocation to \"%s\" "
236 "from compiled module \"%s\" section \"%s\"."),
237 name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
240 /* Helper for link_callbacks callbacks vector. */
243 link_callbacks_reloc_overflow (struct bfd_link_info *link_info,
244 struct bfd_link_hash_entry *entry,
245 const char *name, const char *reloc_name,
246 bfd_vma addend, bfd *abfd, asection *section,
251 /* Helper for link_callbacks callbacks vector. */
254 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
255 const char *message, bfd *abfd,
256 asection *section, bfd_vma address)
258 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
260 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
264 /* Helper for link_callbacks callbacks vector. */
267 link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
268 const char *name, bfd *abfd, asection *section,
271 warning (_("Compiled module \"%s\" section \"%s\": unattached "
273 bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
277 /* Helper for link_callbacks callbacks vector. */
279 static void link_callbacks_einfo (const char *fmt, ...)
280 ATTRIBUTE_PRINTF (1, 2);
283 link_callbacks_einfo (const char *fmt, ...)
288 std::string str = string_vprintf (fmt, ap);
291 warning (_("Compile module: warning: %s"), str.c_str ());
294 /* Helper for bfd_get_relocated_section_contents.
295 Only these symbols are set by bfd_simple_get_relocated_section_contents
296 but bfd/ seems to use even the NULL ones without checking them first. */
298 static const struct bfd_link_callbacks link_callbacks =
300 NULL, /* add_archive_element */
301 link_callbacks_multiple_definition, /* multiple_definition */
302 NULL, /* multiple_common */
303 NULL, /* add_to_set */
304 NULL, /* constructor */
305 link_callbacks_warning, /* warning */
306 link_callbacks_undefined_symbol, /* undefined_symbol */
307 link_callbacks_reloc_overflow, /* reloc_overflow */
308 link_callbacks_reloc_dangerous, /* reloc_dangerous */
309 link_callbacks_unattached_reloc, /* unattached_reloc */
311 link_callbacks_einfo, /* einfo */
314 NULL, /* override_segment_assignment */
317 struct link_hash_table_cleanup_data
323 /* Cleanup callback for struct bfd_link_info. */
326 link_hash_table_free (void *d)
328 struct link_hash_table_cleanup_data *data
329 = (struct link_hash_table_cleanup_data *) d;
331 if (data->abfd->is_linker_output)
332 (*data->abfd->link.hash->hash_table_free) (data->abfd);
333 data->abfd->link.next = data->link_next;
336 /* Relocate and store into inferior memory each section SECT of ABFD. */
339 copy_sections (bfd *abfd, asection *sect, void *data)
341 asymbol **symbol_table = (asymbol **) data;
342 bfd_byte *sect_data, *sect_data_got;
343 struct cleanup *cleanups;
344 struct bfd_link_info link_info;
345 struct bfd_link_order link_order;
346 CORE_ADDR inferior_addr;
347 struct link_hash_table_cleanup_data cleanup_data;
349 if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
350 != (SEC_ALLOC | SEC_LOAD))
353 if (bfd_get_section_size (sect) == 0)
356 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
357 cannot use as it does not report relocations to undefined symbols. */
358 memset (&link_info, 0, sizeof (link_info));
359 link_info.output_bfd = abfd;
360 link_info.input_bfds = abfd;
361 link_info.input_bfds_tail = &abfd->link.next;
363 cleanup_data.abfd = abfd;
364 cleanup_data.link_next = abfd->link.next;
366 abfd->link.next = NULL;
367 link_info.hash = bfd_link_hash_table_create (abfd);
369 cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
370 link_info.callbacks = &link_callbacks;
372 memset (&link_order, 0, sizeof (link_order));
373 link_order.next = NULL;
374 link_order.type = bfd_indirect_link_order;
375 link_order.offset = 0;
376 link_order.size = bfd_get_section_size (sect);
377 link_order.u.indirect.section = sect;
379 sect_data = (bfd_byte *) xmalloc (bfd_get_section_size (sect));
380 make_cleanup (xfree, sect_data);
382 sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
383 &link_order, sect_data,
384 FALSE, symbol_table);
386 if (sect_data_got == NULL)
387 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
388 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
389 bfd_errmsg (bfd_get_error ()));
390 gdb_assert (sect_data_got == sect_data);
392 inferior_addr = bfd_get_section_vma (abfd, sect);
393 if (0 != target_write_memory (inferior_addr, sect_data,
394 bfd_get_section_size (sect)))
395 error (_("Cannot write compiled module \"%s\" section \"%s\" "
396 "to inferior memory range %s-%s."),
397 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
398 paddress (target_gdbarch (), inferior_addr),
399 paddress (target_gdbarch (),
400 inferior_addr + bfd_get_section_size (sect)));
402 do_cleanups (cleanups);
405 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
406 symbols in OBJFILE so we can calculate how much memory to allocate
407 for the out parameter. This avoids needing a malloc in the generated
408 code. Throw an error if anything fails.
409 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
410 If it finds user tries to print an array type this function returns
411 NULL. Caller will then regenerate the code with
412 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
413 This is because __auto_type array-to-pointer type conversion of
414 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
415 preserving the array type. */
418 get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
419 enum compile_i_scope_types scope)
421 struct symbol *gdb_ptr_type_sym;
422 /* Initialize it just to avoid a GCC false warning. */
423 struct symbol *gdb_val_sym = NULL;
424 struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval;
425 /* Initialize it just to avoid a GCC false warning. */
426 const struct block *block = NULL;
427 const struct blockvector *bv;
431 bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab);
432 nblocks = BLOCKVECTOR_NBLOCKS (bv);
434 gdb_ptr_type_sym = NULL;
435 for (block_loop = 0; block_loop < nblocks; block_loop++)
437 struct symbol *function = NULL;
438 const struct block *function_block;
440 block = BLOCKVECTOR_BLOCK (bv, block_loop);
441 if (BLOCK_FUNCTION (block) != NULL)
443 gdb_val_sym = block_lookup_symbol (block,
445 symbol_name_match_type::SEARCH_NAME,
447 if (gdb_val_sym == NULL)
450 function_block = block;
451 while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
452 && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
454 function_block = BLOCK_SUPERBLOCK (function_block);
455 function = BLOCK_FUNCTION (function_block);
456 if (function != NULL)
460 && (BLOCK_SUPERBLOCK (function_block)
461 == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
462 && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
466 if (block_loop == nblocks)
467 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
469 gdb_type = SYMBOL_TYPE (gdb_val_sym);
470 gdb_type = check_typedef (gdb_type);
472 gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
473 symbol_name_match_type::SEARCH_NAME,
475 if (gdb_ptr_type_sym == NULL)
476 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
477 gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
478 gdb_ptr_type = check_typedef (gdb_ptr_type);
479 if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
480 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
481 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
483 if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
485 if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
486 error (_("Expected address scope in compiled module \"%s\"."),
487 objfile_name (objfile));
491 if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
492 error (_("Invalid type code %d of symbol \"%s\" "
493 "in compiled module \"%s\"."),
494 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
495 objfile_name (objfile));
497 retval = gdb_type_from_ptr;
498 switch (TYPE_CODE (gdb_type_from_ptr))
500 case TYPE_CODE_ARRAY:
501 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
506 error (_("Invalid type code %d of symbol \"%s\" "
507 "in compiled module \"%s\"."),
508 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
509 objfile_name (objfile));
511 if (!types_deeply_equal (gdb_type_from_ptr,
512 TYPE_TARGET_TYPE (gdb_type)))
513 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
514 "in compiled module \"%s\"."),
515 COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
516 objfile_name (objfile));
517 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
522 /* Fetch the type of first parameter of FUNC_SYM.
523 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
526 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
528 struct type *func_type = SYMBOL_TYPE (func_sym);
529 struct type *regsp_type, *regs_type;
531 /* No register parameter present. */
532 if (TYPE_NFIELDS (func_type) == 0)
535 regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
536 if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
537 error (_("Invalid type code %d of first parameter of function \"%s\" "
538 "in compiled module \"%s\"."),
539 TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
540 objfile_name (objfile));
542 regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
543 if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
544 error (_("Invalid type code %d of dereferenced first parameter "
545 "of function \"%s\" in compiled module \"%s\"."),
546 TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
547 objfile_name (objfile));
552 /* Store all inferior registers required by REGS_TYPE to inferior memory
553 starting at inferior address REGS_BASE. */
556 store_regs (struct type *regs_type, CORE_ADDR regs_base)
558 struct gdbarch *gdbarch = target_gdbarch ();
561 for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
563 const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
564 ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
565 ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
567 struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
569 ULONGEST reg_size = TYPE_LENGTH (reg_type);
571 struct value *regval;
572 CORE_ADDR inferior_addr;
574 if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
577 if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
578 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
579 reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
580 reg_offset = reg_bitpos / 8;
582 if (TYPE_CODE (reg_type) != TYPE_CODE_INT
583 && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
584 error (_("Invalid register \"%s\" type code %d"), reg_name,
585 TYPE_CODE (reg_type));
587 regnum = compile_register_name_demangle (gdbarch, reg_name);
589 regval = value_from_register (reg_type, regnum, get_current_frame ());
590 if (value_optimized_out (regval))
591 error (_("Register \"%s\" is optimized out."), reg_name);
592 if (!value_entirely_available (regval))
593 error (_("Register \"%s\" is not available."), reg_name);
595 inferior_addr = regs_base + reg_offset;
596 if (0 != target_write_memory (inferior_addr, value_contents (regval),
598 error (_("Cannot write register \"%s\" to inferior memory at %s."),
599 reg_name, paddress (gdbarch, inferior_addr));
603 /* Load the object file specified in FILE_NAMES into inferior memory.
604 Throw an error otherwise. Caller must fully dispose the return
605 value by calling compile_object_run. Returns NULL only for
606 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
607 should have been used instead. */
609 struct compile_module *
610 compile_object_load (const compile_file_names &file_names,
611 enum compile_i_scope_types scope, void *scope_data)
613 struct cleanup *cleanups;
614 struct setup_sections_data setup_sections_data;
615 CORE_ADDR regs_addr, out_value_addr = 0;
616 struct symbol *func_sym;
617 struct type *func_type;
618 struct bound_minimal_symbol bmsym;
620 asymbol **symbol_table, **symp;
621 long number_of_symbols, missing_symbols;
622 struct compile_module *retval;
623 struct type *regs_type, *out_value_type = NULL;
625 struct objfile *objfile;
626 int expect_parameters;
627 struct type *expect_return_type;
628 struct munmap_list *munmap_list_head = NULL;
630 gdb::unique_xmalloc_ptr<char> filename
631 (tilde_expand (file_names.object_file ()));
633 gdb_bfd_ref_ptr abfd (gdb_bfd_open (filename.get (), gnutarget, -1));
635 error (_("\"%s\": could not open as compiled module: %s"),
636 filename.get (), bfd_errmsg (bfd_get_error ()));
638 if (!bfd_check_format_matches (abfd.get (), bfd_object, &matching))
639 error (_("\"%s\": not in loadable format: %s"),
640 filename.get (), gdb_bfd_errmsg (bfd_get_error (), matching));
642 if ((bfd_get_file_flags (abfd.get ()) & (EXEC_P | DYNAMIC)) != 0)
643 error (_("\"%s\": not in object format."), filename.get ());
645 setup_sections_data.last_size = 0;
646 setup_sections_data.last_section_first = abfd->sections;
647 setup_sections_data.last_prot = -1;
648 setup_sections_data.last_max_alignment = 1;
649 setup_sections_data.munmap_list_headp = &munmap_list_head;
650 cleanups = make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
651 bfd_map_over_sections (abfd.get (), setup_sections, &setup_sections_data);
652 setup_sections (abfd.get (), NULL, &setup_sections_data);
654 storage_needed = bfd_get_symtab_upper_bound (abfd.get ());
655 if (storage_needed < 0)
656 error (_("Cannot read symbols of compiled module \"%s\": %s"),
657 filename.get (), bfd_errmsg (bfd_get_error ()));
659 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
660 "Reading symbols from ..." message for automatically generated file. */
661 std::unique_ptr<struct objfile> objfile_holder
662 (symbol_file_add_from_bfd (abfd.get (), filename.get (),
664 objfile = objfile_holder.get ();
666 func_sym = lookup_global_symbol_from_objfile (objfile,
667 GCC_FE_WRAPPER_FUNCTION,
669 if (func_sym == NULL)
670 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
671 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
672 func_type = SYMBOL_TYPE (func_sym);
673 if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
674 error (_("Invalid type code %d of function \"%s\" in compiled "
676 TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
677 objfile_name (objfile));
681 case COMPILE_I_SIMPLE_SCOPE:
682 expect_parameters = 1;
683 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
685 case COMPILE_I_RAW_SCOPE:
686 expect_parameters = 0;
687 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
689 case COMPILE_I_PRINT_ADDRESS_SCOPE:
690 case COMPILE_I_PRINT_VALUE_SCOPE:
691 expect_parameters = 2;
692 expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
695 internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
697 if (TYPE_NFIELDS (func_type) != expect_parameters)
698 error (_("Invalid %d parameters of function \"%s\" in compiled "
700 TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
701 objfile_name (objfile));
702 if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
703 error (_("Invalid return type of function \"%s\" in compiled "
705 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
707 /* The memory may be later needed
708 by bfd_generic_get_relocated_section_contents
709 called from default_symfile_relocate. */
710 symbol_table = (asymbol **) obstack_alloc (&objfile->objfile_obstack,
712 number_of_symbols = bfd_canonicalize_symtab (abfd.get (), symbol_table);
713 if (number_of_symbols < 0)
714 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
715 filename.get (), bfd_errmsg (bfd_get_error ()));
718 for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
720 asymbol *sym = *symp;
724 sym->flags = BSF_GLOBAL;
725 sym->section = bfd_abs_section_ptr;
726 if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
729 fprintf_unfiltered (gdb_stdlog,
730 "ELF symbol \"%s\" relocated to zero\n",
733 /* It seems to be a GCC bug, with -mcmodel=large there should be no
734 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
735 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
739 bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
740 switch (bmsym.minsym == NULL
741 ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
744 sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
746 fprintf_unfiltered (gdb_stdlog,
747 "ELF mst_text symbol \"%s\" relocated to %s\n",
749 paddress (target_gdbarch (), sym->value));
751 case mst_text_gnu_ifunc:
752 sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
753 BMSYMBOL_VALUE_ADDRESS (bmsym));
755 fprintf_unfiltered (gdb_stdlog,
756 "ELF mst_text_gnu_ifunc symbol \"%s\" "
759 paddress (target_gdbarch (), sym->value));
762 warning (_("Could not find symbol \"%s\" "
763 "for compiled module \"%s\"."),
764 sym->name, filename.get ());
769 error (_("%ld symbols were missing, cannot continue."), missing_symbols);
771 bfd_map_over_sections (abfd.get (), copy_sections, symbol_table);
773 regs_type = get_regs_type (func_sym, objfile);
774 if (regs_type == NULL)
778 /* Use read-only non-executable memory protection. */
779 regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
780 TYPE_LENGTH (regs_type),
782 gdb_assert (regs_addr != 0);
783 munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
785 fprintf_unfiltered (gdb_stdlog,
786 "allocated %s bytes at %s for registers\n",
787 paddress (target_gdbarch (),
788 TYPE_LENGTH (regs_type)),
789 paddress (target_gdbarch (), regs_addr));
790 store_regs (regs_type, regs_addr);
793 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
794 || scope == COMPILE_I_PRINT_VALUE_SCOPE)
796 out_value_type = get_out_value_type (func_sym, objfile, scope);
797 if (out_value_type == NULL)
799 do_cleanups (cleanups);
802 check_typedef (out_value_type);
803 out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
804 TYPE_LENGTH (out_value_type),
806 | GDB_MMAP_PROT_WRITE));
807 gdb_assert (out_value_addr != 0);
808 munmap_list_add (&munmap_list_head, out_value_addr,
809 TYPE_LENGTH (out_value_type));
811 fprintf_unfiltered (gdb_stdlog,
812 "allocated %s bytes at %s for printed value\n",
813 paddress (target_gdbarch (),
814 TYPE_LENGTH (out_value_type)),
815 paddress (target_gdbarch (), out_value_addr));
818 retval = XNEW (struct compile_module);
819 retval->objfile = objfile_holder.release ();
820 retval->source_file = xstrdup (file_names.source_file ());
821 retval->func_sym = func_sym;
822 retval->regs_addr = regs_addr;
823 retval->scope = scope;
824 retval->scope_data = scope_data;
825 retval->out_value_type = out_value_type;
826 retval->out_value_addr = out_value_addr;
828 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
829 retval->munmap_list_head = munmap_list_head;
830 munmap_list_head = NULL;
832 do_cleanups (cleanups);