1 /* Load module for 'compile' command. 2 3 Copyright (C) 2014-2015 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20 #include "defs.h" 21 #include "compile-object-load.h" 22 #include "compile-internal.h" 23 #include "command.h" 24 #include "objfiles.h" 25 #include "gdbcore.h" 26 #include "readline/tilde.h" 27 #include "bfdlink.h" 28 #include "gdbcmd.h" 29 #include "regcache.h" 30 #include "inferior.h" 31 #include "compile.h" 32 #include "block.h" 33 #include "arch-utils.h" 34 35 /* Track inferior memory reserved by inferior mmap. */ 36 37 struct munmap_list 38 { 39 struct munmap_list *next; 40 CORE_ADDR addr, size; 41 }; 42 43 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list 44 HEADP. *HEADP needs to be initialized to NULL. */ 45 46 static void 47 munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size) 48 { 49 struct munmap_list *head_new = xmalloc (sizeof (*head_new)); 50 51 head_new->next = *headp; 52 *headp = head_new; 53 head_new->addr = addr; 54 head_new->size = size; 55 } 56 57 /* Free list of inferior mmap memory ranges HEAD. HEAD is the first 58 element of the list, it can be NULL. After calling this function 59 HEAD pointer is invalid and the possible list needs to be 60 reinitialized by caller to NULL. */ 61 62 void 63 munmap_list_free (struct munmap_list *head) 64 { 65 while (head) 66 { 67 struct munmap_list *todo = head; 68 69 head = todo->next; 70 gdbarch_infcall_munmap (target_gdbarch (), todo->addr, todo->size); 71 xfree (todo); 72 } 73 } 74 75 /* Stub for munmap_list_free suitable for make_cleanup. Contrary to 76 munmap_list_free this function's parameter is a pointer to the first 77 list element pointer. */ 78 79 static void 80 munmap_listp_free_cleanup (void *headp_voidp) 81 { 82 struct munmap_list **headp = headp_voidp; 83 84 munmap_list_free (*headp); 85 } 86 87 /* Helper data for setup_sections. */ 88 89 struct setup_sections_data 90 { 91 /* Size of all recent sections with matching LAST_PROT. */ 92 CORE_ADDR last_size; 93 94 /* First section matching LAST_PROT. */ 95 asection *last_section_first; 96 97 /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */ 98 unsigned last_prot; 99 100 /* Maximum of alignments of all sections matching LAST_PROT. 101 This value is always at least 1. This value is always a power of 2. */ 102 CORE_ADDR last_max_alignment; 103 104 /* List of inferior mmap ranges where setup_sections should add its 105 next range. */ 106 struct munmap_list **munmap_list_headp; 107 }; 108 109 /* Place all ABFD sections next to each other obeying all constraints. */ 110 111 static void 112 setup_sections (bfd *abfd, asection *sect, void *data_voidp) 113 { 114 struct setup_sections_data *data = data_voidp; 115 CORE_ADDR alignment; 116 unsigned prot; 117 118 if (sect != NULL) 119 { 120 /* It is required by later bfd_get_relocated_section_contents. */ 121 if (sect->output_section == NULL) 122 sect->output_section = sect; 123 124 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0) 125 return; 126 127 /* Make the memory always readable. */ 128 prot = GDB_MMAP_PROT_READ; 129 if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0) 130 prot |= GDB_MMAP_PROT_WRITE; 131 if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0) 132 prot |= GDB_MMAP_PROT_EXEC; 133 134 if (compile_debug) 135 fprintf_unfiltered (gdb_stdlog, 136 "module \"%s\" section \"%s\" size %s prot %u\n", 137 bfd_get_filename (abfd), 138 bfd_get_section_name (abfd, sect), 139 paddress (target_gdbarch (), 140 bfd_get_section_size (sect)), 141 prot); 142 } 143 else 144 prot = -1; 145 146 if (sect == NULL 147 || (data->last_prot != prot && bfd_get_section_size (sect) != 0)) 148 { 149 CORE_ADDR addr; 150 asection *sect_iter; 151 152 if (data->last_size != 0) 153 { 154 addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size, 155 data->last_prot); 156 munmap_list_add (data->munmap_list_headp, addr, data->last_size); 157 if (compile_debug) 158 fprintf_unfiltered (gdb_stdlog, 159 "allocated %s bytes at %s prot %u\n", 160 paddress (target_gdbarch (), data->last_size), 161 paddress (target_gdbarch (), addr), 162 data->last_prot); 163 } 164 else 165 addr = 0; 166 167 if ((addr & (data->last_max_alignment - 1)) != 0) 168 error (_("Inferior compiled module address %s " 169 "is not aligned to BFD required %s."), 170 paddress (target_gdbarch (), addr), 171 paddress (target_gdbarch (), data->last_max_alignment)); 172 173 for (sect_iter = data->last_section_first; sect_iter != sect; 174 sect_iter = sect_iter->next) 175 if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0) 176 bfd_set_section_vma (abfd, sect_iter, 177 addr + bfd_get_section_vma (abfd, sect_iter)); 178 179 data->last_size = 0; 180 data->last_section_first = sect; 181 data->last_prot = prot; 182 data->last_max_alignment = 1; 183 } 184 185 if (sect == NULL) 186 return; 187 188 alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect); 189 data->last_max_alignment = max (data->last_max_alignment, alignment); 190 191 data->last_size = (data->last_size + alignment - 1) & -alignment; 192 193 bfd_set_section_vma (abfd, sect, data->last_size); 194 195 data->last_size += bfd_get_section_size (sect); 196 data->last_size = (data->last_size + alignment - 1) & -alignment; 197 } 198 199 /* Helper for link_callbacks callbacks vector. */ 200 201 static bfd_boolean 202 link_callbacks_multiple_definition (struct bfd_link_info *link_info, 203 struct bfd_link_hash_entry *h, bfd *nbfd, 204 asection *nsec, bfd_vma nval) 205 { 206 bfd *abfd = link_info->input_bfds; 207 208 if (link_info->allow_multiple_definition) 209 return TRUE; 210 warning (_("Compiled module \"%s\": multiple symbol definitions: %s"), 211 bfd_get_filename (abfd), h->root.string); 212 return FALSE; 213 } 214 215 /* Helper for link_callbacks callbacks vector. */ 216 217 static bfd_boolean 218 link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning, 219 const char *symbol, bfd *abfd, asection *section, 220 bfd_vma address) 221 { 222 warning (_("Compiled module \"%s\" section \"%s\": warning: %s"), 223 bfd_get_filename (abfd), bfd_get_section_name (abfd, section), 224 xwarning); 225 /* Maybe permit running as a module? */ 226 return FALSE; 227 } 228 229 /* Helper for link_callbacks callbacks vector. */ 230 231 static bfd_boolean 232 link_callbacks_undefined_symbol (struct bfd_link_info *link_info, 233 const char *name, bfd *abfd, asection *section, 234 bfd_vma address, bfd_boolean is_fatal) 235 { 236 warning (_("Cannot resolve relocation to \"%s\" " 237 "from compiled module \"%s\" section \"%s\"."), 238 name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section)); 239 return FALSE; 240 } 241 242 /* Helper for link_callbacks callbacks vector. */ 243 244 static bfd_boolean 245 link_callbacks_reloc_overflow (struct bfd_link_info *link_info, 246 struct bfd_link_hash_entry *entry, 247 const char *name, const char *reloc_name, 248 bfd_vma addend, bfd *abfd, asection *section, 249 bfd_vma address) 250 { 251 /* TRUE is required for intra-module relocations. */ 252 return TRUE; 253 } 254 255 /* Helper for link_callbacks callbacks vector. */ 256 257 static bfd_boolean 258 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info, 259 const char *message, bfd *abfd, 260 asection *section, bfd_vma address) 261 { 262 warning (_("Compiled module \"%s\" section \"%s\": dangerous " 263 "relocation: %s\n"), 264 bfd_get_filename (abfd), bfd_get_section_name (abfd, section), 265 message); 266 return FALSE; 267 } 268 269 /* Helper for link_callbacks callbacks vector. */ 270 271 static bfd_boolean 272 link_callbacks_unattached_reloc (struct bfd_link_info *link_info, 273 const char *name, bfd *abfd, asection *section, 274 bfd_vma address) 275 { 276 warning (_("Compiled module \"%s\" section \"%s\": unattached " 277 "relocation: %s\n"), 278 bfd_get_filename (abfd), bfd_get_section_name (abfd, section), 279 name); 280 return FALSE; 281 } 282 283 /* Helper for link_callbacks callbacks vector. */ 284 285 static void link_callbacks_einfo (const char *fmt, ...) 286 ATTRIBUTE_PRINTF (1, 2); 287 288 static void 289 link_callbacks_einfo (const char *fmt, ...) 290 { 291 struct cleanup *cleanups; 292 va_list ap; 293 char *str; 294 295 va_start (ap, fmt); 296 str = xstrvprintf (fmt, ap); 297 va_end (ap); 298 cleanups = make_cleanup (xfree, str); 299 300 warning (_("Compile module: warning: %s"), str); 301 302 do_cleanups (cleanups); 303 } 304 305 /* Helper for bfd_get_relocated_section_contents. 306 Only these symbols are set by bfd_simple_get_relocated_section_contents 307 but bfd/ seems to use even the NULL ones without checking them first. */ 308 309 static const struct bfd_link_callbacks link_callbacks = 310 { 311 NULL, /* add_archive_element */ 312 link_callbacks_multiple_definition, /* multiple_definition */ 313 NULL, /* multiple_common */ 314 NULL, /* add_to_set */ 315 NULL, /* constructor */ 316 link_callbacks_warning, /* warning */ 317 link_callbacks_undefined_symbol, /* undefined_symbol */ 318 link_callbacks_reloc_overflow, /* reloc_overflow */ 319 link_callbacks_reloc_dangerous, /* reloc_dangerous */ 320 link_callbacks_unattached_reloc, /* unattached_reloc */ 321 NULL, /* notice */ 322 link_callbacks_einfo, /* einfo */ 323 NULL, /* info */ 324 NULL, /* minfo */ 325 NULL, /* override_segment_assignment */ 326 }; 327 328 struct link_hash_table_cleanup_data 329 { 330 bfd *abfd; 331 bfd *link_next; 332 }; 333 334 /* Cleanup callback for struct bfd_link_info. */ 335 336 static void 337 link_hash_table_free (void *d) 338 { 339 struct link_hash_table_cleanup_data *data = d; 340 341 if (data->abfd->is_linker_output) 342 (*data->abfd->link.hash->hash_table_free) (data->abfd); 343 data->abfd->link.next = data->link_next; 344 } 345 346 /* Relocate and store into inferior memory each section SECT of ABFD. */ 347 348 static void 349 copy_sections (bfd *abfd, asection *sect, void *data) 350 { 351 asymbol **symbol_table = data; 352 bfd_byte *sect_data, *sect_data_got; 353 struct cleanup *cleanups; 354 struct bfd_link_info link_info; 355 struct bfd_link_order link_order; 356 CORE_ADDR inferior_addr; 357 struct link_hash_table_cleanup_data cleanup_data; 358 359 if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD)) 360 != (SEC_ALLOC | SEC_LOAD)) 361 return; 362 363 if (bfd_get_section_size (sect) == 0) 364 return; 365 366 /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB 367 cannot use as it does not report relocations to undefined symbols. */ 368 memset (&link_info, 0, sizeof (link_info)); 369 link_info.output_bfd = abfd; 370 link_info.input_bfds = abfd; 371 link_info.input_bfds_tail = &abfd->link.next; 372 373 cleanup_data.abfd = abfd; 374 cleanup_data.link_next = abfd->link.next; 375 376 abfd->link.next = NULL; 377 link_info.hash = bfd_link_hash_table_create (abfd); 378 379 cleanups = make_cleanup (link_hash_table_free, &cleanup_data); 380 link_info.callbacks = &link_callbacks; 381 382 memset (&link_order, 0, sizeof (link_order)); 383 link_order.next = NULL; 384 link_order.type = bfd_indirect_link_order; 385 link_order.offset = 0; 386 link_order.size = bfd_get_section_size (sect); 387 link_order.u.indirect.section = sect; 388 389 sect_data = xmalloc (bfd_get_section_size (sect)); 390 make_cleanup (xfree, sect_data); 391 392 sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info, 393 &link_order, sect_data, 394 FALSE, symbol_table); 395 396 if (sect_data_got == NULL) 397 error (_("Cannot map compiled module \"%s\" section \"%s\": %s"), 398 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect), 399 bfd_errmsg (bfd_get_error ())); 400 gdb_assert (sect_data_got == sect_data); 401 402 inferior_addr = bfd_get_section_vma (abfd, sect); 403 if (0 != target_write_memory (inferior_addr, sect_data, 404 bfd_get_section_size (sect))) 405 error (_("Cannot write compiled module \"%s\" section \"%s\" " 406 "to inferior memory range %s-%s."), 407 bfd_get_filename (abfd), bfd_get_section_name (abfd, sect), 408 paddress (target_gdbarch (), inferior_addr), 409 paddress (target_gdbarch (), 410 inferior_addr + bfd_get_section_size (sect))); 411 412 do_cleanups (cleanups); 413 } 414 415 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL 416 symbols in OBJFILE so we can calculate how much memory to allocate 417 for the out parameter. This avoids needing a malloc in the generated 418 code. Throw an error if anything fails. 419 GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE. 420 If it finds user tries to print an array type this function returns 421 NULL. Caller will then regenerate the code with 422 COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it. 423 This is because __auto_type array-to-pointer type conversion of 424 COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE 425 preserving the array type. */ 426 427 static struct type * 428 get_out_value_type (struct symbol *func_sym, struct objfile *objfile, 429 enum compile_i_scope_types scope) 430 { 431 struct symbol *gdb_ptr_type_sym; 432 /* Initialize it just to avoid a GCC false warning. */ 433 struct symbol *gdb_val_sym = NULL; 434 struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval; 435 /* Initialize it just to avoid a GCC false warning. */ 436 const struct block *block = NULL; 437 const struct blockvector *bv; 438 int nblocks = 0; 439 int block_loop = 0; 440 441 bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab); 442 nblocks = BLOCKVECTOR_NBLOCKS (bv); 443 444 gdb_ptr_type_sym = NULL; 445 for (block_loop = 0; block_loop < nblocks; block_loop++) 446 { 447 struct symbol *function = NULL; 448 const struct block *function_block; 449 450 block = BLOCKVECTOR_BLOCK (bv, block_loop); 451 if (BLOCK_FUNCTION (block) != NULL) 452 continue; 453 gdb_val_sym = block_lookup_symbol (block, COMPILE_I_EXPR_VAL, VAR_DOMAIN); 454 if (gdb_val_sym == NULL) 455 continue; 456 457 function_block = block; 458 while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) 459 && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) 460 { 461 function_block = BLOCK_SUPERBLOCK (function_block); 462 function = BLOCK_FUNCTION (function_block); 463 if (function != NULL) 464 break; 465 } 466 if (function != NULL 467 && (BLOCK_SUPERBLOCK (function_block) 468 == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) 469 && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION) 470 == 0)) 471 break; 472 } 473 if (block_loop == nblocks) 474 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE); 475 476 gdb_type = SYMBOL_TYPE (gdb_val_sym); 477 CHECK_TYPEDEF (gdb_type); 478 479 gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE, 480 VAR_DOMAIN); 481 if (gdb_ptr_type_sym == NULL) 482 error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE); 483 gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym); 484 CHECK_TYPEDEF (gdb_ptr_type); 485 if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR) 486 error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE); 487 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type); 488 489 if (types_deeply_equal (gdb_type, gdb_type_from_ptr)) 490 { 491 if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE) 492 error (_("Expected address scope in compiled module \"%s\"."), 493 objfile_name (objfile)); 494 return gdb_type; 495 } 496 497 if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR) 498 error (_("Invalid type code %d of symbol \"%s\" " 499 "in compiled module \"%s\"."), 500 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL, 501 objfile_name (objfile)); 502 503 retval = gdb_type_from_ptr; 504 switch (TYPE_CODE (gdb_type_from_ptr)) 505 { 506 case TYPE_CODE_ARRAY: 507 gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr); 508 break; 509 case TYPE_CODE_FUNC: 510 break; 511 default: 512 error (_("Invalid type code %d of symbol \"%s\" " 513 "in compiled module \"%s\"."), 514 TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE, 515 objfile_name (objfile)); 516 } 517 if (!types_deeply_equal (gdb_type_from_ptr, 518 TYPE_TARGET_TYPE (gdb_type))) 519 error (_("Referenced types do not match for symbols \"%s\" and \"%s\" " 520 "in compiled module \"%s\"."), 521 COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL, 522 objfile_name (objfile)); 523 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE) 524 return NULL; 525 return retval; 526 } 527 528 /* Fetch the type of first parameter of FUNC_SYM. 529 Return NULL if FUNC_SYM has no parameters. Throw an error otherwise. */ 530 531 static struct type * 532 get_regs_type (struct symbol *func_sym, struct objfile *objfile) 533 { 534 struct type *func_type = SYMBOL_TYPE (func_sym); 535 struct type *regsp_type, *regs_type; 536 537 /* No register parameter present. */ 538 if (TYPE_NFIELDS (func_type) == 0) 539 return NULL; 540 541 regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0)); 542 if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR) 543 error (_("Invalid type code %d of first parameter of function \"%s\" " 544 "in compiled module \"%s\"."), 545 TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION, 546 objfile_name (objfile)); 547 548 regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type)); 549 if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT) 550 error (_("Invalid type code %d of dereferenced first parameter " 551 "of function \"%s\" in compiled module \"%s\"."), 552 TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION, 553 objfile_name (objfile)); 554 555 return regs_type; 556 } 557 558 /* Store all inferior registers required by REGS_TYPE to inferior memory 559 starting at inferior address REGS_BASE. */ 560 561 static void 562 store_regs (struct type *regs_type, CORE_ADDR regs_base) 563 { 564 struct gdbarch *gdbarch = target_gdbarch (); 565 struct regcache *regcache = get_thread_regcache (inferior_ptid); 566 int fieldno; 567 568 for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++) 569 { 570 const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno); 571 ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno); 572 ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno); 573 ULONGEST reg_offset; 574 struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type, 575 fieldno)); 576 ULONGEST reg_size = TYPE_LENGTH (reg_type); 577 int regnum; 578 struct value *regval; 579 CORE_ADDR inferior_addr; 580 581 if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0) 582 continue; 583 584 if ((reg_bitpos % 8) != 0 || reg_bitsize != 0) 585 error (_("Invalid register \"%s\" position %s bits or size %s bits"), 586 reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize)); 587 reg_offset = reg_bitpos / 8; 588 589 if (TYPE_CODE (reg_type) != TYPE_CODE_INT 590 && TYPE_CODE (reg_type) != TYPE_CODE_PTR) 591 error (_("Invalid register \"%s\" type code %d"), reg_name, 592 TYPE_CODE (reg_type)); 593 594 regnum = compile_register_name_demangle (gdbarch, reg_name); 595 596 regval = value_from_register (reg_type, regnum, get_current_frame ()); 597 if (value_optimized_out (regval)) 598 error (_("Register \"%s\" is optimized out."), reg_name); 599 if (!value_entirely_available (regval)) 600 error (_("Register \"%s\" is not available."), reg_name); 601 602 inferior_addr = regs_base + reg_offset; 603 if (0 != target_write_memory (inferior_addr, value_contents (regval), 604 reg_size)) 605 error (_("Cannot write register \"%s\" to inferior memory at %s."), 606 reg_name, paddress (gdbarch, inferior_addr)); 607 } 608 } 609 610 /* Load OBJECT_FILE into inferior memory. Throw an error otherwise. 611 Caller must fully dispose the return value by calling compile_object_run. 612 SOURCE_FILE's copy is stored into the returned object. 613 Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this 614 function returns. 615 Function returns NULL only for COMPILE_I_PRINT_ADDRESS_SCOPE when 616 COMPILE_I_PRINT_VALUE_SCOPE should have been used instead. */ 617 618 struct compile_module * 619 compile_object_load (const char *object_file, const char *source_file, 620 enum compile_i_scope_types scope, void *scope_data) 621 { 622 struct cleanup *cleanups, *cleanups_free_objfile; 623 bfd *abfd; 624 struct setup_sections_data setup_sections_data; 625 CORE_ADDR addr, regs_addr, out_value_addr = 0; 626 struct symbol *func_sym; 627 struct type *func_type; 628 struct bound_minimal_symbol bmsym; 629 long storage_needed; 630 asymbol **symbol_table, **symp; 631 long number_of_symbols, missing_symbols; 632 struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; 633 unsigned dptr_type_len = TYPE_LENGTH (dptr_type); 634 struct compile_module *retval; 635 struct type *regs_type, *out_value_type = NULL; 636 char *filename, **matching; 637 struct objfile *objfile; 638 int expect_parameters; 639 struct type *expect_return_type; 640 struct munmap_list *munmap_list_head = NULL; 641 642 filename = tilde_expand (object_file); 643 cleanups = make_cleanup (xfree, filename); 644 645 abfd = gdb_bfd_open (filename, gnutarget, -1); 646 if (abfd == NULL) 647 error (_("\"%s\": could not open as compiled module: %s"), 648 filename, bfd_errmsg (bfd_get_error ())); 649 make_cleanup_bfd_unref (abfd); 650 651 if (!bfd_check_format_matches (abfd, bfd_object, &matching)) 652 error (_("\"%s\": not in loadable format: %s"), 653 filename, gdb_bfd_errmsg (bfd_get_error (), matching)); 654 655 if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0) 656 error (_("\"%s\": not in object format."), filename); 657 658 setup_sections_data.last_size = 0; 659 setup_sections_data.last_section_first = abfd->sections; 660 setup_sections_data.last_prot = -1; 661 setup_sections_data.last_max_alignment = 1; 662 setup_sections_data.munmap_list_headp = &munmap_list_head; 663 make_cleanup (munmap_listp_free_cleanup, &munmap_list_head); 664 bfd_map_over_sections (abfd, setup_sections, &setup_sections_data); 665 setup_sections (abfd, NULL, &setup_sections_data); 666 667 storage_needed = bfd_get_symtab_upper_bound (abfd); 668 if (storage_needed < 0) 669 error (_("Cannot read symbols of compiled module \"%s\": %s"), 670 filename, bfd_errmsg (bfd_get_error ())); 671 672 /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in 673 "Reading symbols from ..." message for automatically generated file. */ 674 objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL); 675 cleanups_free_objfile = make_cleanup_free_objfile (objfile); 676 677 func_sym = lookup_global_symbol_from_objfile (objfile, 678 GCC_FE_WRAPPER_FUNCTION, 679 VAR_DOMAIN); 680 if (func_sym == NULL) 681 error (_("Cannot find function \"%s\" in compiled module \"%s\"."), 682 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile)); 683 func_type = SYMBOL_TYPE (func_sym); 684 if (TYPE_CODE (func_type) != TYPE_CODE_FUNC) 685 error (_("Invalid type code %d of function \"%s\" in compiled " 686 "module \"%s\"."), 687 TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION, 688 objfile_name (objfile)); 689 690 switch (scope) 691 { 692 case COMPILE_I_SIMPLE_SCOPE: 693 expect_parameters = 1; 694 expect_return_type = builtin_type (target_gdbarch ())->builtin_void; 695 break; 696 case COMPILE_I_RAW_SCOPE: 697 expect_parameters = 0; 698 expect_return_type = builtin_type (target_gdbarch ())->builtin_void; 699 break; 700 case COMPILE_I_PRINT_ADDRESS_SCOPE: 701 case COMPILE_I_PRINT_VALUE_SCOPE: 702 expect_parameters = 2; 703 expect_return_type = builtin_type (target_gdbarch ())->builtin_void; 704 break; 705 default: 706 internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope); 707 } 708 if (TYPE_NFIELDS (func_type) != expect_parameters) 709 error (_("Invalid %d parameters of function \"%s\" in compiled " 710 "module \"%s\"."), 711 TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION, 712 objfile_name (objfile)); 713 if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type))) 714 error (_("Invalid return type of function \"%s\" in compiled " 715 "module \"%s\"."), 716 GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile)); 717 718 /* The memory may be later needed 719 by bfd_generic_get_relocated_section_contents 720 called from default_symfile_relocate. */ 721 symbol_table = obstack_alloc (&objfile->objfile_obstack, storage_needed); 722 number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table); 723 if (number_of_symbols < 0) 724 error (_("Cannot parse symbols of compiled module \"%s\": %s"), 725 filename, bfd_errmsg (bfd_get_error ())); 726 727 missing_symbols = 0; 728 for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++) 729 { 730 asymbol *sym = *symp; 731 732 if (sym->flags != 0) 733 continue; 734 sym->flags = BSF_GLOBAL; 735 sym->section = bfd_abs_section_ptr; 736 if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0) 737 { 738 if (compile_debug) 739 fprintf_unfiltered (gdb_stdlog, 740 "ELF symbol \"%s\" relocated to zero\n", 741 sym->name); 742 743 /* It seems to be a GCC bug, with -mcmodel=large there should be no 744 need for _GLOBAL_OFFSET_TABLE_. Together with -fPIE the data 745 remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero. */ 746 sym->value = 0; 747 continue; 748 } 749 bmsym = lookup_minimal_symbol (sym->name, NULL, NULL); 750 switch (bmsym.minsym == NULL 751 ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym)) 752 { 753 case mst_text: 754 sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym); 755 if (compile_debug) 756 fprintf_unfiltered (gdb_stdlog, 757 "ELF mst_text symbol \"%s\" relocated to %s\n", 758 sym->name, 759 paddress (target_gdbarch (), sym->value)); 760 break; 761 case mst_text_gnu_ifunc: 762 sym->value = gnu_ifunc_resolve_addr (target_gdbarch (), 763 BMSYMBOL_VALUE_ADDRESS (bmsym)); 764 if (compile_debug) 765 fprintf_unfiltered (gdb_stdlog, 766 "ELF mst_text_gnu_ifunc symbol \"%s\" " 767 "relocated to %s\n", 768 sym->name, 769 paddress (target_gdbarch (), sym->value)); 770 break; 771 default: 772 warning (_("Could not find symbol \"%s\" " 773 "for compiled module \"%s\"."), 774 sym->name, filename); 775 missing_symbols++; 776 } 777 } 778 if (missing_symbols) 779 error (_("%ld symbols were missing, cannot continue."), missing_symbols); 780 781 bfd_map_over_sections (abfd, copy_sections, symbol_table); 782 783 regs_type = get_regs_type (func_sym, objfile); 784 if (regs_type == NULL) 785 regs_addr = 0; 786 else 787 { 788 /* Use read-only non-executable memory protection. */ 789 regs_addr = gdbarch_infcall_mmap (target_gdbarch (), 790 TYPE_LENGTH (regs_type), 791 GDB_MMAP_PROT_READ); 792 gdb_assert (regs_addr != 0); 793 munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type)); 794 if (compile_debug) 795 fprintf_unfiltered (gdb_stdlog, 796 "allocated %s bytes at %s for registers\n", 797 paddress (target_gdbarch (), 798 TYPE_LENGTH (regs_type)), 799 paddress (target_gdbarch (), regs_addr)); 800 store_regs (regs_type, regs_addr); 801 } 802 803 if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE 804 || scope == COMPILE_I_PRINT_VALUE_SCOPE) 805 { 806 out_value_type = get_out_value_type (func_sym, objfile, scope); 807 if (out_value_type == NULL) 808 { 809 do_cleanups (cleanups); 810 return NULL; 811 } 812 check_typedef (out_value_type); 813 out_value_addr = gdbarch_infcall_mmap (target_gdbarch (), 814 TYPE_LENGTH (out_value_type), 815 (GDB_MMAP_PROT_READ 816 | GDB_MMAP_PROT_WRITE)); 817 gdb_assert (out_value_addr != 0); 818 munmap_list_add (&munmap_list_head, out_value_addr, 819 TYPE_LENGTH (out_value_type)); 820 if (compile_debug) 821 fprintf_unfiltered (gdb_stdlog, 822 "allocated %s bytes at %s for printed value\n", 823 paddress (target_gdbarch (), 824 TYPE_LENGTH (out_value_type)), 825 paddress (target_gdbarch (), out_value_addr)); 826 } 827 828 discard_cleanups (cleanups_free_objfile); 829 830 retval = xmalloc (sizeof (*retval)); 831 retval->objfile = objfile; 832 retval->source_file = xstrdup (source_file); 833 retval->func_sym = func_sym; 834 retval->regs_addr = regs_addr; 835 retval->scope = scope; 836 retval->scope_data = scope_data; 837 retval->out_value_type = out_value_type; 838 retval->out_value_addr = out_value_addr; 839 840 /* CLEANUPS will free MUNMAP_LIST_HEAD. */ 841 retval->munmap_list_head = munmap_list_head; 842 munmap_list_head = NULL; 843 844 do_cleanups (cleanups); 845 846 return retval; 847 } 848