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"
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
= XNEW (struct munmap_list
);
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
= (struct munmap_list
**) 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
= (struct setup_sections_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
);
214 /* Helper for link_callbacks callbacks vector. */
217 link_callbacks_warning (struct bfd_link_info
*link_info
, const char *xwarning
,
218 const char *symbol
, bfd
*abfd
, asection
*section
,
221 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
222 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
226 /* Helper for link_callbacks callbacks vector. */
229 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
230 const char *name
, bfd
*abfd
, asection
*section
,
231 bfd_vma address
, bfd_boolean is_fatal
)
233 warning (_("Cannot resolve relocation to \"%s\" "
234 "from compiled module \"%s\" section \"%s\"."),
235 name
, bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
238 /* Helper for link_callbacks callbacks vector. */
241 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
242 struct bfd_link_hash_entry
*entry
,
243 const char *name
, const char *reloc_name
,
244 bfd_vma addend
, bfd
*abfd
, asection
*section
,
249 /* Helper for link_callbacks callbacks vector. */
252 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
253 const char *message
, bfd
*abfd
,
254 asection
*section
, bfd_vma address
)
256 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
258 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
262 /* Helper for link_callbacks callbacks vector. */
265 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
266 const char *name
, bfd
*abfd
, asection
*section
,
269 warning (_("Compiled module \"%s\" section \"%s\": unattached "
271 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
275 /* Helper for link_callbacks callbacks vector. */
277 static void link_callbacks_einfo (const char *fmt
, ...)
278 ATTRIBUTE_PRINTF (1, 2);
281 link_callbacks_einfo (const char *fmt
, ...)
283 struct cleanup
*cleanups
;
288 str
= xstrvprintf (fmt
, ap
);
290 cleanups
= make_cleanup (xfree
, str
);
292 warning (_("Compile module: warning: %s"), str
);
294 do_cleanups (cleanups
);
297 /* Helper for bfd_get_relocated_section_contents.
298 Only these symbols are set by bfd_simple_get_relocated_section_contents
299 but bfd/ seems to use even the NULL ones without checking them first. */
301 static const struct bfd_link_callbacks link_callbacks
=
303 NULL
, /* add_archive_element */
304 link_callbacks_multiple_definition
, /* multiple_definition */
305 NULL
, /* multiple_common */
306 NULL
, /* add_to_set */
307 NULL
, /* constructor */
308 link_callbacks_warning
, /* warning */
309 link_callbacks_undefined_symbol
, /* undefined_symbol */
310 link_callbacks_reloc_overflow
, /* reloc_overflow */
311 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
312 link_callbacks_unattached_reloc
, /* unattached_reloc */
314 link_callbacks_einfo
, /* einfo */
317 NULL
, /* override_segment_assignment */
320 struct link_hash_table_cleanup_data
326 /* Cleanup callback for struct bfd_link_info. */
329 link_hash_table_free (void *d
)
331 struct link_hash_table_cleanup_data
*data
332 = (struct link_hash_table_cleanup_data
*) d
;
334 if (data
->abfd
->is_linker_output
)
335 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
336 data
->abfd
->link
.next
= data
->link_next
;
339 /* Relocate and store into inferior memory each section SECT of ABFD. */
342 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
344 asymbol
**symbol_table
= (asymbol
**) data
;
345 bfd_byte
*sect_data
, *sect_data_got
;
346 struct cleanup
*cleanups
;
347 struct bfd_link_info link_info
;
348 struct bfd_link_order link_order
;
349 CORE_ADDR inferior_addr
;
350 struct link_hash_table_cleanup_data cleanup_data
;
352 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
353 != (SEC_ALLOC
| SEC_LOAD
))
356 if (bfd_get_section_size (sect
) == 0)
359 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
360 cannot use as it does not report relocations to undefined symbols. */
361 memset (&link_info
, 0, sizeof (link_info
));
362 link_info
.output_bfd
= abfd
;
363 link_info
.input_bfds
= abfd
;
364 link_info
.input_bfds_tail
= &abfd
->link
.next
;
366 cleanup_data
.abfd
= abfd
;
367 cleanup_data
.link_next
= abfd
->link
.next
;
369 abfd
->link
.next
= NULL
;
370 link_info
.hash
= bfd_link_hash_table_create (abfd
);
372 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
373 link_info
.callbacks
= &link_callbacks
;
375 memset (&link_order
, 0, sizeof (link_order
));
376 link_order
.next
= NULL
;
377 link_order
.type
= bfd_indirect_link_order
;
378 link_order
.offset
= 0;
379 link_order
.size
= bfd_get_section_size (sect
);
380 link_order
.u
.indirect
.section
= sect
;
382 sect_data
= (bfd_byte
*) xmalloc (bfd_get_section_size (sect
));
383 make_cleanup (xfree
, sect_data
);
385 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
386 &link_order
, sect_data
,
387 FALSE
, symbol_table
);
389 if (sect_data_got
== NULL
)
390 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
391 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
392 bfd_errmsg (bfd_get_error ()));
393 gdb_assert (sect_data_got
== sect_data
);
395 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
396 if (0 != target_write_memory (inferior_addr
, sect_data
,
397 bfd_get_section_size (sect
)))
398 error (_("Cannot write compiled module \"%s\" section \"%s\" "
399 "to inferior memory range %s-%s."),
400 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
401 paddress (target_gdbarch (), inferior_addr
),
402 paddress (target_gdbarch (),
403 inferior_addr
+ bfd_get_section_size (sect
)));
405 do_cleanups (cleanups
);
408 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
409 symbols in OBJFILE so we can calculate how much memory to allocate
410 for the out parameter. This avoids needing a malloc in the generated
411 code. Throw an error if anything fails.
412 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
413 If it finds user tries to print an array type this function returns
414 NULL. Caller will then regenerate the code with
415 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
416 This is because __auto_type array-to-pointer type conversion of
417 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
418 preserving the array type. */
421 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
422 enum compile_i_scope_types scope
)
424 struct symbol
*gdb_ptr_type_sym
;
425 /* Initialize it just to avoid a GCC false warning. */
426 struct symbol
*gdb_val_sym
= NULL
;
427 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
428 /* Initialize it just to avoid a GCC false warning. */
429 const struct block
*block
= NULL
;
430 const struct blockvector
*bv
;
434 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
435 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
437 gdb_ptr_type_sym
= NULL
;
438 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
440 struct symbol
*function
= NULL
;
441 const struct block
*function_block
;
443 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
444 if (BLOCK_FUNCTION (block
) != NULL
)
446 gdb_val_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_VAL
, VAR_DOMAIN
);
447 if (gdb_val_sym
== NULL
)
450 function_block
= block
;
451 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
452 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
454 function_block
= BLOCK_SUPERBLOCK (function_block
);
455 function
= BLOCK_FUNCTION (function_block
);
456 if (function
!= NULL
)
460 && (BLOCK_SUPERBLOCK (function_block
)
461 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
462 && (strcmp (SYMBOL_LINKAGE_NAME (function
), GCC_FE_WRAPPER_FUNCTION
)
466 if (block_loop
== nblocks
)
467 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
469 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
470 gdb_type
= check_typedef (gdb_type
);
472 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
474 if (gdb_ptr_type_sym
== NULL
)
475 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
476 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
477 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
478 if (TYPE_CODE (gdb_ptr_type
) != TYPE_CODE_PTR
)
479 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
480 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_ptr_type
);
482 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
484 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
485 error (_("Expected address scope in compiled module \"%s\"."),
486 objfile_name (objfile
));
490 if (TYPE_CODE (gdb_type
) != TYPE_CODE_PTR
)
491 error (_("Invalid type code %d of symbol \"%s\" "
492 "in compiled module \"%s\"."),
493 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_VAL
,
494 objfile_name (objfile
));
496 retval
= gdb_type_from_ptr
;
497 switch (TYPE_CODE (gdb_type_from_ptr
))
499 case TYPE_CODE_ARRAY
:
500 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
505 error (_("Invalid type code %d of symbol \"%s\" "
506 "in compiled module \"%s\"."),
507 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_PTR_TYPE
,
508 objfile_name (objfile
));
510 if (!types_deeply_equal (gdb_type_from_ptr
,
511 TYPE_TARGET_TYPE (gdb_type
)))
512 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
513 "in compiled module \"%s\"."),
514 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
515 objfile_name (objfile
));
516 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
521 /* Fetch the type of first parameter of FUNC_SYM.
522 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
525 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
527 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
528 struct type
*regsp_type
, *regs_type
;
530 /* No register parameter present. */
531 if (TYPE_NFIELDS (func_type
) == 0)
534 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
535 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
536 error (_("Invalid type code %d of first parameter of function \"%s\" "
537 "in compiled module \"%s\"."),
538 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
539 objfile_name (objfile
));
541 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
542 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
543 error (_("Invalid type code %d of dereferenced first parameter "
544 "of function \"%s\" in compiled module \"%s\"."),
545 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
546 objfile_name (objfile
));
551 /* Store all inferior registers required by REGS_TYPE to inferior memory
552 starting at inferior address REGS_BASE. */
555 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
557 struct gdbarch
*gdbarch
= target_gdbarch ();
558 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
561 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
563 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
564 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
565 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
567 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
569 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
571 struct value
*regval
;
572 CORE_ADDR inferior_addr
;
574 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
577 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
578 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
579 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
580 reg_offset
= reg_bitpos
/ 8;
582 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
583 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
584 error (_("Invalid register \"%s\" type code %d"), reg_name
,
585 TYPE_CODE (reg_type
));
587 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
589 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
590 if (value_optimized_out (regval
))
591 error (_("Register \"%s\" is optimized out."), reg_name
);
592 if (!value_entirely_available (regval
))
593 error (_("Register \"%s\" is not available."), reg_name
);
595 inferior_addr
= regs_base
+ reg_offset
;
596 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
598 error (_("Cannot write register \"%s\" to inferior memory at %s."),
599 reg_name
, paddress (gdbarch
, inferior_addr
));
603 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
604 Caller must fully dispose the return value by calling compile_object_run.
605 SOURCE_FILE's copy is stored into the returned object.
606 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
608 Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when
609 COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */
611 struct compile_module
*
612 compile_object_load (const char *object_file
, const char *source_file
,
613 enum compile_i_scope_types scope
, void *scope_data
)
615 struct cleanup
*cleanups
, *cleanups_free_objfile
;
617 struct setup_sections_data setup_sections_data
;
618 CORE_ADDR addr
, regs_addr
, out_value_addr
= 0;
619 struct symbol
*func_sym
;
620 struct type
*func_type
;
621 struct bound_minimal_symbol bmsym
;
623 asymbol
**symbol_table
, **symp
;
624 long number_of_symbols
, missing_symbols
;
625 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
626 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
627 struct compile_module
*retval
;
628 struct type
*regs_type
, *out_value_type
= NULL
;
629 char *filename
, **matching
;
630 struct objfile
*objfile
;
631 int expect_parameters
;
632 struct type
*expect_return_type
;
633 struct munmap_list
*munmap_list_head
= NULL
;
635 filename
= tilde_expand (object_file
);
636 cleanups
= make_cleanup (xfree
, filename
);
638 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
640 error (_("\"%s\": could not open as compiled module: %s"),
641 filename
, bfd_errmsg (bfd_get_error ()));
642 make_cleanup_bfd_unref (abfd
);
644 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
645 error (_("\"%s\": not in loadable format: %s"),
646 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
648 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
649 error (_("\"%s\": not in object format."), filename
);
651 setup_sections_data
.last_size
= 0;
652 setup_sections_data
.last_section_first
= abfd
->sections
;
653 setup_sections_data
.last_prot
= -1;
654 setup_sections_data
.last_max_alignment
= 1;
655 setup_sections_data
.munmap_list_headp
= &munmap_list_head
;
656 make_cleanup (munmap_listp_free_cleanup
, &munmap_list_head
);
657 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
658 setup_sections (abfd
, NULL
, &setup_sections_data
);
660 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
661 if (storage_needed
< 0)
662 error (_("Cannot read symbols of compiled module \"%s\": %s"),
663 filename
, bfd_errmsg (bfd_get_error ()));
665 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
666 "Reading symbols from ..." message for automatically generated file. */
667 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
668 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
670 func_sym
= lookup_global_symbol_from_objfile (objfile
,
671 GCC_FE_WRAPPER_FUNCTION
,
673 if (func_sym
== NULL
)
674 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
675 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
676 func_type
= SYMBOL_TYPE (func_sym
);
677 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
678 error (_("Invalid type code %d of function \"%s\" in compiled "
680 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
681 objfile_name (objfile
));
685 case COMPILE_I_SIMPLE_SCOPE
:
686 expect_parameters
= 1;
687 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
689 case COMPILE_I_RAW_SCOPE
:
690 expect_parameters
= 0;
691 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
693 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
694 case COMPILE_I_PRINT_VALUE_SCOPE
:
695 expect_parameters
= 2;
696 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
699 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
701 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
702 error (_("Invalid %d parameters of function \"%s\" in compiled "
704 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
705 objfile_name (objfile
));
706 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
707 error (_("Invalid return type of function \"%s\" in compiled "
709 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
711 /* The memory may be later needed
712 by bfd_generic_get_relocated_section_contents
713 called from default_symfile_relocate. */
714 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
716 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
717 if (number_of_symbols
< 0)
718 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
719 filename
, bfd_errmsg (bfd_get_error ()));
722 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
724 asymbol
*sym
= *symp
;
728 sym
->flags
= BSF_GLOBAL
;
729 sym
->section
= bfd_abs_section_ptr
;
730 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
733 fprintf_unfiltered (gdb_stdlog
,
734 "ELF symbol \"%s\" relocated to zero\n",
737 /* It seems to be a GCC bug, with -mcmodel=large there should be no
738 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
739 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
743 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
744 switch (bmsym
.minsym
== NULL
745 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
748 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
750 fprintf_unfiltered (gdb_stdlog
,
751 "ELF mst_text symbol \"%s\" relocated to %s\n",
753 paddress (target_gdbarch (), sym
->value
));
755 case mst_text_gnu_ifunc
:
756 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
757 BMSYMBOL_VALUE_ADDRESS (bmsym
));
759 fprintf_unfiltered (gdb_stdlog
,
760 "ELF mst_text_gnu_ifunc symbol \"%s\" "
763 paddress (target_gdbarch (), sym
->value
));
766 warning (_("Could not find symbol \"%s\" "
767 "for compiled module \"%s\"."),
768 sym
->name
, filename
);
773 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
775 bfd_map_over_sections (abfd
, copy_sections
, symbol_table
);
777 regs_type
= get_regs_type (func_sym
, objfile
);
778 if (regs_type
== NULL
)
782 /* Use read-only non-executable memory protection. */
783 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
784 TYPE_LENGTH (regs_type
),
786 gdb_assert (regs_addr
!= 0);
787 munmap_list_add (&munmap_list_head
, regs_addr
, TYPE_LENGTH (regs_type
));
789 fprintf_unfiltered (gdb_stdlog
,
790 "allocated %s bytes at %s for registers\n",
791 paddress (target_gdbarch (),
792 TYPE_LENGTH (regs_type
)),
793 paddress (target_gdbarch (), regs_addr
));
794 store_regs (regs_type
, regs_addr
);
797 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
798 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
800 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
801 if (out_value_type
== NULL
)
803 do_cleanups (cleanups
);
806 check_typedef (out_value_type
);
807 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
808 TYPE_LENGTH (out_value_type
),
810 | GDB_MMAP_PROT_WRITE
));
811 gdb_assert (out_value_addr
!= 0);
812 munmap_list_add (&munmap_list_head
, out_value_addr
,
813 TYPE_LENGTH (out_value_type
));
815 fprintf_unfiltered (gdb_stdlog
,
816 "allocated %s bytes at %s for printed value\n",
817 paddress (target_gdbarch (),
818 TYPE_LENGTH (out_value_type
)),
819 paddress (target_gdbarch (), out_value_addr
));
822 discard_cleanups (cleanups_free_objfile
);
824 retval
= XNEW (struct compile_module
);
825 retval
->objfile
= objfile
;
826 retval
->source_file
= xstrdup (source_file
);
827 retval
->func_sym
= func_sym
;
828 retval
->regs_addr
= regs_addr
;
829 retval
->scope
= scope
;
830 retval
->scope_data
= scope_data
;
831 retval
->out_value_type
= out_value_type
;
832 retval
->out_value_addr
= out_value_addr
;
834 /* CLEANUPS will free MUNMAP_LIST_HEAD. */
835 retval
->munmap_list_head
= munmap_list_head
;
836 munmap_list_head
= NULL
;
838 do_cleanups (cleanups
);