1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2019 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"
31 #include "gdbthread.h"
34 #include "arch-utils.h"
37 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to the
41 munmap_list::add (CORE_ADDR addr
, CORE_ADDR size
)
43 struct munmap_item item
= { addr
, size
};
44 items
.push_back (item
);
47 /* Destroy an munmap_list. */
49 munmap_list::~munmap_list ()
51 for (auto &item
: items
)
55 gdbarch_infcall_munmap (target_gdbarch (), item
.addr
, item
.size
);
57 CATCH (ex
, RETURN_MASK_ERROR
)
59 /* There's not much the user can do, so just ignore
66 /* Helper data for setup_sections. */
68 struct setup_sections_data
70 /* Size of all recent sections with matching LAST_PROT. */
73 /* First section matching LAST_PROT. */
74 asection
*last_section_first
;
76 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
79 /* Maximum of alignments of all sections matching LAST_PROT.
80 This value is always at least 1. This value is always a power of 2. */
81 CORE_ADDR last_max_alignment
;
83 /* List of inferior mmap ranges where setup_sections should add its
85 std::unique_ptr
<struct munmap_list
> munmap_list
;
88 /* Place all ABFD sections next to each other obeying all constraints. */
91 setup_sections (bfd
*abfd
, asection
*sect
, void *data_voidp
)
93 struct setup_sections_data
*data
= (struct setup_sections_data
*) data_voidp
;
99 /* It is required by later bfd_get_relocated_section_contents. */
100 if (sect
->output_section
== NULL
)
101 sect
->output_section
= sect
;
103 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
106 /* Make the memory always readable. */
107 prot
= GDB_MMAP_PROT_READ
;
108 if ((bfd_get_section_flags (abfd
, sect
) & SEC_READONLY
) == 0)
109 prot
|= GDB_MMAP_PROT_WRITE
;
110 if ((bfd_get_section_flags (abfd
, sect
) & SEC_CODE
) != 0)
111 prot
|= GDB_MMAP_PROT_EXEC
;
114 fprintf_unfiltered (gdb_stdlog
,
115 "module \"%s\" section \"%s\" size %s prot %u\n",
116 bfd_get_filename (abfd
),
117 bfd_get_section_name (abfd
, sect
),
118 paddress (target_gdbarch (),
119 bfd_get_section_size (sect
)),
126 || (data
->last_prot
!= prot
&& bfd_get_section_size (sect
) != 0))
131 if (data
->last_size
!= 0)
133 addr
= gdbarch_infcall_mmap (target_gdbarch (), data
->last_size
,
135 data
->munmap_list
->add (addr
, data
->last_size
);
137 fprintf_unfiltered (gdb_stdlog
,
138 "allocated %s bytes at %s prot %u\n",
139 paddress (target_gdbarch (), data
->last_size
),
140 paddress (target_gdbarch (), addr
),
146 if ((addr
& (data
->last_max_alignment
- 1)) != 0)
147 error (_("Inferior compiled module address %s "
148 "is not aligned to BFD required %s."),
149 paddress (target_gdbarch (), addr
),
150 paddress (target_gdbarch (), data
->last_max_alignment
));
152 for (sect_iter
= data
->last_section_first
; sect_iter
!= sect
;
153 sect_iter
= sect_iter
->next
)
154 if ((bfd_get_section_flags (abfd
, sect_iter
) & SEC_ALLOC
) != 0)
155 bfd_set_section_vma (abfd
, sect_iter
,
156 addr
+ bfd_get_section_vma (abfd
, sect_iter
));
159 data
->last_section_first
= sect
;
160 data
->last_prot
= prot
;
161 data
->last_max_alignment
= 1;
167 alignment
= ((CORE_ADDR
) 1) << bfd_get_section_alignment (abfd
, sect
);
168 data
->last_max_alignment
= std::max (data
->last_max_alignment
, alignment
);
170 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
172 bfd_set_section_vma (abfd
, sect
, data
->last_size
);
174 data
->last_size
+= bfd_get_section_size (sect
);
175 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
178 /* Helper for link_callbacks callbacks vector. */
181 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
182 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
183 asection
*nsec
, bfd_vma nval
)
185 bfd
*abfd
= link_info
->input_bfds
;
187 if (link_info
->allow_multiple_definition
)
189 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
190 bfd_get_filename (abfd
), h
->root
.string
);
193 /* Helper for link_callbacks callbacks vector. */
196 link_callbacks_warning (struct bfd_link_info
*link_info
, const char *xwarning
,
197 const char *symbol
, bfd
*abfd
, asection
*section
,
200 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
201 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
205 /* Helper for link_callbacks callbacks vector. */
208 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
209 const char *name
, bfd
*abfd
, asection
*section
,
210 bfd_vma address
, bfd_boolean is_fatal
)
212 warning (_("Cannot resolve relocation to \"%s\" "
213 "from compiled module \"%s\" section \"%s\"."),
214 name
, bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
217 /* Helper for link_callbacks callbacks vector. */
220 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
221 struct bfd_link_hash_entry
*entry
,
222 const char *name
, const char *reloc_name
,
223 bfd_vma addend
, bfd
*abfd
, asection
*section
,
228 /* Helper for link_callbacks callbacks vector. */
231 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
232 const char *message
, bfd
*abfd
,
233 asection
*section
, bfd_vma address
)
235 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
237 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
241 /* Helper for link_callbacks callbacks vector. */
244 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
245 const char *name
, bfd
*abfd
, asection
*section
,
248 warning (_("Compiled module \"%s\" section \"%s\": unattached "
250 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
254 /* Helper for link_callbacks callbacks vector. */
256 static void link_callbacks_einfo (const char *fmt
, ...)
257 ATTRIBUTE_PRINTF (1, 2);
260 link_callbacks_einfo (const char *fmt
, ...)
265 std::string str
= string_vprintf (fmt
, ap
);
268 warning (_("Compile module: warning: %s"), str
.c_str ());
271 /* Helper for bfd_get_relocated_section_contents.
272 Only these symbols are set by bfd_simple_get_relocated_section_contents
273 but bfd/ seems to use even the NULL ones without checking them first. */
275 static const struct bfd_link_callbacks link_callbacks
=
277 NULL
, /* add_archive_element */
278 link_callbacks_multiple_definition
, /* multiple_definition */
279 NULL
, /* multiple_common */
280 NULL
, /* add_to_set */
281 NULL
, /* constructor */
282 link_callbacks_warning
, /* warning */
283 link_callbacks_undefined_symbol
, /* undefined_symbol */
284 link_callbacks_reloc_overflow
, /* reloc_overflow */
285 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
286 link_callbacks_unattached_reloc
, /* unattached_reloc */
288 link_callbacks_einfo
, /* einfo */
291 NULL
, /* override_segment_assignment */
294 struct link_hash_table_cleanup_data
296 explicit link_hash_table_cleanup_data (bfd
*abfd_
)
298 link_next (abfd
->link
.next
)
302 ~link_hash_table_cleanup_data ()
304 if (abfd
->is_linker_output
)
305 (*abfd
->link
.hash
->hash_table_free
) (abfd
);
306 abfd
->link
.next
= link_next
;
309 DISABLE_COPY_AND_ASSIGN (link_hash_table_cleanup_data
);
317 /* Relocate and store into inferior memory each section SECT of ABFD. */
320 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
322 asymbol
**symbol_table
= (asymbol
**) data
;
323 bfd_byte
*sect_data_got
;
324 struct bfd_link_info link_info
;
325 struct bfd_link_order link_order
;
326 CORE_ADDR inferior_addr
;
328 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
329 != (SEC_ALLOC
| SEC_LOAD
))
332 if (bfd_get_section_size (sect
) == 0)
335 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
336 cannot use as it does not report relocations to undefined symbols. */
337 memset (&link_info
, 0, sizeof (link_info
));
338 link_info
.output_bfd
= abfd
;
339 link_info
.input_bfds
= abfd
;
340 link_info
.input_bfds_tail
= &abfd
->link
.next
;
342 struct link_hash_table_cleanup_data
cleanup_data (abfd
);
344 abfd
->link
.next
= NULL
;
345 link_info
.hash
= bfd_link_hash_table_create (abfd
);
347 link_info
.callbacks
= &link_callbacks
;
349 memset (&link_order
, 0, sizeof (link_order
));
350 link_order
.next
= NULL
;
351 link_order
.type
= bfd_indirect_link_order
;
352 link_order
.offset
= 0;
353 link_order
.size
= bfd_get_section_size (sect
);
354 link_order
.u
.indirect
.section
= sect
;
356 gdb::unique_xmalloc_ptr
<gdb_byte
> sect_data
357 ((bfd_byte
*) xmalloc (bfd_get_section_size (sect
)));
359 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
362 FALSE
, symbol_table
);
364 if (sect_data_got
== NULL
)
365 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
366 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
367 bfd_errmsg (bfd_get_error ()));
368 gdb_assert (sect_data_got
== sect_data
.get ());
370 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
371 if (0 != target_write_memory (inferior_addr
, sect_data
.get (),
372 bfd_get_section_size (sect
)))
373 error (_("Cannot write compiled module \"%s\" section \"%s\" "
374 "to inferior memory range %s-%s."),
375 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
376 paddress (target_gdbarch (), inferior_addr
),
377 paddress (target_gdbarch (),
378 inferior_addr
+ bfd_get_section_size (sect
)));
381 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
382 symbols in OBJFILE so we can calculate how much memory to allocate
383 for the out parameter. This avoids needing a malloc in the generated
384 code. Throw an error if anything fails.
385 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
386 If it finds user tries to print an array type this function returns
387 NULL. Caller will then regenerate the code with
388 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
389 This is because __auto_type array-to-pointer type conversion of
390 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
391 preserving the array type. */
394 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
395 enum compile_i_scope_types scope
)
397 struct symbol
*gdb_ptr_type_sym
;
398 /* Initialize it just to avoid a GCC false warning. */
399 struct symbol
*gdb_val_sym
= NULL
;
400 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
401 /* Initialize it just to avoid a GCC false warning. */
402 const struct block
*block
= NULL
;
403 const struct blockvector
*bv
;
407 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
408 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
410 gdb_ptr_type_sym
= NULL
;
411 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
413 struct symbol
*function
= NULL
;
414 const struct block
*function_block
;
416 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
417 if (BLOCK_FUNCTION (block
) != NULL
)
419 gdb_val_sym
= block_lookup_symbol (block
,
421 symbol_name_match_type::SEARCH_NAME
,
423 if (gdb_val_sym
== NULL
)
426 function_block
= block
;
427 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
428 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
430 function_block
= BLOCK_SUPERBLOCK (function_block
);
431 function
= BLOCK_FUNCTION (function_block
);
432 if (function
!= NULL
)
436 && (BLOCK_SUPERBLOCK (function_block
)
437 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
438 && (strcmp_iw (SYMBOL_LINKAGE_NAME (function
),
439 GCC_FE_WRAPPER_FUNCTION
)
443 if (block_loop
== nblocks
)
444 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
446 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
447 gdb_type
= check_typedef (gdb_type
);
449 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
450 symbol_name_match_type::SEARCH_NAME
,
452 if (gdb_ptr_type_sym
== NULL
)
453 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
454 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
455 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
456 if (TYPE_CODE (gdb_ptr_type
) != TYPE_CODE_PTR
)
457 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
458 gdb_type_from_ptr
= check_typedef (TYPE_TARGET_TYPE (gdb_ptr_type
));
460 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
462 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
463 error (_("Expected address scope in compiled module \"%s\"."),
464 objfile_name (objfile
));
468 if (TYPE_CODE (gdb_type
) != TYPE_CODE_PTR
)
469 error (_("Invalid type code %d of symbol \"%s\" "
470 "in compiled module \"%s\"."),
471 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_VAL
,
472 objfile_name (objfile
));
474 retval
= gdb_type_from_ptr
;
475 switch (TYPE_CODE (gdb_type_from_ptr
))
477 case TYPE_CODE_ARRAY
:
478 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
483 error (_("Invalid type code %d of symbol \"%s\" "
484 "in compiled module \"%s\"."),
485 TYPE_CODE (gdb_type_from_ptr
), COMPILE_I_EXPR_PTR_TYPE
,
486 objfile_name (objfile
));
488 if (!types_deeply_equal (gdb_type_from_ptr
,
489 TYPE_TARGET_TYPE (gdb_type
)))
490 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
491 "in compiled module \"%s\"."),
492 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
493 objfile_name (objfile
));
494 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
499 /* Fetch the type of first parameter of FUNC_SYM.
500 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
503 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
505 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
506 struct type
*regsp_type
, *regs_type
;
508 /* No register parameter present. */
509 if (TYPE_NFIELDS (func_type
) == 0)
512 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
513 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
514 error (_("Invalid type code %d of first parameter of function \"%s\" "
515 "in compiled module \"%s\"."),
516 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
517 objfile_name (objfile
));
519 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
520 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
521 error (_("Invalid type code %d of dereferenced first parameter "
522 "of function \"%s\" in compiled module \"%s\"."),
523 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
524 objfile_name (objfile
));
529 /* Store all inferior registers required by REGS_TYPE to inferior memory
530 starting at inferior address REGS_BASE. */
533 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
535 struct gdbarch
*gdbarch
= target_gdbarch ();
538 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
540 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
541 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
542 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
544 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
546 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
548 struct value
*regval
;
549 CORE_ADDR inferior_addr
;
551 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
554 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
555 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
556 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
557 reg_offset
= reg_bitpos
/ 8;
559 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
560 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
561 error (_("Invalid register \"%s\" type code %d"), reg_name
,
562 TYPE_CODE (reg_type
));
564 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
566 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
567 if (value_optimized_out (regval
))
568 error (_("Register \"%s\" is optimized out."), reg_name
);
569 if (!value_entirely_available (regval
))
570 error (_("Register \"%s\" is not available."), reg_name
);
572 inferior_addr
= regs_base
+ reg_offset
;
573 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
575 error (_("Cannot write register \"%s\" to inferior memory at %s."),
576 reg_name
, paddress (gdbarch
, inferior_addr
));
580 /* Load the object file specified in FILE_NAMES into inferior memory.
581 Throw an error otherwise. Caller must fully dispose the return
582 value by calling compile_object_run. Returns NULL only for
583 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
584 should have been used instead. */
586 struct compile_module
*
587 compile_object_load (const compile_file_names
&file_names
,
588 enum compile_i_scope_types scope
, void *scope_data
)
590 struct setup_sections_data setup_sections_data
;
591 CORE_ADDR regs_addr
, out_value_addr
= 0;
592 struct symbol
*func_sym
;
593 struct type
*func_type
;
594 struct bound_minimal_symbol bmsym
;
596 asymbol
**symbol_table
, **symp
;
597 long number_of_symbols
, missing_symbols
;
598 struct compile_module
*retval
;
599 struct type
*regs_type
, *out_value_type
= NULL
;
601 struct objfile
*objfile
;
602 int expect_parameters
;
603 struct type
*expect_return_type
;
605 gdb::unique_xmalloc_ptr
<char> filename
606 (tilde_expand (file_names
.object_file ()));
608 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
, -1));
610 error (_("\"%s\": could not open as compiled module: %s"),
611 filename
.get (), bfd_errmsg (bfd_get_error ()));
613 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
614 error (_("\"%s\": not in loadable format: %s"),
616 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
618 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
619 error (_("\"%s\": not in object format."), filename
.get ());
621 setup_sections_data
.last_size
= 0;
622 setup_sections_data
.last_section_first
= abfd
->sections
;
623 setup_sections_data
.last_prot
= -1;
624 setup_sections_data
.last_max_alignment
= 1;
625 setup_sections_data
.munmap_list
.reset (new struct munmap_list
);
627 bfd_map_over_sections (abfd
.get (), setup_sections
, &setup_sections_data
);
628 setup_sections (abfd
.get (), NULL
, &setup_sections_data
);
630 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
631 if (storage_needed
< 0)
632 error (_("Cannot read symbols of compiled module \"%s\": %s"),
633 filename
.get (), bfd_errmsg (bfd_get_error ()));
635 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
636 "Reading symbols from ..." message for automatically generated file. */
637 std::unique_ptr
<struct objfile
> objfile_holder
638 (symbol_file_add_from_bfd (abfd
.get (), filename
.get (),
640 objfile
= objfile_holder
.get ();
642 func_sym
= lookup_global_symbol_from_objfile (objfile
,
643 GCC_FE_WRAPPER_FUNCTION
,
645 if (func_sym
== NULL
)
646 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
647 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
648 func_type
= SYMBOL_TYPE (func_sym
);
649 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
650 error (_("Invalid type code %d of function \"%s\" in compiled "
652 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
653 objfile_name (objfile
));
657 case COMPILE_I_SIMPLE_SCOPE
:
658 expect_parameters
= 1;
659 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
661 case COMPILE_I_RAW_SCOPE
:
662 expect_parameters
= 0;
663 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
665 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
666 case COMPILE_I_PRINT_VALUE_SCOPE
:
667 expect_parameters
= 2;
668 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
671 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
673 if (TYPE_NFIELDS (func_type
) != expect_parameters
)
674 error (_("Invalid %d parameters of function \"%s\" in compiled "
676 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
677 objfile_name (objfile
));
678 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
679 error (_("Invalid return type of function \"%s\" in compiled "
681 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
683 /* The memory may be later needed
684 by bfd_generic_get_relocated_section_contents
685 called from default_symfile_relocate. */
686 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
688 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
689 if (number_of_symbols
< 0)
690 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
691 filename
.get (), bfd_errmsg (bfd_get_error ()));
694 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
696 asymbol
*sym
= *symp
;
700 sym
->flags
= BSF_GLOBAL
;
701 sym
->section
= bfd_abs_section_ptr
;
702 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
705 fprintf_unfiltered (gdb_stdlog
,
706 "ELF symbol \"%s\" relocated to zero\n",
709 /* It seems to be a GCC bug, with -mcmodel=large there should be no
710 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
711 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
715 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
716 switch (bmsym
.minsym
== NULL
717 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
722 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
724 fprintf_unfiltered (gdb_stdlog
,
725 "ELF mst_text symbol \"%s\" relocated to %s\n",
727 paddress (target_gdbarch (), sym
->value
));
729 case mst_text_gnu_ifunc
:
730 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
731 BMSYMBOL_VALUE_ADDRESS (bmsym
));
733 fprintf_unfiltered (gdb_stdlog
,
734 "ELF mst_text_gnu_ifunc symbol \"%s\" "
737 paddress (target_gdbarch (), sym
->value
));
740 warning (_("Could not find symbol \"%s\" "
741 "for compiled module \"%s\"."),
742 sym
->name
, filename
.get ());
747 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
749 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
751 regs_type
= get_regs_type (func_sym
, objfile
);
752 if (regs_type
== NULL
)
756 /* Use read-only non-executable memory protection. */
757 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
758 TYPE_LENGTH (regs_type
),
760 gdb_assert (regs_addr
!= 0);
761 setup_sections_data
.munmap_list
->add (regs_addr
, TYPE_LENGTH (regs_type
));
763 fprintf_unfiltered (gdb_stdlog
,
764 "allocated %s bytes at %s for registers\n",
765 paddress (target_gdbarch (),
766 TYPE_LENGTH (regs_type
)),
767 paddress (target_gdbarch (), regs_addr
));
768 store_regs (regs_type
, regs_addr
);
771 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
772 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
774 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
775 if (out_value_type
== NULL
)
777 check_typedef (out_value_type
);
778 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
779 TYPE_LENGTH (out_value_type
),
781 | GDB_MMAP_PROT_WRITE
));
782 gdb_assert (out_value_addr
!= 0);
783 setup_sections_data
.munmap_list
->add (out_value_addr
,
784 TYPE_LENGTH (out_value_type
));
786 fprintf_unfiltered (gdb_stdlog
,
787 "allocated %s bytes at %s for printed value\n",
788 paddress (target_gdbarch (),
789 TYPE_LENGTH (out_value_type
)),
790 paddress (target_gdbarch (), out_value_addr
));
793 retval
= XNEW (struct compile_module
);
794 retval
->objfile
= objfile_holder
.release ();
795 retval
->source_file
= xstrdup (file_names
.source_file ());
796 retval
->func_sym
= func_sym
;
797 retval
->regs_addr
= regs_addr
;
798 retval
->scope
= scope
;
799 retval
->scope_data
= scope_data
;
800 retval
->out_value_type
= out_value_type
;
801 retval
->out_value_addr
= out_value_addr
;
802 retval
->munmap_list_head
= setup_sections_data
.munmap_list
.release ();