1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2023 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 (current_inferior ()->arch (),
56 item
.addr
, item
.size
);
58 catch (const gdb_exception_error
&ex
)
60 /* There's not much the user can do, so just ignore
66 /* A data structure that is used to lay out sections of our objfile in
69 struct setup_sections_data
71 explicit setup_sections_data (bfd
*abfd
)
73 m_last_section_first (abfd
->sections
)
77 /* Place all ABFD sections next to each other obeying all
79 void setup_one_section (asection
*sect
);
81 /* List of inferior mmap ranges where setup_sections should add its
83 struct munmap_list munmap_list
;
90 /* Size of all recent sections with matching LAST_PROT. */
91 CORE_ADDR m_last_size
= 0;
93 /* First section matching LAST_PROT. */
94 asection
*m_last_section_first
;
96 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
97 unsigned m_last_prot
= -1;
99 /* Maximum of alignments of all sections matching LAST_PROT.
100 This value is always at least 1. This value is always a power of 2. */
101 CORE_ADDR m_last_max_alignment
= -1;
105 /* See setup_sections_data. */
108 setup_sections_data::setup_one_section (asection
*sect
)
115 /* It is required by later bfd_get_relocated_section_contents. */
116 if (sect
->output_section
== NULL
)
117 sect
->output_section
= sect
;
119 if ((bfd_section_flags (sect
) & SEC_ALLOC
) == 0)
122 /* Make the memory always readable. */
123 prot
= GDB_MMAP_PROT_READ
;
124 if ((bfd_section_flags (sect
) & SEC_READONLY
) == 0)
125 prot
|= GDB_MMAP_PROT_WRITE
;
126 if ((bfd_section_flags (sect
) & SEC_CODE
) != 0)
127 prot
|= GDB_MMAP_PROT_EXEC
;
130 gdb_printf (gdb_stdlog
,
131 "module \"%s\" section \"%s\" size %s prot %u\n",
132 bfd_get_filename (m_bfd
),
133 bfd_section_name (sect
),
134 paddress (current_inferior ()->arch (),
135 bfd_section_size (sect
)),
142 || (m_last_prot
!= prot
&& bfd_section_size (sect
) != 0))
147 if (m_last_size
!= 0)
149 addr
= gdbarch_infcall_mmap (current_inferior ()->arch (),
150 m_last_size
, m_last_prot
);
151 munmap_list
.add (addr
, m_last_size
);
153 gdb_printf (gdb_stdlog
,
154 "allocated %s bytes at %s prot %u\n",
155 paddress (current_inferior ()->arch (), m_last_size
),
156 paddress (current_inferior ()->arch (), addr
),
162 if ((addr
& (m_last_max_alignment
- 1)) != 0)
163 error (_("Inferior compiled module address %s "
164 "is not aligned to BFD required %s."),
165 paddress (current_inferior ()->arch (), addr
),
166 paddress (current_inferior ()->arch (), m_last_max_alignment
));
168 for (sect_iter
= m_last_section_first
; sect_iter
!= sect
;
169 sect_iter
= sect_iter
->next
)
170 if ((bfd_section_flags (sect_iter
) & SEC_ALLOC
) != 0)
171 bfd_set_section_vma (sect_iter
, addr
+ bfd_section_vma (sect_iter
));
174 m_last_section_first
= sect
;
176 m_last_max_alignment
= 1;
182 alignment
= ((CORE_ADDR
) 1) << bfd_section_alignment (sect
);
183 m_last_max_alignment
= std::max (m_last_max_alignment
, alignment
);
185 m_last_size
= (m_last_size
+ alignment
- 1) & -alignment
;
187 bfd_set_section_vma (sect
, m_last_size
);
189 m_last_size
+= bfd_section_size (sect
);
190 m_last_size
= (m_last_size
+ alignment
- 1) & -alignment
;
193 /* Helper for link_callbacks callbacks vector. */
196 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
197 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
198 asection
*nsec
, bfd_vma nval
)
200 bfd
*abfd
= link_info
->input_bfds
;
202 if (link_info
->allow_multiple_definition
)
204 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
205 bfd_get_filename (abfd
), h
->root
.string
);
208 /* Helper for link_callbacks callbacks vector. */
211 link_callbacks_warning (struct bfd_link_info
*link_info
, const char *xwarning
,
212 const char *symbol
, bfd
*abfd
, asection
*section
,
215 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
216 bfd_get_filename (abfd
), bfd_section_name (section
),
220 /* Helper for link_callbacks callbacks vector. */
223 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
224 const char *name
, bfd
*abfd
, asection
*section
,
225 bfd_vma address
, bfd_boolean is_fatal
)
227 warning (_("Cannot resolve relocation to \"%s\" "
228 "from compiled module \"%s\" section \"%s\"."),
229 name
, bfd_get_filename (abfd
), bfd_section_name (section
));
232 /* Helper for link_callbacks callbacks vector. */
235 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
236 struct bfd_link_hash_entry
*entry
,
237 const char *name
, const char *reloc_name
,
238 bfd_vma addend
, bfd
*abfd
, asection
*section
,
243 /* Helper for link_callbacks callbacks vector. */
246 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
247 const char *message
, bfd
*abfd
,
248 asection
*section
, bfd_vma address
)
250 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
252 bfd_get_filename (abfd
), bfd_section_name (section
),
256 /* Helper for link_callbacks callbacks vector. */
259 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
260 const char *name
, bfd
*abfd
, asection
*section
,
263 warning (_("Compiled module \"%s\" section \"%s\": unattached "
265 bfd_get_filename (abfd
), bfd_section_name (section
),
269 /* Helper for link_callbacks callbacks vector. */
271 static void link_callbacks_einfo (const char *fmt
, ...)
272 ATTRIBUTE_PRINTF (1, 2);
275 link_callbacks_einfo (const char *fmt
, ...)
280 std::string str
= string_vprintf (fmt
, ap
);
283 warning (_("Compile module: warning: %s"), str
.c_str ());
286 /* Helper for bfd_get_relocated_section_contents.
287 Only these symbols are set by bfd_simple_get_relocated_section_contents
288 but bfd/ seems to use even the NULL ones without checking them first. */
290 static const struct bfd_link_callbacks link_callbacks
=
292 NULL
, /* add_archive_element */
293 link_callbacks_multiple_definition
, /* multiple_definition */
294 NULL
, /* multiple_common */
295 NULL
, /* add_to_set */
296 NULL
, /* constructor */
297 link_callbacks_warning
, /* warning */
298 link_callbacks_undefined_symbol
, /* undefined_symbol */
299 link_callbacks_reloc_overflow
, /* reloc_overflow */
300 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
301 link_callbacks_unattached_reloc
, /* unattached_reloc */
303 link_callbacks_einfo
, /* einfo */
306 NULL
, /* override_segment_assignment */
309 struct link_hash_table_cleanup_data
311 explicit link_hash_table_cleanup_data (bfd
*abfd_
)
313 link_next (abfd
->link
.next
)
317 ~link_hash_table_cleanup_data ()
319 if (abfd
->is_linker_output
)
320 (*abfd
->link
.hash
->hash_table_free
) (abfd
);
321 abfd
->link
.next
= link_next
;
324 DISABLE_COPY_AND_ASSIGN (link_hash_table_cleanup_data
);
332 /* Relocate and store into inferior memory each section SECT of ABFD. */
335 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
337 asymbol
**symbol_table
= (asymbol
**) data
;
338 bfd_byte
*sect_data_got
;
339 struct bfd_link_info link_info
;
340 struct bfd_link_order link_order
;
341 CORE_ADDR inferior_addr
;
343 if ((bfd_section_flags (sect
) & (SEC_ALLOC
| SEC_LOAD
))
344 != (SEC_ALLOC
| SEC_LOAD
))
347 if (bfd_section_size (sect
) == 0)
350 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
351 cannot use as it does not report relocations to undefined symbols. */
352 memset (&link_info
, 0, sizeof (link_info
));
353 link_info
.output_bfd
= abfd
;
354 link_info
.input_bfds
= abfd
;
355 link_info
.input_bfds_tail
= &abfd
->link
.next
;
357 struct link_hash_table_cleanup_data
cleanup_data (abfd
);
359 abfd
->link
.next
= NULL
;
360 link_info
.hash
= bfd_link_hash_table_create (abfd
);
362 link_info
.callbacks
= &link_callbacks
;
364 memset (&link_order
, 0, sizeof (link_order
));
365 link_order
.next
= NULL
;
366 link_order
.type
= bfd_indirect_link_order
;
367 link_order
.offset
= 0;
368 link_order
.size
= bfd_section_size (sect
);
369 link_order
.u
.indirect
.section
= sect
;
371 gdb::unique_xmalloc_ptr
<gdb_byte
> sect_data
372 ((bfd_byte
*) xmalloc (bfd_section_size (sect
)));
374 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
377 FALSE
, symbol_table
);
379 if (sect_data_got
== NULL
)
380 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
381 bfd_get_filename (abfd
), bfd_section_name (sect
),
382 bfd_errmsg (bfd_get_error ()));
383 gdb_assert (sect_data_got
== sect_data
.get ());
385 inferior_addr
= bfd_section_vma (sect
);
386 if (0 != target_write_memory (inferior_addr
, sect_data
.get (),
387 bfd_section_size (sect
)))
388 error (_("Cannot write compiled module \"%s\" section \"%s\" "
389 "to inferior memory range %s-%s."),
390 bfd_get_filename (abfd
), bfd_section_name (sect
),
391 paddress (current_inferior ()->arch (), inferior_addr
),
392 paddress (current_inferior ()->arch (),
393 inferior_addr
+ bfd_section_size (sect
)));
396 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
397 symbols in OBJFILE so we can calculate how much memory to allocate
398 for the out parameter. This avoids needing a malloc in the generated
399 code. Throw an error if anything fails.
400 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
401 If it finds user tries to print an array type this function returns
402 NULL. Caller will then regenerate the code with
403 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
404 This is because __auto_type array-to-pointer type conversion of
405 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
406 preserving the array type. */
409 get_out_value_type (struct symbol
*func_sym
, struct objfile
*objfile
,
410 enum compile_i_scope_types scope
)
412 struct symbol
*gdb_ptr_type_sym
;
413 /* Initialize it just to avoid a GCC false warning. */
414 struct symbol
*gdb_val_sym
= NULL
;
415 struct type
*gdb_ptr_type
, *gdb_type_from_ptr
, *gdb_type
, *retval
;
416 /* Initialize it just to avoid a GCC false warning. */
417 const struct block
*block
= NULL
;
418 const struct blockvector
*bv
;
422 lookup_name_info
func_matcher (GCC_FE_WRAPPER_FUNCTION
,
423 symbol_name_match_type::SEARCH_NAME
);
425 bv
= func_sym
->symtab ()->compunit ()->blockvector ();
426 nblocks
= bv
->num_blocks ();
428 gdb_ptr_type_sym
= NULL
;
429 for (block_loop
= 0; block_loop
< nblocks
; block_loop
++)
431 struct symbol
*function
= NULL
;
432 const struct block
*function_block
;
434 block
= bv
->block (block_loop
);
435 if (block
->function () != NULL
)
437 gdb_val_sym
= block_lookup_symbol (block
,
439 symbol_name_match_type::SEARCH_NAME
,
441 if (gdb_val_sym
== NULL
)
444 function_block
= block
;
445 while (function_block
!= bv
->static_block ()
446 && function_block
!= bv
->global_block ())
448 function_block
= function_block
->superblock ();
449 function
= function_block
->function ();
450 if (function
!= NULL
)
454 && function_block
->superblock () == 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
= gdb_val_sym
->type ();
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
= gdb_ptr_type_sym
->type ();
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 (gdb_ptr_type
->target_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
= gdb_type_from_ptr
->target_type ();
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 gdb_type
->target_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
= func_sym
->type ();
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 (regsp_type
->target_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 gdbarch
*gdbarch
= current_inferior ()->arch ();
553 for (fieldno
= 0; fieldno
< regs_type
->num_fields (); fieldno
++)
555 const char *reg_name
= regs_type
->field (fieldno
).name ();
556 ULONGEST reg_bitpos
= regs_type
->field (fieldno
).loc_bitpos ();
557 ULONGEST reg_bitsize
= regs_type
->field (fieldno
).bitsize ();
559 struct type
*reg_type
560 = check_typedef (regs_type
->field (fieldno
).type ());
561 ULONGEST reg_size
= reg_type
->length ();
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 (regval
->optimized_out ())
583 error (_("Register \"%s\" is optimized out."), reg_name
);
584 if (!regval
->entirely_available ())
585 error (_("Register \"%s\" is not available."), reg_name
);
587 inferior_addr
= regs_base
+ reg_offset
;
588 if (0 != target_write_memory (inferior_addr
,
589 regval
->contents ().data (),
591 error (_("Cannot write register \"%s\" to inferior memory at %s."),
592 reg_name
, paddress (gdbarch
, inferior_addr
));
596 /* Load the object file specified in FILE_NAMES into inferior memory.
597 Throw an error otherwise. Caller must fully dispose the return
598 value by calling compile_object_run. Returns NULL only for
599 COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
600 should have been used instead. */
603 compile_object_load (const compile_file_names
&file_names
,
604 enum compile_i_scope_types scope
, void *scope_data
)
606 CORE_ADDR regs_addr
, out_value_addr
= 0;
607 struct symbol
*func_sym
;
608 struct type
*func_type
;
609 struct bound_minimal_symbol bmsym
;
611 asymbol
**symbol_table
, **symp
;
612 long number_of_symbols
, missing_symbols
;
613 struct type
*regs_type
, *out_value_type
= NULL
;
615 struct objfile
*objfile
;
616 int expect_parameters
;
617 struct type
*expect_return_type
;
619 gdb::unique_xmalloc_ptr
<char> filename
620 (tilde_expand (file_names
.object_file ()));
622 gdb_bfd_ref_ptr
abfd (gdb_bfd_open (filename
.get (), gnutarget
));
624 error (_("\"%s\": could not open as compiled module: %s"),
625 filename
.get (), bfd_errmsg (bfd_get_error ()));
627 if (!bfd_check_format_matches (abfd
.get (), bfd_object
, &matching
))
628 error (_("\"%s\": not in loadable format: %s"),
630 gdb_bfd_errmsg (bfd_get_error (), matching
).c_str ());
632 if ((bfd_get_file_flags (abfd
.get ()) & (EXEC_P
| DYNAMIC
)) != 0)
633 error (_("\"%s\": not in object format."), filename
.get ());
635 struct setup_sections_data
setup_sections_data (abfd
.get ());
636 for (asection
*sect
= abfd
->sections
; sect
!= nullptr; sect
= sect
->next
)
637 setup_sections_data
.setup_one_section (sect
);
638 setup_sections_data
.setup_one_section (nullptr);
640 storage_needed
= bfd_get_symtab_upper_bound (abfd
.get ());
641 if (storage_needed
< 0)
642 error (_("Cannot read symbols of compiled module \"%s\": %s"),
643 filename
.get (), bfd_errmsg (bfd_get_error ()));
645 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
646 "Reading symbols from ..." message for automatically generated file. */
647 objfile_up
objfile_holder (symbol_file_add_from_bfd (abfd
,
650 objfile
= objfile_holder
.get ();
652 func_sym
= lookup_global_symbol_from_objfile (objfile
,
654 GCC_FE_WRAPPER_FUNCTION
,
656 if (func_sym
== NULL
)
657 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
658 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
659 func_type
= func_sym
->type ();
660 if (func_type
->code () != TYPE_CODE_FUNC
)
661 error (_("Invalid type code %d of function \"%s\" in compiled "
663 func_type
->code (), GCC_FE_WRAPPER_FUNCTION
,
664 objfile_name (objfile
));
668 case COMPILE_I_SIMPLE_SCOPE
:
669 expect_parameters
= 1;
671 = builtin_type (current_inferior ()->arch ())->builtin_void
;
673 case COMPILE_I_RAW_SCOPE
:
674 expect_parameters
= 0;
676 = builtin_type (current_inferior ()->arch ())->builtin_void
;
678 case COMPILE_I_PRINT_ADDRESS_SCOPE
:
679 case COMPILE_I_PRINT_VALUE_SCOPE
:
680 expect_parameters
= 2;
682 = builtin_type (current_inferior ()->arch ())->builtin_void
;
685 internal_error (_("invalid scope %d"), scope
);
687 if (func_type
->num_fields () != expect_parameters
)
688 error (_("Invalid %d parameters of function \"%s\" in compiled "
690 func_type
->num_fields (), GCC_FE_WRAPPER_FUNCTION
,
691 objfile_name (objfile
));
692 if (!types_deeply_equal (expect_return_type
, func_type
->target_type ()))
693 error (_("Invalid return type of function \"%s\" in compiled "
695 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
697 /* The memory may be later needed
698 by bfd_generic_get_relocated_section_contents
699 called from default_symfile_relocate. */
700 symbol_table
= (asymbol
**) obstack_alloc (&objfile
->objfile_obstack
,
702 number_of_symbols
= bfd_canonicalize_symtab (abfd
.get (), symbol_table
);
703 if (number_of_symbols
< 0)
704 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
705 filename
.get (), bfd_errmsg (bfd_get_error ()));
708 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
710 asymbol
*sym
= *symp
;
714 sym
->flags
= BSF_GLOBAL
;
715 sym
->section
= bfd_abs_section_ptr
;
716 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
719 gdb_printf (gdb_stdlog
,
720 "ELF symbol \"%s\" relocated to zero\n",
723 /* It seems to be a GCC bug, with -mcmodel=large there should be no
724 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data
725 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */
729 if (strcmp (sym
->name
, ".TOC.") == 0)
731 /* Handle the .TOC. symbol as the linker would do. Set the .TOC.
732 sections value to 0x8000 (see bfd/elf64-ppc.c TOC_BASE_OFF);
733 point the symbol section at the ".toc" section;
734 and pass the toc->vma value into bfd_set_gp_value().
735 If the .toc section is not found, use the first section
736 with the SEC_ALLOC flag set. In the unlikely case that
737 we still do not have a section identified, fall back to using
738 the "*ABS*" section. */
739 asection
*toc_fallback
= bfd_get_section_by_name(abfd
.get(), ".toc");
740 if (toc_fallback
== NULL
)
742 for (asection
*tsect
= abfd
->sections
; tsect
!= nullptr;
745 if (bfd_section_flags (tsect
) & SEC_ALLOC
)
747 toc_fallback
= tsect
;
753 if (toc_fallback
== NULL
)
754 /* If we've gotten here, we have not found a section usable
755 as a backup for the .toc section. In this case, use the
756 absolute (*ABS*) section. */
757 toc_fallback
= bfd_abs_section_ptr
;
759 sym
->section
= toc_fallback
;
761 bfd_set_gp_value(abfd
.get(), toc_fallback
->vma
);
763 gdb_printf (gdb_stdlog
,
764 "Connecting ELF symbol \"%s\" to the .toc section (%s)\n",
766 paddress (current_inferior ()->arch (), sym
->value
));
770 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
771 switch (bmsym
.minsym
== NULL
772 ? mst_unknown
: bmsym
.minsym
->type ())
777 sym
->value
= bmsym
.value_address ();
779 gdb_printf (gdb_stdlog
,
780 "ELF mst_text symbol \"%s\" relocated to %s\n",
782 paddress (current_inferior ()->arch (), sym
->value
));
784 case mst_text_gnu_ifunc
:
785 sym
->value
= gnu_ifunc_resolve_addr (current_inferior ()->arch (),
786 bmsym
.value_address ());
788 gdb_printf (gdb_stdlog
,
789 "ELF mst_text_gnu_ifunc symbol \"%s\" "
792 paddress (current_inferior ()->arch (), sym
->value
));
795 warning (_("Could not find symbol \"%s\" "
796 "for compiled module \"%s\"."),
797 sym
->name
, filename
.get ());
802 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
804 bfd_map_over_sections (abfd
.get (), copy_sections
, symbol_table
);
806 regs_type
= get_regs_type (func_sym
, objfile
);
807 if (regs_type
== NULL
)
811 /* Use read-only non-executable memory protection. */
812 regs_addr
= gdbarch_infcall_mmap (current_inferior ()->arch (),
813 regs_type
->length (),
815 gdb_assert (regs_addr
!= 0);
816 setup_sections_data
.munmap_list
.add (regs_addr
, regs_type
->length ());
818 gdb_printf (gdb_stdlog
,
819 "allocated %s bytes at %s for registers\n",
820 paddress (current_inferior ()->arch (),
821 regs_type
->length ()),
822 paddress (current_inferior ()->arch (), regs_addr
));
823 store_regs (regs_type
, regs_addr
);
826 if (scope
== COMPILE_I_PRINT_ADDRESS_SCOPE
827 || scope
== COMPILE_I_PRINT_VALUE_SCOPE
)
829 out_value_type
= get_out_value_type (func_sym
, objfile
, scope
);
830 if (out_value_type
== NULL
)
832 check_typedef (out_value_type
);
833 out_value_addr
= gdbarch_infcall_mmap (current_inferior ()->arch (),
834 out_value_type
->length (),
836 | GDB_MMAP_PROT_WRITE
));
837 gdb_assert (out_value_addr
!= 0);
838 setup_sections_data
.munmap_list
.add (out_value_addr
,
839 out_value_type
->length ());
841 gdb_printf (gdb_stdlog
,
842 "allocated %s bytes at %s for printed value\n",
843 paddress (current_inferior ()->arch (),
844 out_value_type
->length ()),
845 paddress (current_inferior ()->arch (), out_value_addr
));
848 compile_module_up
retval (new struct compile_module
);
849 retval
->objfile
= objfile_holder
.release ();
850 retval
->source_file
= file_names
.source_file ();
851 retval
->func_sym
= func_sym
;
852 retval
->regs_addr
= regs_addr
;
853 retval
->scope
= scope
;
854 retval
->scope_data
= scope_data
;
855 retval
->out_value_type
= out_value_type
;
856 retval
->out_value_addr
= out_value_addr
;
857 retval
->munmap_list
= std::move (setup_sections_data
.munmap_list
);