1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2016 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 OBJECT_FILE into inferior memory. Throw an error otherwise.
605 Caller must fully dispose the return value by calling compile_object_run.
606 SOURCE_FILE's copy is stored into the returned object.
607 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
609 Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when
610 COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */
612 struct compile_module
*
613 compile_object_load (const char *object_file
, const char *source_file
,
614 enum compile_i_scope_types scope
, void *scope_data
)
616 struct cleanup
*cleanups
, *cleanups_free_objfile
;
618 struct setup_sections_data setup_sections_data
;
619 CORE_ADDR addr
, regs_addr
, out_value_addr
= 0;
620 struct symbol
*func_sym
;
621 struct type
*func_type
;
622 struct bound_minimal_symbol bmsym
;
624 asymbol
**symbol_table
, **symp
;
625 long number_of_symbols
, missing_symbols
;
626 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
627 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
628 struct compile_module
*retval
;
629 struct type
*regs_type
, *out_value_type
= NULL
;
630 char *filename
, **matching
;
631 struct objfile
*objfile
;
632 int expect_parameters
;
633 struct type
*expect_return_type
;
634 struct munmap_list
*munmap_list_head
= NULL
;
636 filename
= tilde_expand (object_file
);
637 cleanups
= make_cleanup (xfree
, filename
);
639 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
641 error (_("\"%s\": could not open as compiled module: %s"),
642 filename
, bfd_errmsg (bfd_get_error ()));
643 make_cleanup_bfd_unref (abfd
);
645 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
646 error (_("\"%s\": not in loadable format: %s"),
647 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
649 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
650 error (_("\"%s\": not in object format."), filename
);
652 setup_sections_data
.last_size
= 0;
653 setup_sections_data
.last_section_first
= abfd
->sections
;
654 setup_sections_data
.last_prot
= -1;
655 setup_sections_data
.last_max_alignment
= 1;
656 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
657 make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
658 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
659 setup_sections (abfd
, NULL
, &setup_sections_data
);
661 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
662 if (storage_needed
< 0)
663 error (_("Cannot read symbols of compiled module \"%s\": %s"),
664 filename
, bfd_errmsg (bfd_get_error ()));
666 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
667 "Reading symbols from ..." message for automatically generated file. */
668 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
669 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
671 func_sym
= lookup_global_symbol_from_objfile (objfile
,
672 GCC_FE_WRAPPER_FUNCTION
,
674 if (func_sym
== NULL
)
675 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
676 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
677 func_type
= SYMBOL_TYPE (func_sym
);
678 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
679 error (_("Invalid type code %d of function \"%s\" in compiled "
681 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
682 objfile_name (objfile
));
686 case COMPILE_I_SIMPLE_SCOPE
:
687 expect_parameters
= 1;
688 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
690 case COMPILE_I_RAW_SCOPE
:
691 expect_parameters
= 0;
692 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
694 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
695 case COMPILE_I_PRINT_VALUE_SCOPE
:
696 expect_parameters
= 2;
697 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
700 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
702 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
703 error (_("Invalid %d parameters of function \"%s\" in compiled "
705 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
706 objfile_name (objfile
));
707 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
708 error (_("Invalid return type of function \"%s\" in compiled "
710 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
712 /* The memory may be later needed
713 by bfd_generic_get_relocated_section_contents
714 called from default_symfile_relocate. */
715 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
717 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
718 if (number_of_symbols
< 0)
719 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
720 filename
, bfd_errmsg (bfd_get_error ()));
723 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
725 asymbol
*sym
= *symp
;
729 sym
->flags
= BSF_GLOBAL
;
730 sym
->section
= bfd_abs_section_ptr
;
731 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
734 fprintf_unfiltered (gdb_stdlog
,
735 "ELF symbol \"%s\" relocated to zero\n",
738 /* It seems to be a GCC bug, with -mcmodel=large there should be no
739 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
740 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
744 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
745 switch (bmsym
.minsym
== NULL
746 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
749 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
751 fprintf_unfiltered (gdb_stdlog
,
752 "ELF mst_text symbol \"%s\" relocated to %s\n",
754 paddress (target_gdbarch (), sym
->value
));
756 case mst_text_gnu_ifunc
:
757 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
758 BMSYMBOL_VALUE_ADDRESS (bmsym
));
760 fprintf_unfiltered (gdb_stdlog
,
761 "ELF mst_text_gnu_ifunc symbol \"%s\" "
764 paddress (target_gdbarch (), sym
->value
));
767 warning (_("Could not find symbol \"%s\" "
768 "for compiled module \"%s\"."),
769 sym
->name
, filename
);
774 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
776 bfd_map_over_sections (abfd
, copy_sections
, symbol_table
);
778 regs_type
= get_regs_type (func_sym
, objfile
);
779 if (regs_type
== NULL
)
783 /* Use read-only non-executable memory protection. */
784 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
785 TYPE_LENGTH (regs_type
),
787 gdb_assert (regs_addr
!= 0);
788 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
790 fprintf_unfiltered (gdb_stdlog
,
791 "allocated %s bytes at %s for registers\n",
792 paddress (target_gdbarch (),
793 TYPE_LENGTH (regs_type
)),
794 paddress (target_gdbarch (), regs_addr
));
795 store_regs (regs_type
, regs_addr
);
798 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
799 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
801 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
802 if (out_value_type
== NULL
)
804 do_cleanups (cleanups
);
807 check_typedef (out_value_type
);
808 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
809 TYPE_LENGTH (out_value_type
),
811 | GDB_MMAP_PROT_WRITE
));
812 gdb_assert (out_value_addr
!= 0);
813 munmap_list_add (&munmap_list_head
, out_value_addr
,
814 TYPE_LENGTH (out_value_type
));
816 fprintf_unfiltered (gdb_stdlog
,
817 "allocated %s bytes at %s for printed value\n",
818 paddress (target_gdbarch (),
819 TYPE_LENGTH (out_value_type
)),
820 paddress (target_gdbarch (), out_value_addr
));
823 discard_cleanups (cleanups_free_objfile
);
825 retval
= XNEW (struct compile_module
);
826 retval
->objfile
= objfile
;
827 retval
->source_file
= xstrdup (source_file
);
828 retval
->func_sym
= func_sym
;
829 retval
->regs_addr
= regs_addr
;
830 retval
->scope
= scope
;
831 retval
->scope_data
= scope_data
;
832 retval
->out_value_type
= out_value_type
;
833 retval
->out_value_addr
= out_value_addr
;
835 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
836 retval
->munmap_list_head
= munmap_list_head
;
837 munmap_list_head
= NULL
;
839 do_cleanups (cleanups
);