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
, ...)
284 struct cleanup
*cleanups
;
289 str
= xstrvprintf (fmt
, ap
);
291 cleanups
= make_cleanup (xfree
, str
);
293 warning (_("Compile module: warning: %s"), str
);
295 do_cleanups (cleanups
);
298 /* Helper for bfd_get_relocated_section_contents.
299 Only these symbols are set by bfd_simple_get_relocated_section_contents
300 but bfd/ seems to use even the NULL ones without checking them first. */
302 static const struct bfd_link_callbacks link_callbacks
=
304 NULL
, /* add_archive_element */
305 link_callbacks_multiple_definition
, /* multiple_definition */
306 NULL
, /* multiple_common */
307 NULL
, /* add_to_set */
308 NULL
, /* constructor */
309 link_callbacks_warning
, /* warning */
310 link_callbacks_undefined_symbol
, /* undefined_symbol */
311 link_callbacks_reloc_overflow
, /* reloc_overflow */
312 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
313 link_callbacks_unattached_reloc
, /* unattached_reloc */
315 link_callbacks_einfo
, /* einfo */
318 NULL
, /* override_segment_assignment */
321 struct link_hash_table_cleanup_data
327 /* Cleanup callback for struct bfd_link_info. */
330 link_hash_table_free (void *d
)
332 struct link_hash_table_cleanup_data
*data
333 = (struct link_hash_table_cleanup_data
*) d
;
335 if (data
->abfd
->is_linker_output
)
336 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
337 data
->abfd
->link
.next
= data
->link_next
;
340 /* Relocate and store into inferior memory each section SECT of ABFD. */
343 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
345 asymbol
**symbol_table
= (asymbol
**) data
;
346 bfd_byte
*sect_data
, *sect_data_got
;
347 struct cleanup
*cleanups
;
348 struct bfd_link_info link_info
;
349 struct bfd_link_order link_order
;
350 CORE_ADDR inferior_addr
;
351 struct link_hash_table_cleanup_data cleanup_data
;
353 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
354 != (SEC_ALLOC
| SEC_LOAD
))
357 if (bfd_get_section_size (sect
) == 0)
360 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
361 cannot use as it does not report relocations to undefined symbols. */
362 memset (&link_info
, 0, sizeof (link_info
));
363 link_info
.output_bfd
= abfd
;
364 link_info
.input_bfds
= abfd
;
365 link_info
.input_bfds_tail
= &abfd
->link
.next
;
367 cleanup_data
.abfd
= abfd
;
368 cleanup_data
.link_next
= abfd
->link
.next
;
370 abfd
->link
.next
= NULL
;
371 link_info
.hash
= bfd_link_hash_table_create (abfd
);
373 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
374 link_info
.callbacks
= &link_callbacks
;
376 memset (&link_order
, 0, sizeof (link_order
));
377 link_order
.next
= NULL
;
378 link_order
.type
= bfd_indirect_link_order
;
379 link_order
.offset
= 0;
380 link_order
.size
= bfd_get_section_size (sect
);
381 link_order
.u
.indirect
.section
= sect
;
383 sect_data
= (bfd_byte
*) xmalloc (bfd_get_section_size (sect
));
384 make_cleanup (xfree
, sect_data
);
386 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
387 &link_order
, sect_data
,
388 FALSE
, symbol_table
);
390 if (sect_data_got
== NULL
)
391 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
392 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
393 bfd_errmsg (bfd_get_error ()));
394 gdb_assert (sect_data_got
== sect_data
);
396 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
397 if (0 != target_write_memory (inferior_addr
, sect_data
,
398 bfd_get_section_size (sect
)))
399 error (_("Cannot write compiled module \"%s\" section \"%s\" "
400 "to inferior memory range %s-%s."),
401 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
402 paddress (target_gdbarch (), inferior_addr
),
403 paddress (target_gdbarch (),
404 inferior_addr
+ bfd_get_section_size (sect
)));
406 do_cleanups (cleanups
);
409 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
410 symbols in OBJFILE so we can calculate how much memory to allocate
411 for the out parameter. This avoids needing a malloc in the generated
412 code. Throw an error if anything fails.
413 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
414 If it finds user tries to print an array type this function returns
415 NULL. Caller will then regenerate the code with
416 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
417 This is because __auto_type array-to-pointer type conversion of
418 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
419 preserving the array type. */
422 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
423 enum compile_i_scope_types scope
)
425 struct symbol
*gdb_ptr_type_sym
;
426 /* Initialize it just to avoid a GCC false warning. */
427 struct symbol
*gdb_val_sym
= NULL
;
428 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
429 /* Initialize it just to avoid a GCC false warning. */
430 const struct block
*block
= NULL
;
431 const struct blockvector
*bv
;
435 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
436 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
438 gdb_ptr_type_sym
= NULL
;
439 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
441 struct symbol
*function
= NULL
;
442 const struct block
*function_block
;
444 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
445 if (BLOCK_FUNCTION (block
) != NULL
)
447 gdb_val_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_VAL
, VAR_DOMAIN
);
448 if (gdb_val_sym
== NULL
)
451 function_block
= block
;
452 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
453 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
455 function_block
= BLOCK_SUPERBLOCK (function_block
);
456 function
= BLOCK_FUNCTION (function_block
);
457 if (function
!= NULL
)
461 && (BLOCK_SUPERBLOCK (function_block
)
462 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
463 && (strcmp (SYMBOL_LINKAGE_NAME (function
), 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
,
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 ();
559 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
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
, *cleanups_free_objfile
;
616 struct setup_sections_data setup_sections_data
;
617 CORE_ADDR addr
, regs_addr
, out_value_addr
= 0;
618 struct symbol
*func_sym
;
619 struct type
*func_type
;
620 struct bound_minimal_symbol bmsym
;
622 asymbol
**symbol_table
, **symp
;
623 long number_of_symbols
, missing_symbols
;
624 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
625 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
626 struct compile_module
*retval
;
627 struct type
*regs_type
, *out_value_type
= NULL
;
628 char *filename
, **matching
;
629 struct objfile
*objfile
;
630 int expect_parameters
;
631 struct type
*expect_return_type
;
632 struct munmap_list
*munmap_list_head
= NULL
;
634 filename
= tilde_expand (file_names
.object_file ());
635 cleanups
= make_cleanup (xfree
, filename
);
637 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
639 error (_("\"%s\": could not open as compiled module: %s"),
640 filename
, bfd_errmsg (bfd_get_error ()));
641 make_cleanup_bfd_unref (abfd
);
643 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
644 error (_("\"%s\": not in loadable format: %s"),
645 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
647 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
648 error (_("\"%s\": not in object format."), filename
);
650 setup_sections_data
.last_size
= 0;
651 setup_sections_data
.last_section_first
= abfd
->sections
;
652 setup_sections_data
.last_prot
= -1;
653 setup_sections_data
.last_max_alignment
= 1;
654 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
655 make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
656 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
657 setup_sections (abfd
, NULL
, &setup_sections_data
);
659 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
660 if (storage_needed
< 0)
661 error (_("Cannot read symbols of compiled module \"%s\": %s"),
662 filename
, bfd_errmsg (bfd_get_error ()));
664 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
665 "Reading symbols from ..." message for automatically generated file. */
666 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
667 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
669 func_sym
= lookup_global_symbol_from_objfile (objfile
,
670 GCC_FE_WRAPPER_FUNCTION
,
672 if (func_sym
== NULL
)
673 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
674 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
675 func_type
= SYMBOL_TYPE (func_sym
);
676 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
677 error (_("Invalid type code %d of function \"%s\" in compiled "
679 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
680 objfile_name (objfile
));
684 case COMPILE_I_SIMPLE_SCOPE
:
685 expect_parameters
= 1;
686 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
688 case COMPILE_I_RAW_SCOPE
:
689 expect_parameters
= 0;
690 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
692 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
693 case COMPILE_I_PRINT_VALUE_SCOPE
:
694 expect_parameters
= 2;
695 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
698 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
700 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
701 error (_("Invalid %d parameters of function \"%s\" in compiled "
703 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
704 objfile_name (objfile
));
705 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
706 error (_("Invalid return type of function \"%s\" in compiled "
708 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
710 /* The memory may be later needed
711 by bfd_generic_get_relocated_section_contents
712 called from default_symfile_relocate. */
713 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
715 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
716 if (number_of_symbols
< 0)
717 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
718 filename
, bfd_errmsg (bfd_get_error ()));
721 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
723 asymbol
*sym
= *symp
;
727 sym
->flags
= BSF_GLOBAL
;
728 sym
->section
= bfd_abs_section_ptr
;
729 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
732 fprintf_unfiltered (gdb_stdlog
,
733 "ELF symbol \"%s\" relocated to zero\n",
736 /* It seems to be a GCC bug, with -mcmodel=large there should be no
737 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
738 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
742 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
743 switch (bmsym
.minsym
== NULL
744 ? 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
);
772 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
774 bfd_map_over_sections (abfd
, 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 discard_cleanups (cleanups_free_objfile
);
823 retval
= XNEW (struct compile_module
);
824 retval
->objfile
= objfile
;
825 retval
->source_file
= xstrdup (file_names
.source_file ());
826 retval
->func_sym
= func_sym
;
827 retval
->regs_addr
= regs_addr
;
828 retval
->scope
= scope
;
829 retval
->scope_data
= scope_data
;
830 retval
->out_value_type
= out_value_type
;
831 retval
->out_value_addr
= out_value_addr
;
833 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
834 retval
->munmap_list_head
= munmap_list_head
;
835 munmap_list_head
= NULL
;
837 do_cleanups (cleanups
);