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_iw (SYMBOL_LINKAGE_NAME (function
),
463 GCC_FE_WRAPPER_FUNCTION
)
467 if (block_loop
== nblocks
)
468 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
470 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
471 gdb_type
= check_typedef (gdb_type
);
473 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
474 symbol_name_match_type::SEARCH_NAME
,
476 if (gdb_ptr_type_sym
== NULL
)
477 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
478 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
479 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
480 if (TYPE_CODE (gdb_ptr_type
) != TYPE_CODE_PTR
)
481 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
482 gdb_type_from_ptr
= check_typedef (TYPE_TARGET_TYPE (gdb_ptr_type
));
484 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
486 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
487 error (_("Expected address scope in compiled module \"%s\"."),
488 objfile_name (objfile
));
492 if (TYPE_CODE (gdb_type
) != TYPE_CODE_PTR
)
493 error (_("Invalid type code %d of symbol \"%s\" "
494 "in compiled module \"%s\"."),
495 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_VAL
,
496 objfile_name (objfile
));
498 retval
= gdb_type_from_ptr
;
499 switch (TYPE_CODE (gdb_type_from_ptr
))
501 case TYPE_CODE_ARRAY
:
502 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
507 error (_("Invalid type code %d of symbol \"%s\" "
508 "in compiled module \"%s\"."),
509 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_PTR_TYPE
,
510 objfile_name (objfile
));
512 if (!types_deeply_equal (gdb_type_from_ptr
,
513 TYPE_TARGET_TYPE (gdb_type
)))
514 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
515 "in compiled module \"%s\"."),
516 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
517 objfile_name (objfile
));
518 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
523 /* Fetch the type of first parameter of FUNC_SYM.
524 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
527 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
529 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
530 struct type
*regsp_type
, *regs_type
;
532 /* No register parameter present. */
533 if (TYPE_NFIELDS (func_type
) == 0)
536 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
537 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
538 error (_("Invalid type code %d of first parameter of function \"%s\" "
539 "in compiled module \"%s\"."),
540 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
541 objfile_name (objfile
));
543 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
544 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
545 error (_("Invalid type code %d of dereferenced first parameter "
546 "of function \"%s\" in compiled module \"%s\"."),
547 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
548 objfile_name (objfile
));
553 /* Store all inferior registers required by REGS_TYPE to inferior memory
554 starting at inferior address REGS_BASE. */
557 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
559 struct gdbarch
*gdbarch
= target_gdbarch ();
562 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
564 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
565 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
566 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
568 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
570 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
572 struct value
*regval
;
573 CORE_ADDR inferior_addr
;
575 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
578 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
579 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
580 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
581 reg_offset
= reg_bitpos
/ 8;
583 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
584 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
585 error (_("Invalid register \"%s\" type code %d"), reg_name
,
586 TYPE_CODE (reg_type
));
588 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
590 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
591 if (value_optimized_out (regval
))
592 error (_("Register \"%s\" is optimized out."), reg_name
);
593 if (!value_entirely_available (regval
))
594 error (_("Register \"%s\" is not available."), reg_name
);
596 inferior_addr
= regs_base
+ reg_offset
;
597 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
599 error (_("Cannot write register \"%s\" to inferior memory at %s."),
600 reg_name
, paddress (gdbarch
, inferior_addr
));
604 /* Load the object file specified in FILE_NAMES into inferior memory.
605 Throw an error otherwise. Caller must fully dispose the return
606 value by calling compile_object_run. Returns NULL only for
607 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
608 should have been used instead. */
610 struct compile_module
*
611 compile_object_load (const compile_file_names
&file_names
,
612 enum compile_i_scope_types scope
, void *scope_data
)
614 struct cleanup
*cleanups
;
615 struct setup_sections_data setup_sections_data
;
616 CORE_ADDR regs_addr
, out_value_addr
= 0;
617 struct symbol
*func_sym
;
618 struct type
*func_type
;
619 struct bound_minimal_symbol bmsym
;
621 asymbol
**symbol_table
, **symp
;
622 long number_of_symbols
, missing_symbols
;
623 struct compile_module
*retval
;
624 struct type
*regs_type
, *out_value_type
= NULL
;
626 struct objfile
*objfile
;
627 int expect_parameters
;
628 struct type
*expect_return_type
;
629 struct munmap_list
*munmap_list_head
= NULL
;
631 gdb::unique_xmalloc_ptr
<char> filename
632 (tilde_expand (file_names
.object_file ()));
634 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
636 error (_("\"%s\": could not open as compiled module: %s"),
637 filename
.get (), bfd_errmsg (bfd_get_error ()));
639 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
640 error (_("\"%s\": not in loadable format: %s"),
641 filename
.get (), gdb_bfd_errmsg (bfd_get_error (), matching
));
643 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
644 error (_("\"%s\": not in object format."), filename
.get ());
646 setup_sections_data
.last_size
= 0;
647 setup_sections_data
.last_section_first
= abfd
->sections
;
648 setup_sections_data
.last_prot
= -1;
649 setup_sections_data
.last_max_alignment
= 1;
650 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
651 cleanups
= make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
652 bfd_map_over_sections (abfd
.get (), setup_sections
, &setup_sections_data
);
653 setup_sections (abfd
.get (), NULL
, &setup_sections_data
);
655 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
656 if (storage_needed
< 0)
657 error (_("Cannot read symbols of compiled module \"%s\": %s"),
658 filename
.get (), bfd_errmsg (bfd_get_error ()));
660 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
661 "Reading symbols from ..." message for automatically generated file. */
662 std::unique_ptr
<struct objfile
> objfile_holder
663 (symbol_file_add_from_bfd (abfd
.get (), filename
.get (),
665 objfile
= objfile_holder
.get ();
667 func_sym
= lookup_global_symbol_from_objfile (objfile
,
668 GCC_FE_WRAPPER_FUNCTION
,
670 if (func_sym
== NULL
)
671 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
672 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
673 func_type
= SYMBOL_TYPE (func_sym
);
674 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
675 error (_("Invalid type code %d of function \"%s\" in compiled "
677 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
678 objfile_name (objfile
));
682 case COMPILE_I_SIMPLE_SCOPE
:
683 expect_parameters
= 1;
684 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
686 case COMPILE_I_RAW_SCOPE
:
687 expect_parameters
= 0;
688 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
690 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
691 case COMPILE_I_PRINT_VALUE_SCOPE
:
692 expect_parameters
= 2;
693 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
696 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
698 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
699 error (_("Invalid %d parameters of function \"%s\" in compiled "
701 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
702 objfile_name (objfile
));
703 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
704 error (_("Invalid return type of function \"%s\" in compiled "
706 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
708 /* The memory may be later needed
709 by bfd_generic_get_relocated_section_contents
710 called from default_symfile_relocate. */
711 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
713 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
714 if (number_of_symbols
< 0)
715 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
716 filename
.get (), bfd_errmsg (bfd_get_error ()));
719 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
721 asymbol
*sym
= *symp
;
725 sym
->flags
= BSF_GLOBAL
;
726 sym
->section
= bfd_abs_section_ptr
;
727 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
730 fprintf_unfiltered (gdb_stdlog
,
731 "ELF symbol \"%s\" relocated to zero\n",
734 /* It seems to be a GCC bug, with -mcmodel=large there should be no
735 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
736 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
740 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
741 switch (bmsym
.minsym
== NULL
742 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
747 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
749 fprintf_unfiltered (gdb_stdlog
,
750 "ELF mst_text symbol \"%s\" relocated to %s\n",
752 paddress (target_gdbarch (), sym
->value
));
754 case mst_text_gnu_ifunc
:
755 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
756 BMSYMBOL_VALUE_ADDRESS (bmsym
));
758 fprintf_unfiltered (gdb_stdlog
,
759 "ELF mst_text_gnu_ifunc symbol \"%s\" "
762 paddress (target_gdbarch (), sym
->value
));
765 warning (_("Could not find symbol \"%s\" "
766 "for compiled module \"%s\"."),
767 sym
->name
, filename
.get ());
772 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
774 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
776 regs_type
= get_regs_type (func_sym
, objfile
);
777 if (regs_type
== NULL
)
781 /* Use read-only non-executable memory protection. */
782 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
783 TYPE_LENGTH (regs_type
),
785 gdb_assert (regs_addr
!= 0);
786 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
788 fprintf_unfiltered (gdb_stdlog
,
789 "allocated %s bytes at %s for registers\n",
790 paddress (target_gdbarch (),
791 TYPE_LENGTH (regs_type
)),
792 paddress (target_gdbarch (), regs_addr
));
793 store_regs (regs_type
, regs_addr
);
796 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
797 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
799 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
800 if (out_value_type
== NULL
)
802 do_cleanups (cleanups
);
805 check_typedef (out_value_type
);
806 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
807 TYPE_LENGTH (out_value_type
),
809 | GDB_MMAP_PROT_WRITE
));
810 gdb_assert (out_value_addr
!= 0);
811 munmap_list_add (&munmap_list_head
, out_value_addr
,
812 TYPE_LENGTH (out_value_type
));
814 fprintf_unfiltered (gdb_stdlog
,
815 "allocated %s bytes at %s for printed value\n",
816 paddress (target_gdbarch (),
817 TYPE_LENGTH (out_value_type
)),
818 paddress (target_gdbarch (), out_value_addr
));
821 retval
= XNEW (struct compile_module
);
822 retval
->objfile
= objfile_holder
.release ();
823 retval
->source_file
= xstrdup (file_names
.source_file ());
824 retval
->func_sym
= func_sym
;
825 retval
->regs_addr
= regs_addr
;
826 retval
->scope
= scope
;
827 retval
->scope_data
= scope_data
;
828 retval
->out_value_type
= out_value_type
;
829 retval
->out_value_addr
= out_value_addr
;
831 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
832 retval
->munmap_list_head
= munmap_list_head
;
833 munmap_list_head
= NULL
;
835 do_cleanups (cleanups
);