1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2020 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 (const gdb_exception_error
&ex
)
59 /* There's not much the user can do, so just ignore
65 /* A data structure that is used to lay out sections of our objfile in
68 struct setup_sections_data
70 explicit setup_sections_data (bfd
*abfd
)
72 m_last_section_first (abfd
->sections
)
76 /* Place all ABFD sections next to each other obeying all
78 void setup_one_section (asection
*sect
);
80 /* List of inferior mmap ranges where setup_sections should add its
82 struct munmap_list munmap_list
;
89 /* Size of all recent sections with matching LAST_PROT. */
90 CORE_ADDR m_last_size
= 0;
92 /* First section matching LAST_PROT. */
93 asection
*m_last_section_first
;
95 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
96 unsigned m_last_prot
= -1;
98 /* Maximum of alignments of all sections matching LAST_PROT.
99 This value is always at least 1. This value is always a power of 2. */
100 CORE_ADDR m_last_max_alignment
= -1;
104 /* See setup_sections_data. */
107 setup_sections_data::setup_one_section (asection
*sect
)
114 /* It is required by later bfd_get_relocated_section_contents. */
115 if (sect
->output_section
== NULL
)
116 sect
->output_section
= sect
;
118 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
121 /* Make the memory always readable. */
122 prot
= GDB_MMAP_PROT_READ
;
123 if ((bfd_section_flags (sect
) & SEC_READONLY
) == 0)
124 prot
|= GDB_MMAP_PROT_WRITE
;
125 if ((bfd_section_flags (sect
) & SEC_CODE
) != 0)
126 prot
|= GDB_MMAP_PROT_EXEC
;
129 fprintf_unfiltered (gdb_stdlog
,
130 "module \"%s\" section \"%s\" size %s prot %u\n",
131 bfd_get_filename (m_bfd
),
132 bfd_section_name (sect
),
133 paddress (target_gdbarch (),
134 bfd_section_size (sect
)),
141 || (m_last_prot
!= prot
&& bfd_section_size (sect
) != 0))
146 if (m_last_size
!= 0)
148 addr
= gdbarch_infcall_mmap (target_gdbarch (), m_last_size
,
150 munmap_list
.add (addr
, m_last_size
);
152 fprintf_unfiltered (gdb_stdlog
,
153 "allocated %s bytes at %s prot %u\n",
154 paddress (target_gdbarch (), m_last_size
),
155 paddress (target_gdbarch (), addr
),
161 if ((addr
& (m_last_max_alignment
- 1)) != 0)
162 error (_("Inferior compiled module address %s "
163 "is not aligned to BFD required %s."),
164 paddress (target_gdbarch (), addr
),
165 paddress (target_gdbarch (), m_last_max_alignment
));
167 for (sect_iter
= m_last_section_first
; sect_iter
!= sect
;
168 sect_iter
= sect_iter
->next
)
169 if ((bfd_section_flags (sect_iter
) & SEC_ALLOC
) != 0)
170 bfd_set_section_vma (sect_iter
, addr
+ bfd_section_vma (sect_iter
));
173 m_last_section_first
= sect
;
175 m_last_max_alignment
= 1;
181 alignment
= ((CORE_ADDR
) 1) << bfd_section_alignment (sect
);
182 m_last_max_alignment
= std::max (m_last_max_alignment
, alignment
);
184 m_last_size
= (m_last_size
+ alignment
- 1) & -alignment
;
186 bfd_set_section_vma (sect
, m_last_size
);
188 m_last_size
+= bfd_section_size (sect
);
189 m_last_size
= (m_last_size
+ alignment
- 1) & -alignment
;
192 /* Helper for link_callbacks callbacks vector. */
195 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
196 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
197 asection
*nsec
, bfd_vma nval
)
199 bfd
*abfd
= link_info
->input_bfds
;
201 if (link_info
->allow_multiple_definition
)
203 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
204 bfd_get_filename (abfd
), h
->root
.string
);
207 /* Helper for link_callbacks callbacks vector. */
210 link_callbacks_warning (struct bfd_link_info
*link_info
, const char *xwarning
,
211 const char *symbol
, bfd
*abfd
, asection
*section
,
214 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
215 bfd_get_filename (abfd
), bfd_section_name (section
),
219 /* Helper for link_callbacks callbacks vector. */
222 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
223 const char *name
, bfd
*abfd
, asection
*section
,
224 bfd_vma address
, bfd_boolean is_fatal
)
226 warning (_("Cannot resolve relocation to \"%s\" "
227 "from compiled module \"%s\" section \"%s\"."),
228 name
, bfd_get_filename (abfd
), bfd_section_name (section
));
231 /* Helper for link_callbacks callbacks vector. */
234 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
235 struct bfd_link_hash_entry
*entry
,
236 const char *name
, const char *reloc_name
,
237 bfd_vma addend
, bfd
*abfd
, asection
*section
,
242 /* Helper for link_callbacks callbacks vector. */
245 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
246 const char *message
, bfd
*abfd
,
247 asection
*section
, bfd_vma address
)
249 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
251 bfd_get_filename (abfd
), bfd_section_name (section
),
255 /* Helper for link_callbacks callbacks vector. */
258 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
259 const char *name
, bfd
*abfd
, asection
*section
,
262 warning (_("Compiled module \"%s\" section \"%s\": unattached "
264 bfd_get_filename (abfd
), bfd_section_name (section
),
268 /* Helper for link_callbacks callbacks vector. */
270 static void link_callbacks_einfo (const char *fmt
, ...)
271 ATTRIBUTE_PRINTF (1, 2);
274 link_callbacks_einfo (const char *fmt
, ...)
279 std::string str
= string_vprintf (fmt
, ap
);
282 warning (_("Compile module: warning: %s"), str
.c_str ());
285 /* Helper for bfd_get_relocated_section_contents.
286 Only these symbols are set by bfd_simple_get_relocated_section_contents
287 but bfd/ seems to use even the NULL ones without checking them first. */
289 static const struct bfd_link_callbacks link_callbacks
=
291 NULL
, /* add_archive_element */
292 link_callbacks_multiple_definition
, /* multiple_definition */
293 NULL
, /* multiple_common */
294 NULL
, /* add_to_set */
295 NULL
, /* constructor */
296 link_callbacks_warning
, /* warning */
297 link_callbacks_undefined_symbol
, /* undefined_symbol */
298 link_callbacks_reloc_overflow
, /* reloc_overflow */
299 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
300 link_callbacks_unattached_reloc
, /* unattached_reloc */
302 link_callbacks_einfo
, /* einfo */
305 NULL
, /* override_segment_assignment */
308 struct link_hash_table_cleanup_data
310 explicit link_hash_table_cleanup_data (bfd
*abfd_
)
312 link_next (abfd
->link
.next
)
316 ~link_hash_table_cleanup_data ()
318 if (abfd
->is_linker_output
)
319 (*abfd
->link
.hash
->hash_table_free
) (abfd
);
320 abfd
->link
.next
= link_next
;
323 DISABLE_COPY_AND_ASSIGN (link_hash_table_cleanup_data
);
331 /* Relocate and store into inferior memory each section SECT of ABFD. */
334 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
336 asymbol
**symbol_table
= (asymbol
**) data
;
337 bfd_byte
*sect_data_got
;
338 struct bfd_link_info link_info
;
339 struct bfd_link_order link_order
;
340 CORE_ADDR inferior_addr
;
342 if ((bfd_section_flags (sect
) & (SEC_ALLOC
| SEC_LOAD
))
343 != (SEC_ALLOC
| SEC_LOAD
))
346 if (bfd_section_size (sect
) == 0)
349 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
350 cannot use as it does not report relocations to undefined symbols. */
351 memset (&link_info
, 0, sizeof (link_info
));
352 link_info
.output_bfd
= abfd
;
353 link_info
.input_bfds
= abfd
;
354 link_info
.input_bfds_tail
= &abfd
->link
.next
;
356 struct link_hash_table_cleanup_data
cleanup_data (abfd
);
358 abfd
->link
.next
= NULL
;
359 link_info
.hash
= bfd_link_hash_table_create (abfd
);
361 link_info
.callbacks
= &link_callbacks
;
363 memset (&link_order
, 0, sizeof (link_order
));
364 link_order
.next
= NULL
;
365 link_order
.type
= bfd_indirect_link_order
;
366 link_order
.offset
= 0;
367 link_order
.size
= bfd_section_size (sect
);
368 link_order
.u
.indirect
.section
= sect
;
370 gdb::unique_xmalloc_ptr
<gdb_byte
> sect_data
371 ((bfd_byte
*) xmalloc (bfd_section_size (sect
)));
373 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
376 FALSE
, symbol_table
);
378 if (sect_data_got
== NULL
)
379 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
380 bfd_get_filename (abfd
), bfd_section_name (sect
),
381 bfd_errmsg (bfd_get_error ()));
382 gdb_assert (sect_data_got
== sect_data
.get ());
384 inferior_addr
= bfd_section_vma (sect
);
385 if (0 != target_write_memory (inferior_addr
, sect_data
.get (),
386 bfd_section_size (sect
)))
387 error (_("Cannot write compiled module \"%s\" section \"%s\" "
388 "to inferior memory range %s-%s."),
389 bfd_get_filename (abfd
), bfd_section_name (sect
),
390 paddress (target_gdbarch (), inferior_addr
),
391 paddress (target_gdbarch (),
392 inferior_addr
+ bfd_section_size (sect
)));
395 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
396 symbols in OBJFILE so we can calculate how much memory to allocate
397 for the out parameter. This avoids needing a malloc in the generated
398 code. Throw an error if anything fails.
399 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
400 If it finds user tries to print an array type this function returns
401 NULL. Caller will then regenerate the code with
402 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
403 This is because __auto_type array-to-pointer type conversion of
404 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
405 preserving the array type. */
408 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
409 enum compile_i_scope_types scope
)
411 struct symbol
*gdb_ptr_type_sym
;
412 /* Initialize it just to avoid a GCC false warning. */
413 struct symbol
*gdb_val_sym
= NULL
;
414 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
415 /* Initialize it just to avoid a GCC false warning. */
416 const struct block
*block
= NULL
;
417 const struct blockvector
*bv
;
421 lookup_name_info
func_matcher (GCC_FE_WRAPPER_FUNCTION
,
422 symbol_name_match_type::SEARCH_NAME
);
424 bv
= SYMTAB_BLOCKVECTOR (func_sym
->owner
.symtab
);
425 nblocks
= BLOCKVECTOR_NBLOCKS (bv
);
427 gdb_ptr_type_sym
= NULL
;
428 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
430 struct symbol
*function
= NULL
;
431 const struct block
*function_block
;
433 block
= BLOCKVECTOR_BLOCK (bv
, block_loop
);
434 if (BLOCK_FUNCTION (block
) != NULL
)
436 gdb_val_sym
= block_lookup_symbol (block
,
438 symbol_name_match_type::SEARCH_NAME
,
440 if (gdb_val_sym
== NULL
)
443 function_block
= block
;
444 while (function_block
!= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
)
445 && function_block
!= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
))
447 function_block
= BLOCK_SUPERBLOCK (function_block
);
448 function
= BLOCK_FUNCTION (function_block
);
449 if (function
!= NULL
)
453 && (BLOCK_SUPERBLOCK (function_block
)
454 == BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
))
455 && symbol_matches_search_name (function
, func_matcher
))
458 if (block_loop
== nblocks
)
459 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_VAL
);
461 gdb_type
= SYMBOL_TYPE (gdb_val_sym
);
462 gdb_type
= check_typedef (gdb_type
);
464 gdb_ptr_type_sym
= block_lookup_symbol (block
, COMPILE_I_EXPR_PTR_TYPE
,
465 symbol_name_match_type::SEARCH_NAME
,
467 if (gdb_ptr_type_sym
== NULL
)
468 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE
);
469 gdb_ptr_type
= SYMBOL_TYPE (gdb_ptr_type_sym
);
470 gdb_ptr_type
= check_typedef (gdb_ptr_type
);
471 if (gdb_ptr_type
->code () != TYPE_CODE_PTR
)
472 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE
);
473 gdb_type_from_ptr
= check_typedef (TYPE_TARGET_TYPE (gdb_ptr_type
));
475 if (types_deeply_equal (gdb_type
, gdb_type_from_ptr
))
477 if (scope
!= COMPILE_I_PRINT_ADDRESS_SCOPE
)
478 error (_("Expected address scope in compiled module \"%s\"."),
479 objfile_name (objfile
));
483 if (gdb_type
->code () != TYPE_CODE_PTR
)
484 error (_("Invalid type code %d of symbol \"%s\" "
485 "in compiled module \"%s\"."),
486 gdb_type_from_ptr
->code (), COMPILE_I_EXPR_VAL
,
487 objfile_name (objfile
));
489 retval
= gdb_type_from_ptr
;
490 switch (gdb_type_from_ptr
->code ())
492 case TYPE_CODE_ARRAY
:
493 gdb_type_from_ptr
= TYPE_TARGET_TYPE (gdb_type_from_ptr
);
498 error (_("Invalid type code %d of symbol \"%s\" "
499 "in compiled module \"%s\"."),
500 gdb_type_from_ptr
->code (), COMPILE_I_EXPR_PTR_TYPE
,
501 objfile_name (objfile
));
503 if (!types_deeply_equal (gdb_type_from_ptr
,
504 TYPE_TARGET_TYPE (gdb_type
)))
505 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
506 "in compiled module \"%s\"."),
507 COMPILE_I_EXPR_PTR_TYPE
, COMPILE_I_EXPR_VAL
,
508 objfile_name (objfile
));
509 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
)
514 /* Fetch the type of first parameter of FUNC_SYM.
515 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */
518 get_regs_type (struct symbol
*func_sym
, struct objfile
*objfile
)
520 struct type
*func_type
= SYMBOL_TYPE (func_sym
);
521 struct type
*regsp_type
, *regs_type
;
523 /* No register parameter present. */
524 if (func_type
->num_fields () == 0)
527 regsp_type
= check_typedef (func_type
->field (0).type ());
528 if (regsp_type
->code () != TYPE_CODE_PTR
)
529 error (_("Invalid type code %d of first parameter of function \"%s\" "
530 "in compiled module \"%s\"."),
531 regsp_type
->code (), GCC_FE_WRAPPER_FUNCTION
,
532 objfile_name (objfile
));
534 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
535 if (regs_type
->code () != TYPE_CODE_STRUCT
)
536 error (_("Invalid type code %d of dereferenced first parameter "
537 "of function \"%s\" in compiled module \"%s\"."),
538 regs_type
->code (), GCC_FE_WRAPPER_FUNCTION
,
539 objfile_name (objfile
));
544 /* Store all inferior registers required by REGS_TYPE to inferior memory
545 starting at inferior address REGS_BASE. */
548 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
550 struct gdbarch
*gdbarch
= target_gdbarch ();
553 for (fieldno
= 0; fieldno
< regs_type
->num_fields (); fieldno
++)
555 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
556 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
557 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
559 struct type
*reg_type
560 = check_typedef (regs_type
->field (fieldno
).type ());
561 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
563 struct value
*regval
;
564 CORE_ADDR inferior_addr
;
566 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
569 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
570 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
571 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
572 reg_offset
= reg_bitpos
/ 8;
574 if (reg_type
->code () != TYPE_CODE_INT
575 && reg_type
->code () != TYPE_CODE_PTR
)
576 error (_("Invalid register \"%s\" type code %d"), reg_name
,
579 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
581 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
582 if (value_optimized_out (regval
))
583 error (_("Register \"%s\" is optimized out."), reg_name
);
584 if (!value_entirely_available (regval
))
585 error (_("Register \"%s\" is not available."), reg_name
);
587 inferior_addr
= regs_base
+ reg_offset
;
588 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
590 error (_("Cannot write register \"%s\" to inferior memory at %s."),
591 reg_name
, paddress (gdbarch
, inferior_addr
));
595 /* Load the object file specified in FILE_NAMES into inferior memory.
596 Throw an error otherwise. Caller must fully dispose the return
597 value by calling compile_object_run. Returns NULL only for
598 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
599 should have been used instead. */
602 compile_object_load (const compile_file_names
&file_names
,
603 enum compile_i_scope_types scope
, void *scope_data
)
605 CORE_ADDR regs_addr
, out_value_addr
= 0;
606 struct symbol
*func_sym
;
607 struct type
*func_type
;
608 struct bound_minimal_symbol bmsym
;
610 asymbol
**symbol_table
, **symp
;
611 long number_of_symbols
, missing_symbols
;
612 struct type
*regs_type
, *out_value_type
= NULL
;
614 struct objfile
*objfile
;
615 int expect_parameters
;
616 struct type
*expect_return_type
;
618 gdb::unique_xmalloc_ptr
<char> filename
619 (tilde_expand (file_names
.object_file ()));
621 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
));
623 error (_("\"%s\": could not open as compiled module: %s"),
624 filename
.get (), bfd_errmsg (bfd_get_error ()));
626 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
627 error (_("\"%s\": not in loadable format: %s"),
629 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
631 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
632 error (_("\"%s\": not in object format."), filename
.get ());
634 struct setup_sections_data
setup_sections_data (abfd
.get ());
635 for (asection
*sect
= abfd
->sections
; sect
!= nullptr; sect
= sect
->next
)
636 setup_sections_data
.setup_one_section (sect
);
637 setup_sections_data
.setup_one_section (nullptr);
639 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
640 if (storage_needed
< 0)
641 error (_("Cannot read symbols of compiled module \"%s\": %s"),
642 filename
.get (), bfd_errmsg (bfd_get_error ()));
644 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
645 "Reading symbols from ..." message for automatically generated file. */
646 objfile_up
objfile_holder (symbol_file_add_from_bfd (abfd
.get (),
649 objfile
= objfile_holder
.get ();
651 func_sym
= lookup_global_symbol_from_objfile (objfile
,
653 GCC_FE_WRAPPER_FUNCTION
,
655 if (func_sym
== NULL
)
656 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
657 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
658 func_type
= SYMBOL_TYPE (func_sym
);
659 if (func_type
->code () != TYPE_CODE_FUNC
)
660 error (_("Invalid type code %d of function \"%s\" in compiled "
662 func_type
->code (), GCC_FE_WRAPPER_FUNCTION
,
663 objfile_name (objfile
));
667 case COMPILE_I_SIMPLE_SCOPE
:
668 expect_parameters
= 1;
669 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
671 case COMPILE_I_RAW_SCOPE
:
672 expect_parameters
= 0;
673 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
675 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
676 case COMPILE_I_PRINT_VALUE_SCOPE
:
677 expect_parameters
= 2;
678 expect_return_type
= builtin_type (target_gdbarch ())->builtin_void
;
681 internal_error (__FILE__
, __LINE__
, _("invalid scope %d"), scope
);
683 if (func_type
->num_fields () != expect_parameters
)
684 error (_("Invalid %d parameters of function \"%s\" in compiled "
686 func_type
->num_fields (), GCC_FE_WRAPPER_FUNCTION
,
687 objfile_name (objfile
));
688 if (!types_deeply_equal (expect_return_type
, TYPE_TARGET_TYPE (func_type
)))
689 error (_("Invalid return type of function \"%s\" in compiled "
691 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
693 /* The memory may be later needed
694 by bfd_generic_get_relocated_section_contents
695 called from default_symfile_relocate. */
696 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
698 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
699 if (number_of_symbols
< 0)
700 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
701 filename
.get (), bfd_errmsg (bfd_get_error ()));
704 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
706 asymbol
*sym
= *symp
;
710 sym
->flags
= BSF_GLOBAL
;
711 sym
->section
= bfd_abs_section_ptr
;
712 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
715 fprintf_unfiltered (gdb_stdlog
,
716 "ELF symbol \"%s\" relocated to zero\n",
719 /* It seems to be a GCC bug, with -mcmodel=large there should be no
720 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
721 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
725 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
726 switch (bmsym
.minsym
== NULL
727 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
732 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
734 fprintf_unfiltered (gdb_stdlog
,
735 "ELF mst_text symbol \"%s\" relocated to %s\n",
737 paddress (target_gdbarch (), sym
->value
));
739 case mst_text_gnu_ifunc
:
740 sym
->value
= gnu_ifunc_resolve_addr (target_gdbarch (),
741 BMSYMBOL_VALUE_ADDRESS (bmsym
));
743 fprintf_unfiltered (gdb_stdlog
,
744 "ELF mst_text_gnu_ifunc symbol \"%s\" "
747 paddress (target_gdbarch (), sym
->value
));
750 warning (_("Could not find symbol \"%s\" "
751 "for compiled module \"%s\"."),
752 sym
->name
, filename
.get ());
757 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
759 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
761 regs_type
= get_regs_type (func_sym
, objfile
);
762 if (regs_type
== NULL
)
766 /* Use read-only non-executable memory protection. */
767 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
768 TYPE_LENGTH (regs_type
),
770 gdb_assert (regs_addr
!= 0);
771 setup_sections_data
.munmap_list
.add (regs_addr
, TYPE_LENGTH (regs_type
));
773 fprintf_unfiltered (gdb_stdlog
,
774 "allocated %s bytes at %s for registers\n",
775 paddress (target_gdbarch (),
776 TYPE_LENGTH (regs_type
)),
777 paddress (target_gdbarch (), regs_addr
));
778 store_regs (regs_type
, regs_addr
);
781 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
782 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
784 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
785 if (out_value_type
== NULL
)
787 check_typedef (out_value_type
);
788 out_value_addr
= gdbarch_infcall_mmap (target_gdbarch (),
789 TYPE_LENGTH (out_value_type
),
791 | GDB_MMAP_PROT_WRITE
));
792 gdb_assert (out_value_addr
!= 0);
793 setup_sections_data
.munmap_list
.add (out_value_addr
,
794 TYPE_LENGTH (out_value_type
));
796 fprintf_unfiltered (gdb_stdlog
,
797 "allocated %s bytes at %s for printed value\n",
798 paddress (target_gdbarch (),
799 TYPE_LENGTH (out_value_type
)),
800 paddress (target_gdbarch (), out_value_addr
));
803 compile_module_up
retval (new struct compile_module
);
804 retval
->objfile
= objfile_holder
.release ();
805 retval
->source_file
= file_names
.source_file ();
806 retval
->func_sym
= func_sym
;
807 retval
->regs_addr
= regs_addr
;
808 retval
->scope
= scope
;
809 retval
->scope_data
= scope_data
;
810 retval
->out_value_type
= out_value_type
;
811 retval
->out_value_addr
= out_value_addr
;
812 retval
->munmap_list
= std::move (setup_sections_data
.munmap_list
);