gdb/compile/compile-object-load.c

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