1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2017 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"
36 /* Track inferior memory reserved by inferior mmap. */
40 struct munmap_list
*next
;
44 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
45 HEADP. *HEADP needs to be initialized to NULL. */
48 munmap_list_add (struct munmap_list
**headp
, CORE_ADDR addr
, CORE_ADDR size
)
50 struct munmap_list
*head_new
= XNEW (struct munmap_list
);
52 head_new
->next
= *headp
;
54 head_new
->addr
= addr
;
55 head_new
->size
= size
;
58 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first
59 element of the list, it can be NULL. After calling this function
60 HEAD pointer is invalid and the possible list needs to be
61 reinitialized by caller to NULL. */
64 munmap_list_free (struct munmap_list
*head
)
68 struct munmap_list
*todo
= head
;
71 gdbarch_infcall_munmap (target_gdbarch (), todo
->addr
, todo
->size
);
76 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to
77 munmap_list_free this function's parameter is a pointer to the first
78 list element pointer. */
81 munmap_listp_free_cleanup (void *headp_voidp
)
83 struct munmap_list
**headp
= (struct munmap_list
**) headp_voidp
;
85 munmap_list_free (*headp
);
88 /* Helper data for setup_sections. */
90 struct setup_sections_data
92 /* Size of all recent sections with matching LAST_PROT. */
95 /* First section matching LAST_PROT. */
96 asection
*last_section_first
;
98 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
101 /* Maximum of alignments of all sections matching LAST_PROT.
102 This value is always at least 1. This value is always a power of 2. */
103 CORE_ADDR last_max_alignment
;
105 /* List of inferior mmap ranges where setup_sections should add its
107 struct munmap_list
**munmap_list_headp
;
110 /* Place all ABFD sections next to each other obeying all constraints. */
113 setup_sections (bfd
*abfd
, asection
*sect
, void *data_voidp
)
115 struct setup_sections_data
*data
= (struct setup_sections_data
*) data_voidp
;
121 /* It is required by later bfd_get_relocated_section_contents. */
122 if (sect
->output_section
== NULL
)
123 sect
->output_section
= sect
;
125 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
128 /* Make the memory always readable. */
129 prot
= GDB_MMAP_PROT_READ
;
130 if ((bfd_get_section_flags (abfd
, sect
) & SEC_READONLY
) == 0)
131 prot
|= GDB_MMAP_PROT_WRITE
;
132 if ((bfd_get_section_flags (abfd
, sect
) & SEC_CODE
) != 0)
133 prot
|= GDB_MMAP_PROT_EXEC
;
136 fprintf_unfiltered (gdb_stdlog
,
137 "module \"%s\" section \"%s\" size %s prot %u\n",
138 bfd_get_filename (abfd
),
139 bfd_get_section_name (abfd
, sect
),
140 paddress (target_gdbarch (),
141 bfd_get_section_size (sect
)),
148 || (data
->last_prot
!= prot
&& bfd_get_section_size (sect
) != 0))
153 if (data
->last_size
!= 0)
155 addr
= gdbarch_infcall_mmap (target_gdbarch (), data
->last_size
,
157 munmap_list_add (data
->munmap_list_headp
, addr
, data
->last_size
);
159 fprintf_unfiltered (gdb_stdlog
,
160 "allocated %s bytes at %s prot %u\n",
161 paddress (target_gdbarch (), data
->last_size
),
162 paddress (target_gdbarch (), addr
),
168 if ((addr
& (data
->last_max_alignment
- 1)) != 0)
169 error (_("Inferior compiled module address %s "
170 "is not aligned to BFD required %s."),
171 paddress (target_gdbarch (), addr
),
172 paddress (target_gdbarch (), data
->last_max_alignment
));
174 for (sect_iter
= data
->last_section_first
; sect_iter
!= sect
;
175 sect_iter
= sect_iter
->next
)
176 if ((bfd_get_section_flags (abfd
, sect_iter
) & SEC_ALLOC
) != 0)
177 bfd_set_section_vma (abfd
, sect_iter
,
178 addr
+ bfd_get_section_vma (abfd
, sect_iter
));
181 data
->last_section_first
= sect
;
182 data
->last_prot
= prot
;
183 data
->last_max_alignment
= 1;
189 alignment
= ((CORE_ADDR
) 1) << bfd_get_section_alignment (abfd
, sect
);
190 data
->last_max_alignment
= std::max (data
->last_max_alignment
, alignment
);
192 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
194 bfd_set_section_vma (abfd
, sect
, data
->last_size
);
196 data
->last_size
+= bfd_get_section_size (sect
);
197 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
200 /* Helper for link_callbacks callbacks vector. */
203 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
204 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
205 asection
*nsec
, bfd_vma nval
)
207 bfd
*abfd
= link_info
->input_bfds
;
209 if (link_info
->allow_multiple_definition
)
211 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
212 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
),
227 /* Helper for link_callbacks callbacks vector. */
230 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
231 const char *name
, bfd
*abfd
, asection
*section
,
232 bfd_vma address
, bfd_boolean is_fatal
)
234 warning (_("Cannot resolve relocation to \"%s\" "
235 "from compiled module \"%s\" section \"%s\"."),
236 name
, bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
239 /* Helper for link_callbacks callbacks vector. */
242 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
243 struct bfd_link_hash_entry
*entry
,
244 const char *name
, const char *reloc_name
,
245 bfd_vma addend
, bfd
*abfd
, asection
*section
,
250 /* Helper for link_callbacks callbacks vector. */
253 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
254 const char *message
, bfd
*abfd
,
255 asection
*section
, bfd_vma address
)
257 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
259 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
263 /* Helper for link_callbacks callbacks vector. */
266 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
267 const char *name
, bfd
*abfd
, asection
*section
,
270 warning (_("Compiled module \"%s\" section \"%s\": unattached "
272 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
276 /* Helper for link_callbacks callbacks vector. */
278 static void link_callbacks_einfo (const char *fmt
, ...)
279 ATTRIBUTE_PRINTF (1, 2);
282 link_callbacks_einfo (const char *fmt
, ...)
287 std::string str
= string_vprintf (fmt
, ap
);
290 warning (_("Compile module: warning: %s"), str
.c_str ());
293 /* Helper for bfd_get_relocated_section_contents.
294 Only these symbols are set by bfd_simple_get_relocated_section_contents
295 but bfd/ seems to use even the NULL ones without checking them first. */
297 static const struct bfd_link_callbacks link_callbacks
=
299 NULL
, /* add_archive_element */
300 link_callbacks_multiple_definition
, /* multiple_definition */
301 NULL
, /* multiple_common */
302 NULL
, /* add_to_set */
303 NULL
, /* constructor */
304 link_callbacks_warning
, /* warning */
305 link_callbacks_undefined_symbol
, /* undefined_symbol */
306 link_callbacks_reloc_overflow
, /* reloc_overflow */
307 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
308 link_callbacks_unattached_reloc
, /* unattached_reloc */
310 link_callbacks_einfo
, /* einfo */
313 NULL
, /* override_segment_assignment */
316 struct link_hash_table_cleanup_data
322 /* Cleanup callback for struct bfd_link_info. */
325 link_hash_table_free (void *d
)
327 struct link_hash_table_cleanup_data
*data
328 = (struct link_hash_table_cleanup_data
*) d
;
330 if (data
->abfd
->is_linker_output
)
331 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
332 data
->abfd
->link
.next
= data
->link_next
;
335 /* Relocate and store into inferior memory each section SECT of ABFD. */
338 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
340 asymbol
**symbol_table
= (asymbol
**) data
;
341 bfd_byte
*sect_data
, *sect_data_got
;
342 struct cleanup
*cleanups
;
343 struct bfd_link_info link_info
;
344 struct bfd_link_order link_order
;
345 CORE_ADDR inferior_addr
;
346 struct link_hash_table_cleanup_data cleanup_data
;
348 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
349 != (SEC_ALLOC
| SEC_LOAD
))
352 if (bfd_get_section_size (sect
) == 0)
355 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
356 cannot use as it does not report relocations to undefined symbols. */
357 memset (&link_info
, 0, sizeof (link_info
));
358 link_info
.output_bfd
= abfd
;
359 link_info
.input_bfds
= abfd
;
360 link_info
.input_bfds_tail
= &abfd
->link
.next
;
362 cleanup_data
.abfd
= abfd
;
363 cleanup_data
.link_next
= abfd
->link
.next
;
365 abfd
->link
.next
= NULL
;
366 link_info
.hash
= bfd_link_hash_table_create (abfd
);
368 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
369 link_info
.callbacks
= &link_callbacks
;
371 memset (&link_order
, 0, sizeof (link_order
));
372 link_order
.next
= NULL
;
373 link_order
.type
= bfd_indirect_link_order
;
374 link_order
.offset
= 0;
375 link_order
.size
= bfd_get_section_size (sect
);
376 link_order
.u
.indirect
.section
= sect
;
378 sect_data
= (bfd_byte
*) xmalloc (bfd_get_section_size (sect
));
379 make_cleanup (xfree
, sect_data
);
381 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
382 &link_order
, sect_data
,
383 FALSE
, symbol_table
);
385 if (sect_data_got
== NULL
)
386 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
387 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
388 bfd_errmsg (bfd_get_error ()));
389 gdb_assert (sect_data_got
== sect_data
);
391 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
392 if (0 != target_write_memory (inferior_addr
, sect_data
,
393 bfd_get_section_size (sect
)))
394 error (_("Cannot write compiled module \"%s\" section \"%s\" "
395 "to inferior memory range %s-%s."),
396 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
397 paddress (target_gdbarch (), inferior_addr
),
398 paddress (target_gdbarch (),
399 inferior_addr
+ bfd_get_section_size (sect
)));
401 do_cleanups (cleanups
);
404 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
405 symbols in OBJFILE so we can calculate how much memory to allocate
406 for the out parameter. This avoids needing a malloc in the generated
407 code. Throw an error if anything fails.
408 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
409 If it finds user tries to print an array type this function returns
410 NULL. Caller will then regenerate the code with
411 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
412 This is because __auto_type array-to-pointer type conversion of
413 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
414 preserving the array type. */
417 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
418 enum compile_i_scope_types scope
)
420 struct symbol
*gdb_ptr_type_sym
;
421 /* Initialize it just to avoid a GCC false warning. */
422 struct symbol
*gdb_val_sym
= NULL
;
423 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
424 /* Initialize it just to avoid a GCC false warning. */
425 const struct block
*block
= NULL
;
426 const struct blockvector
*bv
;
430 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
431 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
433 gdb_ptr_type_sym
= NULL
;
434 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
436 struct symbol
*function
= NULL
;
437 const struct block
*function_block
;
439 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
440 if (BLOCK_FUNCTION (block
) != NULL
)
442 gdb_val_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_VAL
, VAR_DOMAIN
);
443 if (gdb_val_sym
== NULL
)
446 function_block
= block
;
447 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
448 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
450 function_block
= BLOCK_SUPERBLOCK (function_block
);
451 function
= BLOCK_FUNCTION (function_block
);
452 if (function
!= NULL
)
456 && (BLOCK_SUPERBLOCK (function_block
)
457 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
458 && (strcmp (SYMBOL_LINKAGE_NAME (function
), GCC_FE_WRAPPER_FUNCTION
)
462 if (block_loop
== nblocks
)
463 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
465 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
466 gdb_type
= check_typedef (gdb_type
);
468 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
470 if (gdb_ptr_type_sym
== NULL
)
471 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
472 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
473 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
474 if (TYPE_CODE (gdb_ptr_type
) != TYPE_CODE_PTR
)
475 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
476 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_ptr_type
);
478 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
480 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
481 error (_("Expected address scope in compiled module \"%s\"."),
482 objfile_name (objfile
));
486 if (TYPE_CODE (gdb_type
) != TYPE_CODE_PTR
)
487 error (_("Invalid type code %d of symbol \"%s\" "
488 "in compiled module \"%s\"."),
489 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_VAL
,
490 objfile_name (objfile
));
492 retval
= gdb_type_from_ptr
;
493 switch (TYPE_CODE (gdb_type_from_ptr
))
495 case TYPE_CODE_ARRAY
:
496 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
501 error (_("Invalid type code %d of symbol \"%s\" "
502 "in compiled module \"%s\"."),
503 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_PTR_TYPE
,
504 objfile_name (objfile
));
506 if (!types_deeply_equal (gdb_type_from_ptr
,
507 TYPE_TARGET_TYPE (gdb_type
)))
508 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
509 "in compiled module \"%s\"."),
510 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
511 objfile_name (objfile
));
512 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
517 /* Fetch the type of first parameter of FUNC_SYM.
518 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
521 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
523 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
524 struct type
*regsp_type
, *regs_type
;
526 /* No register parameter present. */
527 if (TYPE_NFIELDS (func_type
) == 0)
530 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
531 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
532 error (_("Invalid type code %d of first parameter of function \"%s\" "
533 "in compiled module \"%s\"."),
534 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
535 objfile_name (objfile
));
537 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
538 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
539 error (_("Invalid type code %d of dereferenced first parameter "
540 "of function \"%s\" in compiled module \"%s\"."),
541 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
542 objfile_name (objfile
));
547 /* Store all inferior registers required by REGS_TYPE to inferior memory
548 starting at inferior address REGS_BASE. */
551 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
553 struct gdbarch
*gdbarch
= target_gdbarch ();
554 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
557 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
559 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
560 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
561 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
563 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
565 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
567 struct value
*regval
;
568 CORE_ADDR inferior_addr
;
570 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
573 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
574 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
575 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
576 reg_offset
= reg_bitpos
/ 8;
578 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
579 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
580 error (_("Invalid register \"%s\" type code %d"), reg_name
,
581 TYPE_CODE (reg_type
));
583 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
585 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
586 if (value_optimized_out (regval
))
587 error (_("Register \"%s\" is optimized out."), reg_name
);
588 if (!value_entirely_available (regval
))
589 error (_("Register \"%s\" is not available."), reg_name
);
591 inferior_addr
= regs_base
+ reg_offset
;
592 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
594 error (_("Cannot write register \"%s\" to inferior memory at %s."),
595 reg_name
, paddress (gdbarch
, inferior_addr
));
599 /* Load the object file specified in FILE_NAMES into inferior memory.
600 Throw an error otherwise. Caller must fully dispose the return
601 value by calling compile_object_run. Returns NULL only for
602 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
603 should have been used instead. */
605 struct compile_module
*
606 compile_object_load (const compile_file_names
&file_names
,
607 enum compile_i_scope_types scope
, void *scope_data
)
609 struct cleanup
*cleanups
;
610 struct setup_sections_data setup_sections_data
;
611 CORE_ADDR addr
, regs_addr
, out_value_addr
= 0;
612 struct symbol
*func_sym
;
613 struct type
*func_type
;
614 struct bound_minimal_symbol bmsym
;
616 asymbol
**symbol_table
, **symp
;
617 long number_of_symbols
, missing_symbols
;
618 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
619 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
620 struct compile_module
*retval
;
621 struct type
*regs_type
, *out_value_type
= NULL
;
623 struct objfile
*objfile
;
624 int expect_parameters
;
625 struct type
*expect_return_type
;
626 struct munmap_list
*munmap_list_head
= NULL
;
628 gdb::unique_xmalloc_ptr
<char> filename
629 (tilde_expand (file_names
.object_file ()));
631 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
633 error (_("\"%s\": could not open as compiled module: %s"),
634 filename
.get (), bfd_errmsg (bfd_get_error ()));
636 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
637 error (_("\"%s\": not in loadable format: %s"),
638 filename
.get (), gdb_bfd_errmsg (bfd_get_error (), matching
));
640 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
641 error (_("\"%s\": not in object format."), filename
.get ());
643 setup_sections_data
.last_size
= 0;
644 setup_sections_data
.last_section_first
= abfd
->sections
;
645 setup_sections_data
.last_prot
= -1;
646 setup_sections_data
.last_max_alignment
= 1;
647 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
648 cleanups
= make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
649 bfd_map_over_sections (abfd
.get (), setup_sections
, &setup_sections_data
);
650 setup_sections (abfd
.get (), NULL
, &setup_sections_data
);
652 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
653 if (storage_needed
< 0)
654 error (_("Cannot read symbols of compiled module \"%s\": %s"),
655 filename
.get (), bfd_errmsg (bfd_get_error ()));
657 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
658 "Reading symbols from ..." message for automatically generated file. */
659 std::unique_ptr
<struct objfile
> objfile_holder
660 (symbol_file_add_from_bfd (abfd
.get (), filename
.get (),
662 objfile
= objfile_holder
.get ();
664 func_sym
= lookup_global_symbol_from_objfile (objfile
,
665 GCC_FE_WRAPPER_FUNCTION
,
667 if (func_sym
== NULL
)
668 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
669 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
670 func_type
= SYMBOL_TYPE (func_sym
);
671 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
672 error (_("Invalid type code %d of function \"%s\" in compiled "
674 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
675 objfile_name (objfile
));
679 case COMPILE_I_SIMPLE_SCOPE
:
680 expect_parameters
= 1;
681 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
683 case COMPILE_I_RAW_SCOPE
:
684 expect_parameters
= 0;
685 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
687 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
688 case COMPILE_I_PRINT_VALUE_SCOPE
:
689 expect_parameters
= 2;
690 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
693 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
695 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
696 error (_("Invalid %d parameters of function \"%s\" in compiled "
698 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
699 objfile_name (objfile
));
700 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
701 error (_("Invalid return type of function \"%s\" in compiled "
703 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
705 /* The memory may be later needed
706 by bfd_generic_get_relocated_section_contents
707 called from default_symfile_relocate. */
708 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
710 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
711 if (number_of_symbols
< 0)
712 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
713 filename
.get (), bfd_errmsg (bfd_get_error ()));
716 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
718 asymbol
*sym
= *symp
;
722 sym
->flags
= BSF_GLOBAL
;
723 sym
->section
= bfd_abs_section_ptr
;
724 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
727 fprintf_unfiltered (gdb_stdlog
,
728 "ELF symbol \"%s\" relocated to zero\n",
731 /* It seems to be a GCC bug, with -mcmodel=large there should be no
732 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
733 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
737 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
738 switch (bmsym
.minsym
== NULL
739 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
742 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
744 fprintf_unfiltered (gdb_stdlog
,
745 "ELF mst_text symbol \"%s\" relocated to %s\n",
747 paddress (target_gdbarch (), sym
->value
));
749 case mst_text_gnu_ifunc
:
750 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
751 BMSYMBOL_VALUE_ADDRESS (bmsym
));
753 fprintf_unfiltered (gdb_stdlog
,
754 "ELF mst_text_gnu_ifunc symbol \"%s\" "
757 paddress (target_gdbarch (), sym
->value
));
760 warning (_("Could not find symbol \"%s\" "
761 "for compiled module \"%s\"."),
762 sym
->name
, filename
.get ());
767 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
769 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
771 regs_type
= get_regs_type (func_sym
, objfile
);
772 if (regs_type
== NULL
)
776 /* Use read-only non-executable memory protection. */
777 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
778 TYPE_LENGTH (regs_type
),
780 gdb_assert (regs_addr
!= 0);
781 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
783 fprintf_unfiltered (gdb_stdlog
,
784 "allocated %s bytes at %s for registers\n",
785 paddress (target_gdbarch (),
786 TYPE_LENGTH (regs_type
)),
787 paddress (target_gdbarch (), regs_addr
));
788 store_regs (regs_type
, regs_addr
);
791 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
792 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
794 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
795 if (out_value_type
== NULL
)
797 do_cleanups (cleanups
);
800 check_typedef (out_value_type
);
801 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
802 TYPE_LENGTH (out_value_type
),
804 | GDB_MMAP_PROT_WRITE
));
805 gdb_assert (out_value_addr
!= 0);
806 munmap_list_add (&munmap_list_head
, out_value_addr
,
807 TYPE_LENGTH (out_value_type
));
809 fprintf_unfiltered (gdb_stdlog
,
810 "allocated %s bytes at %s for printed value\n",
811 paddress (target_gdbarch (),
812 TYPE_LENGTH (out_value_type
)),
813 paddress (target_gdbarch (), out_value_addr
));
816 retval
= XNEW (struct compile_module
);
817 retval
->objfile
= objfile_holder
.release ();
818 retval
->source_file
= xstrdup (file_names
.source_file ());
819 retval
->func_sym
= func_sym
;
820 retval
->regs_addr
= regs_addr
;
821 retval
->scope
= scope
;
822 retval
->scope_data
= scope_data
;
823 retval
->out_value_type
= out_value_type
;
824 retval
->out_value_addr
= out_value_addr
;
826 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
827 retval
->munmap_list_head
= munmap_list_head
;
828 munmap_list_head
= NULL
;
830 do_cleanups (cleanups
);