1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2015 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"
35 /* Track inferior memory reserved by inferior mmap. */
39 struct munmap_list
*next
;
43 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
44 HEADP. *HEADP needs to be initialized to NULL. */
47 munmap_list_add (struct munmap_list
**headp
, CORE_ADDR addr
, CORE_ADDR size
)
49 struct munmap_list
*head_new
= xmalloc (sizeof (*head_new
));
51 head_new
->next
= *headp
;
53 head_new
->addr
= addr
;
54 head_new
->size
= size
;
57 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first
58 element of the list, it can be NULL. After calling this function
59 HEAD pointer is invalid and the possible list needs to be
60 reinitialized by caller to NULL. */
63 munmap_list_free (struct munmap_list
*head
)
67 struct munmap_list
*todo
= head
;
70 gdbarch_infcall_munmap (target_gdbarch (), todo
->addr
, todo
->size
);
75 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to
76 munmap_list_free this function's parameter is a pointer to the first
77 list element pointer. */
80 munmap_listp_free_cleanup (void *headp_voidp
)
82 struct munmap_list
**headp
= headp_voidp
;
84 munmap_list_free (*headp
);
87 /* Helper data for setup_sections. */
89 struct setup_sections_data
91 /* Size of all recent sections with matching LAST_PROT. */
94 /* First section matching LAST_PROT. */
95 asection
*last_section_first
;
97 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
100 /* Maximum of alignments of all sections matching LAST_PROT.
101 This value is always at least 1. This value is always a power of 2. */
102 CORE_ADDR last_max_alignment
;
104 /* List of inferior mmap ranges where setup_sections should add its
106 struct munmap_list
**munmap_list_headp
;
109 /* Place all ABFD sections next to each other obeying all constraints. */
112 setup_sections (bfd
*abfd
, asection
*sect
, void *data_voidp
)
114 struct setup_sections_data
*data
= data_voidp
;
120 /* It is required by later bfd_get_relocated_section_contents. */
121 if (sect
->output_section
== NULL
)
122 sect
->output_section
= sect
;
124 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
127 /* Make the memory always readable. */
128 prot
= GDB_MMAP_PROT_READ
;
129 if ((bfd_get_section_flags (abfd
, sect
) & SEC_READONLY
) == 0)
130 prot
|= GDB_MMAP_PROT_WRITE
;
131 if ((bfd_get_section_flags (abfd
, sect
) & SEC_CODE
) != 0)
132 prot
|= GDB_MMAP_PROT_EXEC
;
135 fprintf_unfiltered (gdb_stdlog
,
136 "module \"%s\" section \"%s\" size %s prot %u\n",
137 bfd_get_filename (abfd
),
138 bfd_get_section_name (abfd
, sect
),
139 paddress (target_gdbarch (),
140 bfd_get_section_size (sect
)),
147 || (data
->last_prot
!= prot
&& bfd_get_section_size (sect
) != 0))
152 if (data
->last_size
!= 0)
154 addr
= gdbarch_infcall_mmap (target_gdbarch (), data
->last_size
,
156 munmap_list_add (data
->munmap_list_headp
, addr
, data
->last_size
);
158 fprintf_unfiltered (gdb_stdlog
,
159 "allocated %s bytes at %s prot %u\n",
160 paddress (target_gdbarch (), data
->last_size
),
161 paddress (target_gdbarch (), addr
),
167 if ((addr
& (data
->last_max_alignment
- 1)) != 0)
168 error (_("Inferior compiled module address %s "
169 "is not aligned to BFD required %s."),
170 paddress (target_gdbarch (), addr
),
171 paddress (target_gdbarch (), data
->last_max_alignment
));
173 for (sect_iter
= data
->last_section_first
; sect_iter
!= sect
;
174 sect_iter
= sect_iter
->next
)
175 if ((bfd_get_section_flags (abfd
, sect_iter
) & SEC_ALLOC
) != 0)
176 bfd_set_section_vma (abfd
, sect_iter
,
177 addr
+ bfd_get_section_vma (abfd
, sect_iter
));
180 data
->last_section_first
= sect
;
181 data
->last_prot
= prot
;
182 data
->last_max_alignment
= 1;
188 alignment
= ((CORE_ADDR
) 1) << bfd_get_section_alignment (abfd
, sect
);
189 data
->last_max_alignment
= max (data
->last_max_alignment
, alignment
);
191 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
193 bfd_set_section_vma (abfd
, sect
, data
->last_size
);
195 data
->last_size
+= bfd_get_section_size (sect
);
196 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
199 /* Helper for link_callbacks callbacks vector. */
202 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
203 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
204 asection
*nsec
, bfd_vma nval
)
206 bfd
*abfd
= link_info
->input_bfds
;
208 if (link_info
->allow_multiple_definition
)
210 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
211 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
),
225 /* Maybe permit running as a module? */
229 /* Helper for link_callbacks callbacks vector. */
232 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
233 const char *name
, bfd
*abfd
, asection
*section
,
234 bfd_vma address
, bfd_boolean is_fatal
)
236 warning (_("Cannot resolve relocation to \"%s\" "
237 "from compiled module \"%s\" section \"%s\"."),
238 name
, bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
242 /* Helper for link_callbacks callbacks vector. */
245 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
246 struct bfd_link_hash_entry
*entry
,
247 const char *name
, const char *reloc_name
,
248 bfd_vma addend
, bfd
*abfd
, asection
*section
,
251 /* TRUE is required for intra-module relocations. */
255 /* Helper for link_callbacks callbacks vector. */
258 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
259 const char *message
, bfd
*abfd
,
260 asection
*section
, bfd_vma address
)
262 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
264 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
269 /* Helper for link_callbacks callbacks vector. */
272 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
273 const char *name
, bfd
*abfd
, asection
*section
,
276 warning (_("Compiled module \"%s\" section \"%s\": unattached "
278 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
283 /* Helper for link_callbacks callbacks vector. */
285 static void link_callbacks_einfo (const char *fmt
, ...)
286 ATTRIBUTE_PRINTF (1, 2);
289 link_callbacks_einfo (const char *fmt
, ...)
291 struct cleanup
*cleanups
;
296 str
= xstrvprintf (fmt
, ap
);
298 cleanups
= make_cleanup (xfree
, str
);
300 warning (_("Compile module: warning: %s"), str
);
302 do_cleanups (cleanups
);
305 /* Helper for bfd_get_relocated_section_contents.
306 Only these symbols are set by bfd_simple_get_relocated_section_contents
307 but bfd/ seems to use even the NULL ones without checking them first. */
309 static const struct bfd_link_callbacks link_callbacks
=
311 NULL
, /* add_archive_element */
312 link_callbacks_multiple_definition
, /* multiple_definition */
313 NULL
, /* multiple_common */
314 NULL
, /* add_to_set */
315 NULL
, /* constructor */
316 link_callbacks_warning
, /* warning */
317 link_callbacks_undefined_symbol
, /* undefined_symbol */
318 link_callbacks_reloc_overflow
, /* reloc_overflow */
319 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
320 link_callbacks_unattached_reloc
, /* unattached_reloc */
322 link_callbacks_einfo
, /* einfo */
325 NULL
, /* override_segment_assignment */
328 struct link_hash_table_cleanup_data
334 /* Cleanup callback for struct bfd_link_info. */
337 link_hash_table_free (void *d
)
339 struct link_hash_table_cleanup_data
*data
= d
;
341 if (data
->abfd
->is_linker_output
)
342 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
343 data
->abfd
->link
.next
= data
->link_next
;
346 /* Relocate and store into inferior memory each section SECT of ABFD. */
349 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
351 asymbol
**symbol_table
= data
;
352 bfd_byte
*sect_data
, *sect_data_got
;
353 struct cleanup
*cleanups
;
354 struct bfd_link_info link_info
;
355 struct bfd_link_order link_order
;
356 CORE_ADDR inferior_addr
;
357 struct link_hash_table_cleanup_data cleanup_data
;
359 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
360 != (SEC_ALLOC
| SEC_LOAD
))
363 if (bfd_get_section_size (sect
) == 0)
366 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
367 cannot use as it does not report relocations to undefined symbols. */
368 memset (&link_info
, 0, sizeof (link_info
));
369 link_info
.output_bfd
= abfd
;
370 link_info
.input_bfds
= abfd
;
371 link_info
.input_bfds_tail
= &abfd
->link
.next
;
373 cleanup_data
.abfd
= abfd
;
374 cleanup_data
.link_next
= abfd
->link
.next
;
376 abfd
->link
.next
= NULL
;
377 link_info
.hash
= bfd_link_hash_table_create (abfd
);
379 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
380 link_info
.callbacks
= &link_callbacks
;
382 memset (&link_order
, 0, sizeof (link_order
));
383 link_order
.next
= NULL
;
384 link_order
.type
= bfd_indirect_link_order
;
385 link_order
.offset
= 0;
386 link_order
.size
= bfd_get_section_size (sect
);
387 link_order
.u
.indirect
.section
= sect
;
389 sect_data
= xmalloc (bfd_get_section_size (sect
));
390 make_cleanup (xfree
, sect_data
);
392 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
393 &link_order
, sect_data
,
394 FALSE
, symbol_table
);
396 if (sect_data_got
== NULL
)
397 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
398 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
399 bfd_errmsg (bfd_get_error ()));
400 gdb_assert (sect_data_got
== sect_data
);
402 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
403 if (0 != target_write_memory (inferior_addr
, sect_data
,
404 bfd_get_section_size (sect
)))
405 error (_("Cannot write compiled module \"%s\" section \"%s\" "
406 "to inferior memory range %s-%s."),
407 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
408 paddress (target_gdbarch (), inferior_addr
),
409 paddress (target_gdbarch (),
410 inferior_addr
+ bfd_get_section_size (sect
)));
412 do_cleanups (cleanups
);
415 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
416 symbols in OBJFILE so we can calculate how much memory to allocate
417 for the out parameter. This avoids needing a malloc in the generated
418 code. Throw an error if anything fails.
419 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
420 If it finds user tries to print an array type this function returns
421 NULL. Caller will then regenerate the code with
422 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
423 This is because __auto_type array-to-pointer type conversion of
424 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
425 preserving the array type. */
428 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
429 enum compile_i_scope_types scope
)
431 struct symbol
*gdb_ptr_type_sym
;
432 /* Initialize it just to avoid a GCC false warning. */
433 struct symbol
*gdb_val_sym
= NULL
;
434 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
435 /* Initialize it just to avoid a GCC false warning. */
436 const struct block
*block
= NULL
;
437 const struct blockvector
*bv
;
441 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
442 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
444 gdb_ptr_type_sym
= NULL
;
445 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
447 struct symbol
*function
= NULL
;
448 const struct block
*function_block
;
450 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
451 if (BLOCK_FUNCTION (block
) != NULL
)
453 gdb_val_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_VAL
, VAR_DOMAIN
);
454 if (gdb_val_sym
== NULL
)
457 function_block
= block
;
458 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
459 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
461 function_block
= BLOCK_SUPERBLOCK (function_block
);
462 function
= BLOCK_FUNCTION (function_block
);
463 if (function
!= NULL
)
467 && (BLOCK_SUPERBLOCK (function_block
)
468 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
469 && (strcmp (SYMBOL_LINKAGE_NAME (function
), GCC_FE_WRAPPER_FUNCTION
)
473 if (block_loop
== nblocks
)
474 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
476 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
477 gdb_type
= check_typedef (gdb_type
);
479 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
481 if (gdb_ptr_type_sym
== NULL
)
482 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
483 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
484 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
485 if (TYPE_CODE (gdb_ptr_type
) != TYPE_CODE_PTR
)
486 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
487 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_ptr_type
);
489 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
491 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
492 error (_("Expected address scope in compiled module \"%s\"."),
493 objfile_name (objfile
));
497 if (TYPE_CODE (gdb_type
) != TYPE_CODE_PTR
)
498 error (_("Invalid type code %d of symbol \"%s\" "
499 "in compiled module \"%s\"."),
500 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_VAL
,
501 objfile_name (objfile
));
503 retval
= gdb_type_from_ptr
;
504 switch (TYPE_CODE (gdb_type_from_ptr
))
506 case TYPE_CODE_ARRAY
:
507 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
512 error (_("Invalid type code %d of symbol \"%s\" "
513 "in compiled module \"%s\"."),
514 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_PTR_TYPE
,
515 objfile_name (objfile
));
517 if (!types_deeply_equal (gdb_type_from_ptr
,
518 TYPE_TARGET_TYPE (gdb_type
)))
519 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
520 "in compiled module \"%s\"."),
521 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
522 objfile_name (objfile
));
523 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
528 /* Fetch the type of first parameter of FUNC_SYM.
529 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
532 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
534 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
535 struct type
*regsp_type
, *regs_type
;
537 /* No register parameter present. */
538 if (TYPE_NFIELDS (func_type
) == 0)
541 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
542 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
543 error (_("Invalid type code %d of first parameter of function \"%s\" "
544 "in compiled module \"%s\"."),
545 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
546 objfile_name (objfile
));
548 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
549 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
550 error (_("Invalid type code %d of dereferenced first parameter "
551 "of function \"%s\" in compiled module \"%s\"."),
552 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
553 objfile_name (objfile
));
558 /* Store all inferior registers required by REGS_TYPE to inferior memory
559 starting at inferior address REGS_BASE. */
562 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
564 struct gdbarch
*gdbarch
= target_gdbarch ();
565 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
568 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
570 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
571 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
572 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
574 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
576 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
578 struct value
*regval
;
579 CORE_ADDR inferior_addr
;
581 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
584 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
585 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
586 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
587 reg_offset
= reg_bitpos
/ 8;
589 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
590 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
591 error (_("Invalid register \"%s\" type code %d"), reg_name
,
592 TYPE_CODE (reg_type
));
594 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
596 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
597 if (value_optimized_out (regval
))
598 error (_("Register \"%s\" is optimized out."), reg_name
);
599 if (!value_entirely_available (regval
))
600 error (_("Register \"%s\" is not available."), reg_name
);
602 inferior_addr
= regs_base
+ reg_offset
;
603 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
605 error (_("Cannot write register \"%s\" to inferior memory at %s."),
606 reg_name
, paddress (gdbarch
, inferior_addr
));
610 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
611 Caller must fully dispose the return value by calling compile_object_run.
612 SOURCE_FILE's copy is stored into the returned object.
613 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
615 Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when
616 COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */
618 struct compile_module
*
619 compile_object_load (const char *object_file
, const char *source_file
,
620 enum compile_i_scope_types scope
, void *scope_data
)
622 struct cleanup
*cleanups
, *cleanups_free_objfile
;
624 struct setup_sections_data setup_sections_data
;
625 CORE_ADDR addr
, regs_addr
, out_value_addr
= 0;
626 struct symbol
*func_sym
;
627 struct type
*func_type
;
628 struct bound_minimal_symbol bmsym
;
630 asymbol
**symbol_table
, **symp
;
631 long number_of_symbols
, missing_symbols
;
632 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
633 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
634 struct compile_module
*retval
;
635 struct type
*regs_type
, *out_value_type
= NULL
;
636 char *filename
, **matching
;
637 struct objfile
*objfile
;
638 int expect_parameters
;
639 struct type
*expect_return_type
;
640 struct munmap_list
*munmap_list_head
= NULL
;
642 filename
= tilde_expand (object_file
);
643 cleanups
= make_cleanup (xfree
, filename
);
645 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
647 error (_("\"%s\": could not open as compiled module: %s"),
648 filename
, bfd_errmsg (bfd_get_error ()));
649 make_cleanup_bfd_unref (abfd
);
651 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
652 error (_("\"%s\": not in loadable format: %s"),
653 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
655 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
656 error (_("\"%s\": not in object format."), filename
);
658 setup_sections_data
.last_size
= 0;
659 setup_sections_data
.last_section_first
= abfd
->sections
;
660 setup_sections_data
.last_prot
= -1;
661 setup_sections_data
.last_max_alignment
= 1;
662 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
663 make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
664 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
665 setup_sections (abfd
, NULL
, &setup_sections_data
);
667 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
668 if (storage_needed
< 0)
669 error (_("Cannot read symbols of compiled module \"%s\": %s"),
670 filename
, bfd_errmsg (bfd_get_error ()));
672 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
673 "Reading symbols from ..." message for automatically generated file. */
674 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
675 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
677 func_sym
= lookup_global_symbol_from_objfile (objfile
,
678 GCC_FE_WRAPPER_FUNCTION
,
680 if (func_sym
== NULL
)
681 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
682 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
683 func_type
= SYMBOL_TYPE (func_sym
);
684 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
685 error (_("Invalid type code %d of function \"%s\" in compiled "
687 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
688 objfile_name (objfile
));
692 case COMPILE_I_SIMPLE_SCOPE
:
693 expect_parameters
= 1;
694 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
696 case COMPILE_I_RAW_SCOPE
:
697 expect_parameters
= 0;
698 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
700 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
701 case COMPILE_I_PRINT_VALUE_SCOPE
:
702 expect_parameters
= 2;
703 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
706 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
708 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
709 error (_("Invalid %d parameters of function \"%s\" in compiled "
711 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
712 objfile_name (objfile
));
713 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
714 error (_("Invalid return type of function \"%s\" in compiled "
716 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
718 /* The memory may be later needed
719 by bfd_generic_get_relocated_section_contents
720 called from default_symfile_relocate. */
721 symbol_table
= obstack_alloc (&objfile
->objfile_obstack
, storage_needed
);
722 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
723 if (number_of_symbols
< 0)
724 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
725 filename
, bfd_errmsg (bfd_get_error ()));
728 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
730 asymbol
*sym
= *symp
;
734 sym
->flags
= BSF_GLOBAL
;
735 sym
->section
= bfd_abs_section_ptr
;
736 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
739 fprintf_unfiltered (gdb_stdlog
,
740 "ELF symbol \"%s\" relocated to zero\n",
743 /* It seems to be a GCC bug, with -mcmodel=large there should be no
744 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
745 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
749 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
750 switch (bmsym
.minsym
== NULL
751 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
754 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
756 fprintf_unfiltered (gdb_stdlog
,
757 "ELF mst_text symbol \"%s\" relocated to %s\n",
759 paddress (target_gdbarch (), sym
->value
));
761 case mst_text_gnu_ifunc
:
762 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
763 BMSYMBOL_VALUE_ADDRESS (bmsym
));
765 fprintf_unfiltered (gdb_stdlog
,
766 "ELF mst_text_gnu_ifunc symbol \"%s\" "
769 paddress (target_gdbarch (), sym
->value
));
772 warning (_("Could not find symbol \"%s\" "
773 "for compiled module \"%s\"."),
774 sym
->name
, filename
);
779 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
781 bfd_map_over_sections (abfd
, copy_sections
, symbol_table
);
783 regs_type
= get_regs_type (func_sym
, objfile
);
784 if (regs_type
== NULL
)
788 /* Use read-only non-executable memory protection. */
789 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
790 TYPE_LENGTH (regs_type
),
792 gdb_assert (regs_addr
!= 0);
793 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
795 fprintf_unfiltered (gdb_stdlog
,
796 "allocated %s bytes at %s for registers\n",
797 paddress (target_gdbarch (),
798 TYPE_LENGTH (regs_type
)),
799 paddress (target_gdbarch (), regs_addr
));
800 store_regs (regs_type
, regs_addr
);
803 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
804 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
806 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
807 if (out_value_type
== NULL
)
809 do_cleanups (cleanups
);
812 check_typedef (out_value_type
);
813 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
814 TYPE_LENGTH (out_value_type
),
816 | GDB_MMAP_PROT_WRITE
));
817 gdb_assert (out_value_addr
!= 0);
818 munmap_list_add (&munmap_list_head
, out_value_addr
,
819 TYPE_LENGTH (out_value_type
));
821 fprintf_unfiltered (gdb_stdlog
,
822 "allocated %s bytes at %s for printed value\n",
823 paddress (target_gdbarch (),
824 TYPE_LENGTH (out_value_type
)),
825 paddress (target_gdbarch (), out_value_addr
));
828 discard_cleanups (cleanups_free_objfile
);
830 retval
= xmalloc (sizeof (*retval
));
831 retval
->objfile
= objfile
;
832 retval
->source_file
= xstrdup (source_file
);
833 retval
->func_sym
= func_sym
;
834 retval
->regs_addr
= regs_addr
;
835 retval
->scope
= scope
;
836 retval
->scope_data
= scope_data
;
837 retval
->out_value_type
= out_value_type
;
838 retval
->out_value_addr
= out_value_addr
;
840 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
841 retval
->munmap_list_head
= munmap_list_head
;
842 munmap_list_head
= NULL
;
844 do_cleanups (cleanups
);