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"
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 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 compile_module
*retval
;
619 struct type
*regs_type
, *out_value_type
= NULL
;
621 struct objfile
*objfile
;
622 int expect_parameters
;
623 struct type
*expect_return_type
;
624 struct munmap_list
*munmap_list_head
= NULL
;
626 gdb::unique_xmalloc_ptr
<char> filename
627 (tilde_expand (file_names
.object_file ()));
629 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
631 error (_("\"%s\": could not open as compiled module: %s"),
632 filename
.get (), bfd_errmsg (bfd_get_error ()));
634 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
635 error (_("\"%s\": not in loadable format: %s"),
636 filename
.get (), gdb_bfd_errmsg (bfd_get_error (), matching
));
638 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
639 error (_("\"%s\": not in object format."), filename
.get ());
641 setup_sections_data
.last_size
= 0;
642 setup_sections_data
.last_section_first
= abfd
->sections
;
643 setup_sections_data
.last_prot
= -1;
644 setup_sections_data
.last_max_alignment
= 1;
645 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
646 cleanups
= make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
647 bfd_map_over_sections (abfd
.get (), setup_sections
, &setup_sections_data
);
648 setup_sections (abfd
.get (), NULL
, &setup_sections_data
);
650 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
651 if (storage_needed
< 0)
652 error (_("Cannot read symbols of compiled module \"%s\": %s"),
653 filename
.get (), bfd_errmsg (bfd_get_error ()));
655 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
656 "Reading symbols from ..." message for automatically generated file. */
657 std::unique_ptr
<struct objfile
> objfile_holder
658 (symbol_file_add_from_bfd (abfd
.get (), filename
.get (),
660 objfile
= objfile_holder
.get ();
662 func_sym
= lookup_global_symbol_from_objfile (objfile
,
663 GCC_FE_WRAPPER_FUNCTION
,
665 if (func_sym
== NULL
)
666 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
667 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
668 func_type
= SYMBOL_TYPE (func_sym
);
669 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
670 error (_("Invalid type code %d of function \"%s\" in compiled "
672 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
673 objfile_name (objfile
));
677 case COMPILE_I_SIMPLE_SCOPE
:
678 expect_parameters
= 1;
679 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
681 case COMPILE_I_RAW_SCOPE
:
682 expect_parameters
= 0;
683 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
685 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
686 case COMPILE_I_PRINT_VALUE_SCOPE
:
687 expect_parameters
= 2;
688 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
691 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
693 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
694 error (_("Invalid %d parameters of function \"%s\" in compiled "
696 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
697 objfile_name (objfile
));
698 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
699 error (_("Invalid return type of function \"%s\" in compiled "
701 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
703 /* The memory may be later needed
704 by bfd_generic_get_relocated_section_contents
705 called from default_symfile_relocate. */
706 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
708 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
709 if (number_of_symbols
< 0)
710 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
711 filename
.get (), bfd_errmsg (bfd_get_error ()));
714 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
716 asymbol
*sym
= *symp
;
720 sym
->flags
= BSF_GLOBAL
;
721 sym
->section
= bfd_abs_section_ptr
;
722 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
725 fprintf_unfiltered (gdb_stdlog
,
726 "ELF symbol \"%s\" relocated to zero\n",
729 /* It seems to be a GCC bug, with -mcmodel=large there should be no
730 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
731 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
735 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
736 switch (bmsym
.minsym
== NULL
737 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
740 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
742 fprintf_unfiltered (gdb_stdlog
,
743 "ELF mst_text symbol \"%s\" relocated to %s\n",
745 paddress (target_gdbarch (), sym
->value
));
747 case mst_text_gnu_ifunc
:
748 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
749 BMSYMBOL_VALUE_ADDRESS (bmsym
));
751 fprintf_unfiltered (gdb_stdlog
,
752 "ELF mst_text_gnu_ifunc symbol \"%s\" "
755 paddress (target_gdbarch (), sym
->value
));
758 warning (_("Could not find symbol \"%s\" "
759 "for compiled module \"%s\"."),
760 sym
->name
, filename
.get ());
765 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
767 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
769 regs_type
= get_regs_type (func_sym
, objfile
);
770 if (regs_type
== NULL
)
774 /* Use read-only non-executable memory protection. */
775 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
776 TYPE_LENGTH (regs_type
),
778 gdb_assert (regs_addr
!= 0);
779 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
781 fprintf_unfiltered (gdb_stdlog
,
782 "allocated %s bytes at %s for registers\n",
783 paddress (target_gdbarch (),
784 TYPE_LENGTH (regs_type
)),
785 paddress (target_gdbarch (), regs_addr
));
786 store_regs (regs_type
, regs_addr
);
789 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
790 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
792 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
793 if (out_value_type
== NULL
)
795 do_cleanups (cleanups
);
798 check_typedef (out_value_type
);
799 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
800 TYPE_LENGTH (out_value_type
),
802 | GDB_MMAP_PROT_WRITE
));
803 gdb_assert (out_value_addr
!= 0);
804 munmap_list_add (&munmap_list_head
, out_value_addr
,
805 TYPE_LENGTH (out_value_type
));
807 fprintf_unfiltered (gdb_stdlog
,
808 "allocated %s bytes at %s for printed value\n",
809 paddress (target_gdbarch (),
810 TYPE_LENGTH (out_value_type
)),
811 paddress (target_gdbarch (), out_value_addr
));
814 retval
= XNEW (struct compile_module
);
815 retval
->objfile
= objfile_holder
.release ();
816 retval
->source_file
= xstrdup (file_names
.source_file ());
817 retval
->func_sym
= func_sym
;
818 retval
->regs_addr
= regs_addr
;
819 retval
->scope
= scope
;
820 retval
->scope_data
= scope_data
;
821 retval
->out_value_type
= out_value_type
;
822 retval
->out_value_addr
= out_value_addr
;
824 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
825 retval
->munmap_list_head
= munmap_list_head
;
826 munmap_list_head
= NULL
;
828 do_cleanups (cleanups
);