1 /* Load module for 'compile' command.
3 Copyright (C) 2014 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"
32 #include "arch-utils.h"
34 /* Helper data for setup_sections. */
36 struct setup_sections_data
38 /* Size of all recent sections with matching LAST_PROT. */
41 /* First section matching LAST_PROT. */
42 asection
*last_section_first
;
44 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
47 /* Maximum of alignments of all sections matching LAST_PROT.
48 This value is always at least 1. This value is always a power of 2. */
49 CORE_ADDR last_max_alignment
;
52 /* Place all ABFD sections next to each other obeying all constraints. */
55 setup_sections (bfd
*abfd
, asection
*sect
, void *data_voidp
)
57 struct setup_sections_data
*data
= data_voidp
;
63 /* It is required by later bfd_get_relocated_section_contents. */
64 if (sect
->output_section
== NULL
)
65 sect
->output_section
= sect
;
67 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
70 // Make the memory always readable.
71 prot
= GDB_MMAP_PROT_READ
;
72 if ((bfd_get_section_flags (abfd
, sect
) & SEC_READONLY
) == 0)
73 prot
|= GDB_MMAP_PROT_WRITE
;
74 if ((bfd_get_section_flags (abfd
, sect
) & SEC_CODE
) != 0)
75 prot
|= GDB_MMAP_PROT_EXEC
;
78 fprintf_unfiltered (gdb_stdout
,
79 "module \"%s\" section \"%s\" size %s prot %u\n",
80 bfd_get_filename (abfd
),
81 bfd_get_section_name (abfd
, sect
),
82 paddress (target_gdbarch (),
83 bfd_get_section_size (sect
)),
90 || (data
->last_prot
!= prot
&& bfd_get_section_size (sect
) != 0))
95 if (data
->last_size
!= 0)
97 addr
= gdbarch_infcall_mmap (target_gdbarch (), data
->last_size
,
100 fprintf_unfiltered (gdb_stdout
,
101 "allocated %s bytes at %s prot %u\n",
102 paddress (target_gdbarch (), data
->last_size
),
103 paddress (target_gdbarch (), addr
),
109 if ((addr
& (data
->last_max_alignment
- 1)) != 0)
110 error (_("Inferior compiled module address %s "
111 "is not aligned to BFD required %s."),
112 paddress (target_gdbarch (), addr
),
113 paddress (target_gdbarch (), data
->last_max_alignment
));
115 for (sect_iter
= data
->last_section_first
; sect_iter
!= sect
;
116 sect_iter
= sect_iter
->next
)
117 if ((bfd_get_section_flags (abfd
, sect_iter
) & SEC_ALLOC
) != 0)
118 bfd_set_section_vma (abfd
, sect_iter
,
119 addr
+ bfd_get_section_vma (abfd
, sect_iter
));
122 data
->last_section_first
= sect
;
123 data
->last_prot
= prot
;
124 data
->last_max_alignment
= 1;
130 alignment
= ((CORE_ADDR
) 1) << bfd_get_section_alignment (abfd
, sect
);
131 data
->last_max_alignment
= max (data
->last_max_alignment
, alignment
);
133 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
135 bfd_set_section_vma (abfd
, sect
, data
->last_size
);
137 data
->last_size
+= bfd_get_section_size (sect
);
138 data
->last_size
= (data
->last_size
+ alignment
- 1) & -alignment
;
141 /* Helper for link_callbacks callbacks vector. */
144 link_callbacks_multiple_definition (struct bfd_link_info
*link_info
,
145 struct bfd_link_hash_entry
*h
, bfd
*nbfd
,
146 asection
*nsec
, bfd_vma nval
)
148 bfd
*abfd
= link_info
->input_bfds
;
150 if (link_info
->allow_multiple_definition
)
152 warning (_("Compiled module \"%s\": multiple symbol definitions: %s\n"),
153 bfd_get_filename (abfd
), h
->root
.string
);
157 /* Helper for link_callbacks callbacks vector. */
160 link_callbacks_warning (struct bfd_link_info
*link_info
, const char *xwarning
,
161 const char *symbol
, bfd
*abfd
, asection
*section
,
164 warning (_("Compiled module \"%s\" section \"%s\": warning: %s\n"),
165 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
167 /* Maybe permit running as a module? */
171 /* Helper for link_callbacks callbacks vector. */
174 link_callbacks_undefined_symbol (struct bfd_link_info
*link_info
,
175 const char *name
, bfd
*abfd
, asection
*section
,
176 bfd_vma address
, bfd_boolean is_fatal
)
178 warning (_("Cannot resolve relocation to \"%s\" "
179 "from compiled module \"%s\" section \"%s\"."),
180 name
, bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
));
184 /* Helper for link_callbacks callbacks vector. */
187 link_callbacks_reloc_overflow (struct bfd_link_info
*link_info
,
188 struct bfd_link_hash_entry
*entry
,
189 const char *name
, const char *reloc_name
,
190 bfd_vma addend
, bfd
*abfd
, asection
*section
,
193 /* TRUE is required for intra-module relocations. */
197 /* Helper for link_callbacks callbacks vector. */
200 link_callbacks_reloc_dangerous (struct bfd_link_info
*link_info
,
201 const char *message
, bfd
*abfd
,
202 asection
*section
, bfd_vma address
)
204 warning (_("Compiled module \"%s\" section \"%s\": dangerous "
206 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
211 /* Helper for link_callbacks callbacks vector. */
214 link_callbacks_unattached_reloc (struct bfd_link_info
*link_info
,
215 const char *name
, bfd
*abfd
, asection
*section
,
218 warning (_("Compiled module \"%s\" section \"%s\": unattached "
220 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, section
),
225 /* Helper for link_callbacks callbacks vector. */
228 link_callbacks_einfo (const char *fmt
, ...)
230 struct cleanup
*cleanups
;
235 str
= xstrvprintf (fmt
, ap
);
237 cleanups
= make_cleanup (xfree
, str
);
239 warning (_("Compile module: warning: %s\n"), str
);
241 do_cleanups (cleanups
);
244 /* Helper for bfd_get_relocated_section_contents.
245 Only these symbols are set by bfd_simple_get_relocated_section_contents
246 but bfd/ seems to use even the NULL ones without checking them first. */
248 static const struct bfd_link_callbacks link_callbacks
=
250 NULL
, /* add_archive_element */
251 link_callbacks_multiple_definition
, /* multiple_definition */
252 NULL
, /* multiple_common */
253 NULL
, /* add_to_set */
254 NULL
, /* constructor */
255 link_callbacks_warning
, /* warning */
256 link_callbacks_undefined_symbol
, /* undefined_symbol */
257 link_callbacks_reloc_overflow
, /* reloc_overflow */
258 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
259 link_callbacks_unattached_reloc
, /* unattached_reloc */
261 link_callbacks_einfo
, /* einfo */
264 NULL
, /* override_segment_assignment */
267 struct link_hash_table_cleanup_data
273 /* Cleanup callback for struct bfd_link_info. */
276 link_hash_table_free (void *d
)
278 struct link_hash_table_cleanup_data
*data
= d
;
280 if (data
->abfd
->is_linker_output
)
281 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
282 data
->abfd
->link
.next
= data
->link_next
;
285 /* Relocate and store into inferior memory each section SECT of ABFD. */
288 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
290 asymbol
**symbol_table
= data
;
291 bfd_byte
*sect_data
, *sect_data_got
;
292 struct cleanup
*cleanups
;
293 struct bfd_link_info link_info
;
294 struct bfd_link_order link_order
;
295 CORE_ADDR inferior_addr
;
296 struct link_hash_table_cleanup_data cleanup_data
;
298 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
299 != (SEC_ALLOC
| SEC_LOAD
))
302 if (bfd_get_section_size (sect
) == 0)
305 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
306 cannot use as it does not report relocations to undefined symbols. */
307 memset (&link_info
, 0, sizeof (link_info
));
308 link_info
.output_bfd
= abfd
;
309 link_info
.input_bfds
= abfd
;
310 link_info
.input_bfds_tail
= &abfd
->link
.next
;
312 cleanup_data
.abfd
= abfd
;
313 cleanup_data
.link_next
= abfd
->link
.next
;
315 abfd
->link
.next
= NULL
;
316 link_info
.hash
= bfd_link_hash_table_create (abfd
);
318 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
319 link_info
.callbacks
= &link_callbacks
;
321 memset (&link_order
, 0, sizeof (link_order
));
322 link_order
.next
= NULL
;
323 link_order
.type
= bfd_indirect_link_order
;
324 link_order
.offset
= 0;
325 link_order
.size
= bfd_get_section_size (sect
);
326 link_order
.u
.indirect
.section
= sect
;
328 sect_data
= xmalloc (bfd_get_section_size (sect
));
329 make_cleanup (xfree
, sect_data
);
331 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
332 &link_order
, sect_data
,
333 FALSE
, symbol_table
);
335 if (sect_data_got
== NULL
)
336 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
337 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
338 bfd_errmsg (bfd_get_error ()));
339 gdb_assert (sect_data_got
== sect_data
);
341 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
342 if (0 != target_write_memory (inferior_addr
, sect_data
,
343 bfd_get_section_size (sect
)))
344 error (_("Cannot write compiled module \"%s\" section \"%s\" "
345 "to inferior memory range %s-%s."),
346 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
347 paddress (target_gdbarch (), inferior_addr
),
348 paddress (target_gdbarch (),
349 inferior_addr
+ bfd_get_section_size (sect
)));
351 do_cleanups (cleanups
);
354 /* Fetch the type of first parameter of GCC_FE_WRAPPER_FUNCTION.
355 Return NULL if GCC_FE_WRAPPER_FUNCTION has no parameters.
356 Throw an error otherwise. */
359 get_regs_type (struct objfile
*objfile
)
361 struct symbol
*func_sym
;
362 struct type
*func_type
, *regsp_type
, *regs_type
;
364 func_sym
= lookup_global_symbol_from_objfile (objfile
,
365 GCC_FE_WRAPPER_FUNCTION
,
367 if (func_sym
== NULL
)
368 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
369 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
371 func_type
= SYMBOL_TYPE (func_sym
);
372 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
373 error (_("Invalid type code %d of function \"%s\" in compiled "
375 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
376 objfile_name (objfile
));
378 /* No register parameter present. */
379 if (TYPE_NFIELDS (func_type
) == 0)
382 if (TYPE_NFIELDS (func_type
) != 1)
383 error (_("Invalid %d parameters of function \"%s\" in compiled "
385 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
386 objfile_name (objfile
));
388 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
389 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
390 error (_("Invalid type code %d of first parameter of function \"%s\" "
391 "in compiled module \"%s\"."),
392 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
393 objfile_name (objfile
));
395 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
396 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
397 error (_("Invalid type code %d of dereferenced first parameter "
398 "of function \"%s\" in compiled module \"%s\"."),
399 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
400 objfile_name (objfile
));
405 /* Store all inferior registers required by REGS_TYPE to inferior memory
406 starting at inferior address REGS_BASE. */
409 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
411 struct gdbarch
*gdbarch
= target_gdbarch ();
412 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
415 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
417 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
418 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
419 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
421 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
423 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
425 struct value
*regval
;
426 CORE_ADDR inferior_addr
;
428 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
431 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
432 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
433 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
434 reg_offset
= reg_bitpos
/ 8;
436 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
437 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
438 error (_("Invalid register \"%s\" type code %d"), reg_name
,
439 TYPE_CODE (reg_type
));
441 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
443 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
444 if (value_optimized_out (regval
))
445 error (_("Register \"%s\" is optimized out."), reg_name
);
446 if (!value_entirely_available (regval
))
447 error (_("Register \"%s\" is not available."), reg_name
);
449 inferior_addr
= regs_base
+ reg_offset
;
450 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
452 error (_("Cannot write register \"%s\" to inferior memory at %s."),
453 reg_name
, paddress (gdbarch
, inferior_addr
));
457 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
458 Caller must fully dispose the return value by calling compile_object_run.
459 SOURCE_FILE's copy is stored into the returned object.
460 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
463 struct compile_module
*
464 compile_object_load (const char *object_file
, const char *source_file
)
466 struct cleanup
*cleanups
, *cleanups_free_objfile
;
468 struct setup_sections_data setup_sections_data
;
469 CORE_ADDR addr
, func_addr
, regs_addr
;
470 struct bound_minimal_symbol bmsym
;
472 asymbol
**symbol_table
, **symp
;
473 long number_of_symbols
, missing_symbols
;
474 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
475 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
476 struct compile_module
*retval
;
477 struct type
*regs_type
;
478 char *filename
, **matching
;
479 struct objfile
*objfile
;
481 filename
= tilde_expand (object_file
);
482 cleanups
= make_cleanup (xfree
, filename
);
484 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
486 error (_("\"%s\": could not open as compiled module: %s"),
487 filename
, bfd_errmsg (bfd_get_error ()));
488 make_cleanup_bfd_unref (abfd
);
490 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
491 error (_("\"%s\": not in loadable format: %s"),
492 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
494 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
495 error (_("\"%s\": not in object format."), filename
);
497 setup_sections_data
.last_size
= 0;
498 setup_sections_data
.last_section_first
= abfd
->sections
;
499 setup_sections_data
.last_prot
= -1;
500 setup_sections_data
.last_max_alignment
= 1;
501 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
502 setup_sections (abfd
, NULL
, &setup_sections_data
);
504 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
505 if (storage_needed
< 0)
506 error (_("Cannot read symbols of compiled module \"%s\": %s"),
507 filename
, bfd_errmsg (bfd_get_error ()));
509 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
510 "Reading symbols from ..." message for automatically generated file. */
511 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
512 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
514 bmsym
= lookup_minimal_symbol_text (GCC_FE_WRAPPER_FUNCTION
, objfile
);
515 if (bmsym
.minsym
== NULL
|| MSYMBOL_TYPE (bmsym
.minsym
) == mst_file_text
)
516 error (_("Could not find symbol \"%s\" of compiled module \"%s\"."),
517 GCC_FE_WRAPPER_FUNCTION
, filename
);
518 func_addr
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
520 /* The memory may be later needed
521 by bfd_generic_get_relocated_section_contents
522 called from default_symfile_relocate. */
523 symbol_table
= obstack_alloc (&objfile
->objfile_obstack
, storage_needed
);
524 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
525 if (number_of_symbols
< 0)
526 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
527 filename
, bfd_errmsg (bfd_get_error ()));
530 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
532 asymbol
*sym
= *symp
;
537 fprintf_unfiltered (gdb_stdout
,
538 "lookup undefined ELF symbol \"%s\"\n",
540 sym
->flags
= BSF_GLOBAL
;
541 sym
->section
= bfd_abs_section_ptr
;
542 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
547 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
548 switch (bmsym
.minsym
== NULL
549 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
552 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
555 warning (_("Could not find symbol \"%s\" "
556 "for compiled module \"%s\"."),
557 sym
->name
, filename
);
562 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
564 bfd_map_over_sections (abfd
, copy_sections
, symbol_table
);
566 regs_type
= get_regs_type (objfile
);
567 if (regs_type
== NULL
)
571 /* Use read-only non-executable memory protection. */
572 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
573 TYPE_LENGTH (regs_type
),
575 gdb_assert (regs_addr
!= 0);
576 store_regs (regs_type
, regs_addr
);
579 discard_cleanups (cleanups_free_objfile
);
580 do_cleanups (cleanups
);
582 retval
= xmalloc (sizeof (*retval
));
583 retval
->objfile
= objfile
;
584 retval
->source_file
= xstrdup (source_file
);
585 retval
->func_addr
= func_addr
;
586 retval
->regs_addr
= regs_addr
;