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 "compile.h"
  32 #include "block.h"
  33 #include "arch-utils.h"
  34 #include <algorithm>
  35
  36 /* Track inferior memory reserved by inferior mmap.  */
  37
  38 struct munmap_list
  39 {
  40   struct munmap_list *next;
  41   CORE_ADDR addr, size;
  42 };
  43
  44 /* Add inferior mmap memory range ADDR..ADDR+SIZE (exclusive) to list
  45    HEADP.  *HEADP needs to be initialized to NULL.  */
  46
  47 static void
  48 munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
  49 {
  50   struct munmap_list *head_new = XNEW (struct munmap_list);
  51
  52   head_new->next = *headp;
  53   *headp = head_new;
  54   head_new->addr = addr;
  55   head_new->size = size;
  56 }
  57
  58 /* Free list of inferior mmap memory ranges HEAD.  HEAD is the first
  59    element of the list, it can be NULL.  After calling this function
  60    HEAD pointer is invalid and the possible list needs to be
  61    reinitialized by caller to NULL.  */
  62
  63 void
  64 munmap_list_free (struct munmap_list *head)
  65 {
  66   while (head)
  67     {
  68       struct munmap_list *todo = head;
  69
  70       head = todo->next;
  71       gdbarch_infcall_munmap (target_gdbarch (), todo->addr, todo->size);
  72       xfree (todo);
  73     }
  74 }
  75
  76 /* Stub for munmap_list_free suitable for make_cleanup.  Contrary to
  77    munmap_list_free this function's parameter is a pointer to the first
  78    list element pointer.  */
  79
  80 static void
  81 munmap_listp_free_cleanup (void *headp_voidp)
  82 {
  83   struct munmap_list **headp = (struct munmap_list **) headp_voidp;
  84
  85   munmap_list_free (*headp);
  86 }
  87
  88 /* Helper data for setup_sections.  */
  89
  90 struct setup_sections_data
  91 {
  92   /* Size of all recent sections with matching LAST_PROT.  */
  93   CORE_ADDR last_size;
  94
  95   /* First section matching LAST_PROT.  */
  96   asection *last_section_first;
  97
  98   /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
  99   unsigned last_prot;
 100
 101   /* Maximum of alignments of all sections matching LAST_PROT.
 102      This value is always at least 1.  This value is always a power of 2.  */
 103   CORE_ADDR last_max_alignment;
 104
 105   /* List of inferior mmap ranges where setup_sections should add its
 106      next range.  */
 107   struct munmap_list **munmap_list_headp;
 108 };
 109
 110 /* Place all ABFD sections next to each other obeying all constraints.  */
 111
 112 static void
 113 setup_sections (bfd *abfd, asection *sect, void *data_voidp)
 114 {
 115   struct setup_sections_data *data = (struct setup_sections_data *) data_voidp;
 116   CORE_ADDR alignment;
 117   unsigned prot;
 118
 119   if (sect != NULL)
 120     {
 121       /* It is required by later bfd_get_relocated_section_contents.  */
 122       if (sect->output_section == NULL)
 123         sect->output_section = sect;
 124
 125       if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
 126         return;
 127
 128       /* Make the memory always readable.  */
 129       prot = GDB_MMAP_PROT_READ;
 130       if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0)
 131         prot |= GDB_MMAP_PROT_WRITE;
 132       if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0)
 133         prot |= GDB_MMAP_PROT_EXEC;
 134
 135       if (compile_debug)
 136         fprintf_unfiltered (gdb_stdlog,
 137                             "module \"%s\" section \"%s\" size %s prot %u\n",
 138                             bfd_get_filename (abfd),
 139                             bfd_get_section_name (abfd, sect),
 140                             paddress (target_gdbarch (),
 141                                       bfd_get_section_size (sect)),
 142                             prot);
 143     }
 144   else
 145     prot = -1;
 146
 147   if (sect == NULL
 148       || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
 149     {
 150       CORE_ADDR addr;
 151       asection *sect_iter;
 152
 153       if (data->last_size != 0)
 154         {
 155           addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size,
 156                                        data->last_prot);
 157           munmap_list_add (data->munmap_list_headp, addr, data->last_size);
 158           if (compile_debug)
 159             fprintf_unfiltered (gdb_stdlog,
 160                                 "allocated %s bytes at %s prot %u\n",
 161                                 paddress (target_gdbarch (), data->last_size),
 162                                 paddress (target_gdbarch (), addr),
 163                                 data->last_prot);
 164         }
 165       else
 166         addr = 0;
 167
 168       if ((addr & (data->last_max_alignment - 1)) != 0)
 169         error (_("Inferior compiled module address %s "
 170                  "is not aligned to BFD required %s."),
 171                paddress (target_gdbarch (), addr),
 172                paddress (target_gdbarch (), data->last_max_alignment));
 173
 174       for (sect_iter = data->last_section_first; sect_iter != sect;
 175            sect_iter = sect_iter->next)
 176         if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0)
 177           bfd_set_section_vma (abfd, sect_iter,
 178                                addr + bfd_get_section_vma (abfd, sect_iter));
 179
 180       data->last_size = 0;
 181       data->last_section_first = sect;
 182       data->last_prot = prot;
 183       data->last_max_alignment = 1;
 184     }
 185
 186   if (sect == NULL)
 187     return;
 188
 189   alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
 190   data->last_max_alignment = std::max (data->last_max_alignment, alignment);
 191
 192   data->last_size = (data->last_size + alignment - 1) & -alignment;
 193
 194   bfd_set_section_vma (abfd, sect, data->last_size);
 195
 196   data->last_size += bfd_get_section_size (sect);
 197   data->last_size = (data->last_size + alignment - 1) & -alignment;
 198 }
 199
 200 /* Helper for link_callbacks callbacks vector.  */
 201
 202 static void
 203 link_callbacks_multiple_definition (struct bfd_link_info *link_info,
 204                                     struct bfd_link_hash_entry *h, bfd *nbfd,
 205                                     asection *nsec, bfd_vma nval)
 206 {
 207   bfd *abfd = link_info->input_bfds;
 208
 209   if (link_info->allow_multiple_definition)
 210     return;
 211   warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
 212            bfd_get_filename (abfd), h->root.string);
 213 }
 214
 215 /* Helper for link_callbacks callbacks vector.  */
 216
 217 static void
 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 }
 226
 227 /* Helper for link_callbacks callbacks vector.  */
 228
 229 static void
 230 link_callbacks_undefined_symbol (struct bfd_link_info *link_info,
 231                                  const char *name, bfd *abfd, asection *section,
 232                                  bfd_vma address, bfd_boolean is_fatal)
 233 {
 234   warning (_("Cannot resolve relocation to \"%s\" "
 235              "from compiled module \"%s\" section \"%s\"."),
 236            name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
 237 }
 238
 239 /* Helper for link_callbacks callbacks vector.  */
 240
 241 static void
 242 link_callbacks_reloc_overflow (struct bfd_link_info *link_info,
 243                                struct bfd_link_hash_entry *entry,
 244                                const char *name, const char *reloc_name,
 245                                bfd_vma addend, bfd *abfd, asection *section,
 246                                bfd_vma address)
 247 {
 248 }
 249
 250 /* Helper for link_callbacks callbacks vector.  */
 251
 252 static void
 253 link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
 254                                 const char *message, bfd *abfd,
 255                                 asection *section, bfd_vma address)
 256 {
 257   warning (_("Compiled module \"%s\" section \"%s\": dangerous "
 258              "relocation: %s\n"),
 259            bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
 260            message);
 261 }
 262
 263 /* Helper for link_callbacks callbacks vector.  */
 264
 265 static void
 266 link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
 267                                  const char *name, bfd *abfd, asection *section,
 268                                  bfd_vma address)
 269 {
 270   warning (_("Compiled module \"%s\" section \"%s\": unattached "
 271              "relocation: %s\n"),
 272            bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
 273            name);
 274 }
 275
 276 /* Helper for link_callbacks callbacks vector.  */
 277
 278 static void link_callbacks_einfo (const char *fmt, ...)
 279   ATTRIBUTE_PRINTF (1, 2);
 280
 281 static void
 282 link_callbacks_einfo (const char *fmt, ...)
 283 {
 284   va_list ap;
 285
 286   va_start (ap, fmt);
 287   std::string str = string_vprintf (fmt, ap);
 288   va_end (ap);
 289
 290   warning (_("Compile module: warning: %s"), str.c_str ());
 291 }
 292
 293 /* Helper for bfd_get_relocated_section_contents.
 294    Only these symbols are set by bfd_simple_get_relocated_section_contents
 295    but bfd/ seems to use even the NULL ones without checking them first.  */
 296
 297 static const struct bfd_link_callbacks link_callbacks =
 298 {
 299   NULL, /* add_archive_element */
 300   link_callbacks_multiple_definition, /* multiple_definition */
 301   NULL, /* multiple_common */
 302   NULL, /* add_to_set */
 303   NULL, /* constructor */
 304   link_callbacks_warning, /* warning */
 305   link_callbacks_undefined_symbol, /* undefined_symbol */
 306   link_callbacks_reloc_overflow, /* reloc_overflow */
 307   link_callbacks_reloc_dangerous, /* reloc_dangerous */
 308   link_callbacks_unattached_reloc, /* unattached_reloc */
 309   NULL, /* notice */
 310   link_callbacks_einfo, /* einfo */
 311   NULL, /* info */
 312   NULL, /* minfo */
 313   NULL, /* override_segment_assignment */
 314 };
 315
 316 struct link_hash_table_cleanup_data
 317 {
 318   bfd *abfd;
 319   bfd *link_next;
 320 };
 321
 322 /* Cleanup callback for struct bfd_link_info.  */
 323
 324 static void
 325 link_hash_table_free (void *d)
 326 {
 327   struct link_hash_table_cleanup_data *data
 328     = (struct link_hash_table_cleanup_data *) d;
 329
 330   if (data->abfd->is_linker_output)
 331     (*data->abfd->link.hash->hash_table_free) (data->abfd);
 332   data->abfd->link.next = data->link_next;
 333 }
 334
 335 /* Relocate and store into inferior memory each section SECT of ABFD.  */
 336
 337 static void
 338 copy_sections (bfd *abfd, asection *sect, void *data)
 339 {
 340   asymbol **symbol_table = (asymbol **) data;
 341   bfd_byte *sect_data, *sect_data_got;
 342   struct cleanup *cleanups;
 343   struct bfd_link_info link_info;
 344   struct bfd_link_order link_order;
 345   CORE_ADDR inferior_addr;
 346   struct link_hash_table_cleanup_data cleanup_data;
 347
 348   if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
 349       != (SEC_ALLOC | SEC_LOAD))
 350     return;
 351
 352   if (bfd_get_section_size (sect) == 0)
 353     return;
 354
 355   /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
 356      cannot use as it does not report relocations to undefined symbols.  */
 357   memset (&link_info, 0, sizeof (link_info));
 358   link_info.output_bfd = abfd;
 359   link_info.input_bfds = abfd;
 360   link_info.input_bfds_tail = &abfd->link.next;
 361
 362   cleanup_data.abfd = abfd;
 363   cleanup_data.link_next = abfd->link.next;
 364
 365   abfd->link.next = NULL;
 366   link_info.hash = bfd_link_hash_table_create (abfd);
 367
 368   cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
 369   link_info.callbacks = &link_callbacks;
 370
 371   memset (&link_order, 0, sizeof (link_order));
 372   link_order.next = NULL;
 373   link_order.type = bfd_indirect_link_order;
 374   link_order.offset = 0;
 375   link_order.size = bfd_get_section_size (sect);
 376   link_order.u.indirect.section = sect;
 377
 378   sect_data = (bfd_byte *) xmalloc (bfd_get_section_size (sect));
 379   make_cleanup (xfree, sect_data);
 380
 381   sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
 382                                                       &link_order, sect_data,
 383                                                       FALSE, symbol_table);
 384
 385   if (sect_data_got == NULL)
 386     error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
 387            bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
 388            bfd_errmsg (bfd_get_error ()));
 389   gdb_assert (sect_data_got == sect_data);
 390
 391   inferior_addr = bfd_get_section_vma (abfd, sect);
 392   if (0 != target_write_memory (inferior_addr, sect_data,
 393                                 bfd_get_section_size (sect)))
 394     error (_("Cannot write compiled module \"%s\" section \"%s\" "
 395              "to inferior memory range %s-%s."),
 396            bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
 397            paddress (target_gdbarch (), inferior_addr),
 398            paddress (target_gdbarch (),
 399                      inferior_addr + bfd_get_section_size (sect)));
 400
 401   do_cleanups (cleanups);
 402 }
 403
 404 /* Fetch the type of COMPILE_I_EXPR_PTR_TYPE and COMPILE_I_EXPR_VAL
 405    symbols in OBJFILE so we can calculate how much memory to allocate
 406    for the out parameter.  This avoids needing a malloc in the generated
 407    code.  Throw an error if anything fails.
 408    GDB first tries to compile the code with COMPILE_I_PRINT_ADDRESS_SCOPE.
 409    If it finds user tries to print an array type this function returns
 410    NULL.  Caller will then regenerate the code with
 411    COMPILE_I_PRINT_VALUE_SCOPE, recompiles it again and finally runs it.
 412    This is because __auto_type array-to-pointer type conversion of
 413    COMPILE_I_EXPR_VAL which gets detected by COMPILE_I_EXPR_PTR_TYPE
 414    preserving the array type.  */
 415
 416 static struct type *
 417 get_out_value_type (struct symbol *func_sym, struct objfile *objfile,
 418                     enum compile_i_scope_types scope)
 419 {
 420   struct symbol *gdb_ptr_type_sym;
 421   /* Initialize it just to avoid a GCC false warning.  */
 422   struct symbol *gdb_val_sym = NULL;
 423   struct type *gdb_ptr_type, *gdb_type_from_ptr, *gdb_type, *retval;
 424   /* Initialize it just to avoid a GCC false warning.  */
 425   const struct block *block = NULL;
 426   const struct blockvector *bv;
 427   int nblocks = 0;
 428   int block_loop = 0;
 429
 430   bv = SYMTAB_BLOCKVECTOR (func_sym->owner.symtab);
 431   nblocks = BLOCKVECTOR_NBLOCKS (bv);
 432
 433   gdb_ptr_type_sym = NULL;
 434   for (block_loop = 0; block_loop < nblocks; block_loop++)
 435     {
 436       struct symbol *function = NULL;
 437       const struct block *function_block;
 438
 439       block = BLOCKVECTOR_BLOCK (bv, block_loop);
 440       if (BLOCK_FUNCTION (block) != NULL)
 441         continue;
 442       gdb_val_sym = block_lookup_symbol (block,
 443                                          COMPILE_I_EXPR_VAL,
 444                                          symbol_name_match_type::SEARCH_NAME,
 445                                          VAR_DOMAIN);
 446       if (gdb_val_sym == NULL)
 447         continue;
 448
 449       function_block = block;
 450       while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
 451              && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
 452         {
 453           function_block = BLOCK_SUPERBLOCK (function_block);
 454           function = BLOCK_FUNCTION (function_block);
 455           if (function != NULL)
 456             break;
 457         }
 458       if (function != NULL
 459           && (BLOCK_SUPERBLOCK (function_block)
 460               == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
 461           && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
 462               == 0))
 463         break;
 464     }
 465   if (block_loop == nblocks)
 466     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
 467
 468   gdb_type = SYMBOL_TYPE (gdb_val_sym);
 469   gdb_type = check_typedef (gdb_type);
 470
 471   gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
 472                                           symbol_name_match_type::SEARCH_NAME,
 473                                           VAR_DOMAIN);
 474   if (gdb_ptr_type_sym == NULL)
 475     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
 476   gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
 477   gdb_ptr_type = check_typedef (gdb_ptr_type);
 478   if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
 479     error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
 480   gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
 481
 482   if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
 483     {
 484       if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
 485         error (_("Expected address scope in compiled module \"%s\"."),
 486                objfile_name (objfile));
 487       return gdb_type;
 488     }
 489
 490   if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
 491     error (_("Invalid type code %d of symbol \"%s\" "
 492              "in compiled module \"%s\"."),
 493            TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
 494            objfile_name (objfile));
 495
 496   retval = gdb_type_from_ptr;
 497   switch (TYPE_CODE (gdb_type_from_ptr))
 498     {
 499     case TYPE_CODE_ARRAY:
 500       gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
 501       break;
 502     case TYPE_CODE_FUNC:
 503       break;
 504     default:
 505       error (_("Invalid type code %d of symbol \"%s\" "
 506                "in compiled module \"%s\"."),
 507              TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
 508              objfile_name (objfile));
 509     }
 510   if (!types_deeply_equal (gdb_type_from_ptr,
 511                            TYPE_TARGET_TYPE (gdb_type)))
 512     error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
 513              "in compiled module \"%s\"."),
 514            COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
 515            objfile_name (objfile));
 516   if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
 517     return NULL;
 518   return retval;
 519 }
 520
 521 /* Fetch the type of first parameter of FUNC_SYM.
 522    Return NULL if FUNC_SYM has no parameters.  Throw an error otherwise.  */
 523
 524 static struct type *
 525 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
 526 {
 527   struct type *func_type = SYMBOL_TYPE (func_sym);
 528   struct type *regsp_type, *regs_type;
 529
 530   /* No register parameter present.  */
 531   if (TYPE_NFIELDS (func_type) == 0)
 532     return NULL;
 533
 534   regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
 535   if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
 536     error (_("Invalid type code %d of first parameter of function \"%s\" "
 537              "in compiled module \"%s\"."),
 538            TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
 539            objfile_name (objfile));
 540
 541   regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
 542   if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
 543     error (_("Invalid type code %d of dereferenced first parameter "
 544              "of function \"%s\" in compiled module \"%s\"."),
 545            TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
 546            objfile_name (objfile));
 547
 548   return regs_type;
 549 }
 550
 551 /* Store all inferior registers required by REGS_TYPE to inferior memory
 552    starting at inferior address REGS_BASE.  */
 553
 554 static void
 555 store_regs (struct type *regs_type, CORE_ADDR regs_base)
 556 {
 557   struct gdbarch *gdbarch = target_gdbarch ();
 558   struct regcache *regcache = get_thread_regcache (inferior_ptid);
 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 }