1 /* Load module for 'compile' command.
3 Copyright (C) 2014-2015 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"),
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"),
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. */
227 static void link_callbacks_einfo (const char *fmt
, ...)
228 ATTRIBUTE_PRINTF (1, 2);
231 link_callbacks_einfo (const char *fmt
, ...)
233 struct cleanup
*cleanups
;
238 str
= xstrvprintf (fmt
, ap
);
240 cleanups
= make_cleanup (xfree
, str
);
242 warning (_("Compile module: warning: %s"), str
);
244 do_cleanups (cleanups
);
247 /* Helper for bfd_get_relocated_section_contents.
248 Only these symbols are set by bfd_simple_get_relocated_section_contents
249 but bfd/ seems to use even the NULL ones without checking them first. */
251 static const struct bfd_link_callbacks link_callbacks
=
253 NULL
, /* add_archive_element */
254 link_callbacks_multiple_definition
, /* multiple_definition */
255 NULL
, /* multiple_common */
256 NULL
, /* add_to_set */
257 NULL
, /* constructor */
258 link_callbacks_warning
, /* warning */
259 link_callbacks_undefined_symbol
, /* undefined_symbol */
260 link_callbacks_reloc_overflow
, /* reloc_overflow */
261 link_callbacks_reloc_dangerous
, /* reloc_dangerous */
262 link_callbacks_unattached_reloc
, /* unattached_reloc */
264 link_callbacks_einfo
, /* einfo */
267 NULL
, /* override_segment_assignment */
270 struct link_hash_table_cleanup_data
276 /* Cleanup callback for struct bfd_link_info. */
279 link_hash_table_free (void *d
)
281 struct link_hash_table_cleanup_data
*data
= d
;
283 if (data
->abfd
->is_linker_output
)
284 (*data
->abfd
->link
.hash
->hash_table_free
) (data
->abfd
);
285 data
->abfd
->link
.next
= data
->link_next
;
288 /* Relocate and store into inferior memory each section SECT of ABFD. */
291 copy_sections (bfd
*abfd
, asection
*sect
, void *data
)
293 asymbol
**symbol_table
= data
;
294 bfd_byte
*sect_data
, *sect_data_got
;
295 struct cleanup
*cleanups
;
296 struct bfd_link_info link_info
;
297 struct bfd_link_order link_order
;
298 CORE_ADDR inferior_addr
;
299 struct link_hash_table_cleanup_data cleanup_data
;
301 if ((bfd_get_section_flags (abfd
, sect
) & (SEC_ALLOC
| SEC_LOAD
))
302 != (SEC_ALLOC
| SEC_LOAD
))
305 if (bfd_get_section_size (sect
) == 0)
308 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
309 cannot use as it does not report relocations to undefined symbols. */
310 memset (&link_info
, 0, sizeof (link_info
));
311 link_info
.output_bfd
= abfd
;
312 link_info
.input_bfds
= abfd
;
313 link_info
.input_bfds_tail
= &abfd
->link
.next
;
315 cleanup_data
.abfd
= abfd
;
316 cleanup_data
.link_next
= abfd
->link
.next
;
318 abfd
->link
.next
= NULL
;
319 link_info
.hash
= bfd_link_hash_table_create (abfd
);
321 cleanups
= make_cleanup (link_hash_table_free
, &cleanup_data
);
322 link_info
.callbacks
= &link_callbacks
;
324 memset (&link_order
, 0, sizeof (link_order
));
325 link_order
.next
= NULL
;
326 link_order
.type
= bfd_indirect_link_order
;
327 link_order
.offset
= 0;
328 link_order
.size
= bfd_get_section_size (sect
);
329 link_order
.u
.indirect
.section
= sect
;
331 sect_data
= xmalloc (bfd_get_section_size (sect
));
332 make_cleanup (xfree
, sect_data
);
334 sect_data_got
= bfd_get_relocated_section_contents (abfd
, &link_info
,
335 &link_order
, sect_data
,
336 FALSE
, symbol_table
);
338 if (sect_data_got
== NULL
)
339 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
340 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
341 bfd_errmsg (bfd_get_error ()));
342 gdb_assert (sect_data_got
== sect_data
);
344 inferior_addr
= bfd_get_section_vma (abfd
, sect
);
345 if (0 != target_write_memory (inferior_addr
, sect_data
,
346 bfd_get_section_size (sect
)))
347 error (_("Cannot write compiled module \"%s\" section \"%s\" "
348 "to inferior memory range %s-%s."),
349 bfd_get_filename (abfd
), bfd_get_section_name (abfd
, sect
),
350 paddress (target_gdbarch (), inferior_addr
),
351 paddress (target_gdbarch (),
352 inferior_addr
+ bfd_get_section_size (sect
)));
354 do_cleanups (cleanups
);
357 /* Fetch the type of first parameter of GCC_FE_WRAPPER_FUNCTION.
358 Return NULL if GCC_FE_WRAPPER_FUNCTION has no parameters.
359 Throw an error otherwise. */
362 get_regs_type (struct objfile
*objfile
)
364 struct symbol
*func_sym
;
365 struct type
*func_type
, *regsp_type
, *regs_type
;
367 func_sym
= lookup_global_symbol_from_objfile (objfile
,
368 GCC_FE_WRAPPER_FUNCTION
,
370 if (func_sym
== NULL
)
371 error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
372 GCC_FE_WRAPPER_FUNCTION
, objfile_name (objfile
));
374 func_type
= SYMBOL_TYPE (func_sym
);
375 if (TYPE_CODE (func_type
) != TYPE_CODE_FUNC
)
376 error (_("Invalid type code %d of function \"%s\" in compiled "
378 TYPE_CODE (func_type
), GCC_FE_WRAPPER_FUNCTION
,
379 objfile_name (objfile
));
381 /* No register parameter present. */
382 if (TYPE_NFIELDS (func_type
) == 0)
385 if (TYPE_NFIELDS (func_type
) != 1)
386 error (_("Invalid %d parameters of function \"%s\" in compiled "
388 TYPE_NFIELDS (func_type
), GCC_FE_WRAPPER_FUNCTION
,
389 objfile_name (objfile
));
391 regsp_type
= check_typedef (TYPE_FIELD_TYPE (func_type
, 0));
392 if (TYPE_CODE (regsp_type
) != TYPE_CODE_PTR
)
393 error (_("Invalid type code %d of first parameter of function \"%s\" "
394 "in compiled module \"%s\"."),
395 TYPE_CODE (regsp_type
), GCC_FE_WRAPPER_FUNCTION
,
396 objfile_name (objfile
));
398 regs_type
= check_typedef (TYPE_TARGET_TYPE (regsp_type
));
399 if (TYPE_CODE (regs_type
) != TYPE_CODE_STRUCT
)
400 error (_("Invalid type code %d of dereferenced first parameter "
401 "of function \"%s\" in compiled module \"%s\"."),
402 TYPE_CODE (regs_type
), GCC_FE_WRAPPER_FUNCTION
,
403 objfile_name (objfile
));
408 /* Store all inferior registers required by REGS_TYPE to inferior memory
409 starting at inferior address REGS_BASE. */
412 store_regs (struct type
*regs_type
, CORE_ADDR regs_base
)
414 struct gdbarch
*gdbarch
= target_gdbarch ();
415 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
418 for (fieldno
= 0; fieldno
< TYPE_NFIELDS (regs_type
); fieldno
++)
420 const char *reg_name
= TYPE_FIELD_NAME (regs_type
, fieldno
);
421 ULONGEST reg_bitpos
= TYPE_FIELD_BITPOS (regs_type
, fieldno
);
422 ULONGEST reg_bitsize
= TYPE_FIELD_BITSIZE (regs_type
, fieldno
);
424 struct type
*reg_type
= check_typedef (TYPE_FIELD_TYPE (regs_type
,
426 ULONGEST reg_size
= TYPE_LENGTH (reg_type
);
428 struct value
*regval
;
429 CORE_ADDR inferior_addr
;
431 if (strcmp (reg_name
, COMPILE_I_SIMPLE_REGISTER_DUMMY
) == 0)
434 if ((reg_bitpos
% 8) != 0 || reg_bitsize
!= 0)
435 error (_("Invalid register \"%s\" position %s bits or size %s bits"),
436 reg_name
, pulongest (reg_bitpos
), pulongest (reg_bitsize
));
437 reg_offset
= reg_bitpos
/ 8;
439 if (TYPE_CODE (reg_type
) != TYPE_CODE_INT
440 && TYPE_CODE (reg_type
) != TYPE_CODE_PTR
)
441 error (_("Invalid register \"%s\" type code %d"), reg_name
,
442 TYPE_CODE (reg_type
));
444 regnum
= compile_register_name_demangle (gdbarch
, reg_name
);
446 regval
= value_from_register (reg_type
, regnum
, get_current_frame ());
447 if (value_optimized_out (regval
))
448 error (_("Register \"%s\" is optimized out."), reg_name
);
449 if (!value_entirely_available (regval
))
450 error (_("Register \"%s\" is not available."), reg_name
);
452 inferior_addr
= regs_base
+ reg_offset
;
453 if (0 != target_write_memory (inferior_addr
, value_contents (regval
),
455 error (_("Cannot write register \"%s\" to inferior memory at %s."),
456 reg_name
, paddress (gdbarch
, inferior_addr
));
460 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise.
461 Caller must fully dispose the return value by calling compile_object_run.
462 SOURCE_FILE's copy is stored into the returned object.
463 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
466 struct compile_module
*
467 compile_object_load (const char *object_file
, const char *source_file
)
469 struct cleanup
*cleanups
, *cleanups_free_objfile
;
471 struct setup_sections_data setup_sections_data
;
472 CORE_ADDR addr
, func_addr
, regs_addr
;
473 struct bound_minimal_symbol bmsym
;
475 asymbol
**symbol_table
, **symp
;
476 long number_of_symbols
, missing_symbols
;
477 struct type
*dptr_type
= builtin_type (target_gdbarch ())->builtin_data_ptr
;
478 unsigned dptr_type_len
= TYPE_LENGTH (dptr_type
);
479 struct compile_module
*retval
;
480 struct type
*regs_type
;
481 char *filename
, **matching
;
482 struct objfile
*objfile
;
484 filename
= tilde_expand (object_file
);
485 cleanups
= make_cleanup (xfree
, filename
);
487 abfd
= gdb_bfd_open (filename
, gnutarget
, -1);
489 error (_("\"%s\": could not open as compiled module: %s"),
490 filename
, bfd_errmsg (bfd_get_error ()));
491 make_cleanup_bfd_unref (abfd
);
493 if (!bfd_check_format_matches (abfd
, bfd_object
, &matching
))
494 error (_("\"%s\": not in loadable format: %s"),
495 filename
, gdb_bfd_errmsg (bfd_get_error (), matching
));
497 if ((bfd_get_file_flags (abfd
) & (EXEC_P
| DYNAMIC
)) != 0)
498 error (_("\"%s\": not in object format."), filename
);
500 setup_sections_data
.last_size
= 0;
501 setup_sections_data
.last_section_first
= abfd
->sections
;
502 setup_sections_data
.last_prot
= -1;
503 setup_sections_data
.last_max_alignment
= 1;
504 bfd_map_over_sections (abfd
, setup_sections
, &setup_sections_data
);
505 setup_sections (abfd
, NULL
, &setup_sections_data
);
507 storage_needed
= bfd_get_symtab_upper_bound (abfd
);
508 if (storage_needed
< 0)
509 error (_("Cannot read symbols of compiled module \"%s\": %s"),
510 filename
, bfd_errmsg (bfd_get_error ()));
512 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
513 "Reading symbols from ..." message for automatically generated file. */
514 objfile
= symbol_file_add_from_bfd (abfd
, filename
, 0, NULL
, 0, NULL
);
515 cleanups_free_objfile
= make_cleanup_free_objfile (objfile
);
517 bmsym
= lookup_minimal_symbol_text (GCC_FE_WRAPPER_FUNCTION
, objfile
);
518 if (bmsym
.minsym
== NULL
|| MSYMBOL_TYPE (bmsym
.minsym
) == mst_file_text
)
519 error (_("Could not find symbol \"%s\" of compiled module \"%s\"."),
520 GCC_FE_WRAPPER_FUNCTION
, filename
);
521 func_addr
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
523 /* The memory may be later needed
524 by bfd_generic_get_relocated_section_contents
525 called from default_symfile_relocate. */
526 symbol_table
= obstack_alloc (&objfile
->objfile_obstack
, storage_needed
);
527 number_of_symbols
= bfd_canonicalize_symtab (abfd
, symbol_table
);
528 if (number_of_symbols
< 0)
529 error (_("Cannot parse symbols of compiled module \"%s\": %s"),
530 filename
, bfd_errmsg (bfd_get_error ()));
533 for (symp
= symbol_table
; symp
< symbol_table
+ number_of_symbols
; symp
++)
535 asymbol
*sym
= *symp
;
540 fprintf_unfiltered (gdb_stdout
,
541 "lookup undefined ELF symbol \"%s\"\n",
543 sym
->flags
= BSF_GLOBAL
;
544 sym
->section
= bfd_abs_section_ptr
;
545 if (strcmp (sym
->name
, "_GLOBAL_OFFSET_TABLE_") == 0)
550 bmsym
= lookup_minimal_symbol (sym
->name
, NULL
, NULL
);
551 switch (bmsym
.minsym
== NULL
552 ? mst_unknown
: MSYMBOL_TYPE (bmsym
.minsym
))
555 sym
->value
= BMSYMBOL_VALUE_ADDRESS (bmsym
);
558 warning (_("Could not find symbol \"%s\" "
559 "for compiled module \"%s\"."),
560 sym
->name
, filename
);
565 error (_("%ld symbols were missing, cannot continue."), missing_symbols
);
567 bfd_map_over_sections (abfd
, copy_sections
, symbol_table
);
569 regs_type
= get_regs_type (objfile
);
570 if (regs_type
== NULL
)
574 /* Use read-only non-executable memory protection. */
575 regs_addr
= gdbarch_infcall_mmap (target_gdbarch (),
576 TYPE_LENGTH (regs_type
),
578 gdb_assert (regs_addr
!= 0);
579 store_regs (regs_type
, regs_addr
);
582 discard_cleanups (cleanups_free_objfile
);
583 do_cleanups (cleanups
);
585 retval
= xmalloc (sizeof (*retval
));
586 retval
->objfile
= objfile
;
587 retval
->source_file
= xstrdup (source_file
);
588 retval
->func_addr
= func_addr
;
589 retval
->regs_addr
= regs_addr
;