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, COMPILE_I_EXPR_VAL, VAR_DOMAIN);
 443       if (gdb_val_sym == NULL)
 444         continue;
 445
 446       function_block = block;
 447       while (function_block != BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)
 448              && function_block != BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK))
 449         {
 450           function_block = BLOCK_SUPERBLOCK (function_block);
 451           function = BLOCK_FUNCTION (function_block);
 452           if (function != NULL)
 453             break;
 454         }
 455       if (function != NULL
 456           && (BLOCK_SUPERBLOCK (function_block)
 457               == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK))
 458           && (strcmp (SYMBOL_LINKAGE_NAME (function), GCC_FE_WRAPPER_FUNCTION)
 459               == 0))
 460         break;
 461     }
 462   if (block_loop == nblocks)
 463     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
 464
 465   gdb_type = SYMBOL_TYPE (gdb_val_sym);
 466   gdb_type = check_typedef (gdb_type);
 467
 468   gdb_ptr_type_sym = block_lookup_symbol (block, COMPILE_I_EXPR_PTR_TYPE,
 469                                           VAR_DOMAIN);
 470   if (gdb_ptr_type_sym == NULL)
 471     error (_("No \"%s\" symbol found"), COMPILE_I_EXPR_PTR_TYPE);
 472   gdb_ptr_type = SYMBOL_TYPE (gdb_ptr_type_sym);
 473   gdb_ptr_type = check_typedef (gdb_ptr_type);
 474   if (TYPE_CODE (gdb_ptr_type) != TYPE_CODE_PTR)
 475     error (_("Type of \"%s\" is not a pointer"), COMPILE_I_EXPR_PTR_TYPE);
 476   gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_ptr_type);
 477
 478   if (types_deeply_equal (gdb_type, gdb_type_from_ptr))
 479     {
 480       if (scope != COMPILE_I_PRINT_ADDRESS_SCOPE)
 481         error (_("Expected address scope in compiled module \"%s\"."),
 482                objfile_name (objfile));
 483       return gdb_type;
 484     }
 485
 486   if (TYPE_CODE (gdb_type) != TYPE_CODE_PTR)
 487     error (_("Invalid type code %d of symbol \"%s\" "
 488              "in compiled module \"%s\"."),
 489            TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_VAL,
 490            objfile_name (objfile));
 491
 492   retval = gdb_type_from_ptr;
 493   switch (TYPE_CODE (gdb_type_from_ptr))
 494     {
 495     case TYPE_CODE_ARRAY:
 496       gdb_type_from_ptr = TYPE_TARGET_TYPE (gdb_type_from_ptr);
 497       break;
 498     case TYPE_CODE_FUNC:
 499       break;
 500     default:
 501       error (_("Invalid type code %d of symbol \"%s\" "
 502                "in compiled module \"%s\"."),
 503              TYPE_CODE (gdb_type_from_ptr), COMPILE_I_EXPR_PTR_TYPE,
 504              objfile_name (objfile));
 505     }
 506   if (!types_deeply_equal (gdb_type_from_ptr,
 507                            TYPE_TARGET_TYPE (gdb_type)))
 508     error (_("Referenced types do not match for symbols \"%s\" and \"%s\" "
 509              "in compiled module \"%s\"."),
 510            COMPILE_I_EXPR_PTR_TYPE, COMPILE_I_EXPR_VAL,
 511            objfile_name (objfile));
 512   if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE)
 513     return NULL;
 514   return retval;
 515 }
 516
 517 /* Fetch the type of first parameter of FUNC_SYM.
 518    Return NULL if FUNC_SYM has no parameters.  Throw an error otherwise.  */
 519
 520 static struct type *
 521 get_regs_type (struct symbol *func_sym, struct objfile *objfile)
 522 {
 523   struct type *func_type = SYMBOL_TYPE (func_sym);
 524   struct type *regsp_type, *regs_type;
 525
 526   /* No register parameter present.  */
 527   if (TYPE_NFIELDS (func_type) == 0)
 528     return NULL;
 529
 530   regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
 531   if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
 532     error (_("Invalid type code %d of first parameter of function \"%s\" "
 533              "in compiled module \"%s\"."),
 534            TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
 535            objfile_name (objfile));
 536
 537   regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
 538   if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
 539     error (_("Invalid type code %d of dereferenced first parameter "
 540              "of function \"%s\" in compiled module \"%s\"."),
 541            TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
 542            objfile_name (objfile));
 543
 544   return regs_type;
 545 }
 546
 547 /* Store all inferior registers required by REGS_TYPE to inferior memory
 548    starting at inferior address REGS_BASE.  */
 549
 550 static void
 551 store_regs (struct type *regs_type, CORE_ADDR regs_base)
 552 {
 553   struct gdbarch *gdbarch = target_gdbarch ();
 554   struct regcache *regcache = get_thread_regcache (inferior_ptid);
 555   int fieldno;
 556
 557   for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
 558     {
 559       const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
 560       ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
 561       ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
 562       ULONGEST reg_offset;
 563       struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
 564                                                               fieldno));
 565       ULONGEST reg_size = TYPE_LENGTH (reg_type);
 566       int regnum;
 567       struct value *regval;
 568       CORE_ADDR inferior_addr;
 569
 570       if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
 571         continue;
 572
 573       if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
 574         error (_("Invalid register \"%s\" position %s bits or size %s bits"),
 575                reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
 576       reg_offset = reg_bitpos / 8;
 577
 578       if (TYPE_CODE (reg_type) != TYPE_CODE_INT
 579           && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
 580         error (_("Invalid register \"%s\" type code %d"), reg_name,
 581                TYPE_CODE (reg_type));
 582
 583       regnum = compile_register_name_demangle (gdbarch, reg_name);
 584
 585       regval = value_from_register (reg_type, regnum, get_current_frame ());
 586       if (value_optimized_out (regval))
 587         error (_("Register \"%s\" is optimized out."), reg_name);
 588       if (!value_entirely_available (regval))
 589         error (_("Register \"%s\" is not available."), reg_name);
 590
 591       inferior_addr = regs_base + reg_offset;
 592       if (0 != target_write_memory (inferior_addr, value_contents (regval),
 593                                     reg_size))
 594         error (_("Cannot write register \"%s\" to inferior memory at %s."),
 595                reg_name, paddress (gdbarch, inferior_addr));
 596     }
 597 }
 598
 599 /* Load the object file specified in FILE_NAMES into inferior memory.
 600    Throw an error otherwise.  Caller must fully dispose the return
 601    value by calling compile_object_run.  Returns NULL only for
 602    COMPILE_I_PRINT_ADDRESS_SCOPE when COMPILE_I_PRINT_VALUE_SCOPE
 603    should have been used instead.  */
 604
 605 struct compile_module *
 606 compile_object_load (const compile_file_names &file_names,
 607                      enum compile_i_scope_types scope, void *scope_data)
 608 {
 609   struct cleanup *cleanups;
 610   struct setup_sections_data setup_sections_data;
 611   CORE_ADDR regs_addr, out_value_addr = 0;
 612   struct symbol *func_sym;
 613   struct type *func_type;
 614   struct bound_minimal_symbol bmsym;
 615   long storage_needed;
 616   asymbol **symbol_table, **symp;
 617   long number_of_symbols, missing_symbols;
 618   struct compile_module *retval;
 619   struct type *regs_type, *out_value_type = NULL;
 620   char **matching;
 621   struct objfile *objfile;
 622   int expect_parameters;
 623   struct type *expect_return_type;
 624   struct munmap_list *munmap_list_head = NULL;
 625
 626   gdb::unique_xmalloc_ptr<char> filename
 627     (tilde_expand (file_names.object_file ()));
 628
 629   gdb_bfd_ref_ptr abfd (gdb_bfd_open (filename.get (), gnutarget, -1));
 630   if (abfd == NULL)
 631     error (_("\"%s\": could not open as compiled module: %s"),
 632           filename.get (), bfd_errmsg (bfd_get_error ()));
 633
 634   if (!bfd_check_format_matches (abfd.get (), bfd_object, &matching))
 635     error (_("\"%s\": not in loadable format: %s"),
 636           filename.get (), gdb_bfd_errmsg (bfd_get_error (), matching));
 637
 638   if ((bfd_get_file_flags (abfd.get ()) & (EXEC_P | DYNAMIC)) != 0)
 639     error (_("\"%s\": not in object format."), filename.get ());
 640
 641   setup_sections_data.last_size = 0;
 642   setup_sections_data.last_section_first = abfd->sections;
 643   setup_sections_data.last_prot = -1;
 644   setup_sections_data.last_max_alignment = 1;
 645   setup_sections_data.munmap_list_headp = &munmap_list_head;
 646   cleanups = make_cleanup (munmap_listp_free_cleanup, &munmap_list_head);
 647   bfd_map_over_sections (abfd.get (), setup_sections, &setup_sections_data);
 648   setup_sections (abfd.get (), NULL, &setup_sections_data);
 649
 650   storage_needed = bfd_get_symtab_upper_bound (abfd.get ());
 651   if (storage_needed < 0)
 652     error (_("Cannot read symbols of compiled module \"%s\": %s"),
 653           filename.get (), bfd_errmsg (bfd_get_error ()));
 654
 655   /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
 656      "Reading symbols from ..." message for automatically generated file.  */
 657   std::unique_ptr<struct objfile> objfile_holder
 658     (symbol_file_add_from_bfd (abfd.get (), filename.get (),
 659                                0, NULL, 0, NULL));
 660   objfile = objfile_holder.get ();
 661
 662   func_sym = lookup_global_symbol_from_objfile (objfile,
 663                                                 GCC_FE_WRAPPER_FUNCTION,
 664                                                 VAR_DOMAIN).symbol;
 665   if (func_sym == NULL)
 666     error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
 667            GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
 668   func_type = SYMBOL_TYPE (func_sym);
 669   if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
 670     error (_("Invalid type code %d of function \"%s\" in compiled "
 671              "module \"%s\"."),
 672            TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
 673            objfile_name (objfile));
 674
 675   switch (scope)
 676     {
 677     case COMPILE_I_SIMPLE_SCOPE:
 678       expect_parameters = 1;
 679       expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
 680       break;
 681     case COMPILE_I_RAW_SCOPE:
 682       expect_parameters = 0;
 683       expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
 684       break;
 685     case COMPILE_I_PRINT_ADDRESS_SCOPE:
 686     case COMPILE_I_PRINT_VALUE_SCOPE:
 687       expect_parameters = 2;
 688       expect_return_type = builtin_type (target_gdbarch ())->builtin_void;
 689       break;
 690     default:
 691       internal_error (__FILE__, __LINE__, _("invalid scope %d"), scope);
 692     }
 693   if (TYPE_NFIELDS (func_type) != expect_parameters)
 694     error (_("Invalid %d parameters of function \"%s\" in compiled "
 695              "module \"%s\"."),
 696            TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
 697            objfile_name (objfile));
 698   if (!types_deeply_equal (expect_return_type, TYPE_TARGET_TYPE (func_type)))
 699     error (_("Invalid return type of function \"%s\" in compiled "
 700             "module \"%s\"."),
 701           GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));
 702
 703   /* The memory may be later needed
 704      by bfd_generic_get_relocated_section_contents
 705      called from default_symfile_relocate.  */
 706   symbol_table = (asymbol **) obstack_alloc (&objfile->objfile_obstack,
 707                                              storage_needed);
 708   number_of_symbols = bfd_canonicalize_symtab (abfd.get (), symbol_table);
 709   if (number_of_symbols < 0)
 710     error (_("Cannot parse symbols of compiled module \"%s\": %s"),
 711           filename.get (), bfd_errmsg (bfd_get_error ()));
 712
 713   missing_symbols = 0;
 714   for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
 715     {
 716       asymbol *sym = *symp;
 717
 718       if (sym->flags != 0)
 719         continue;
 720       sym->flags = BSF_GLOBAL;
 721       sym->section = bfd_abs_section_ptr;
 722       if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
 723         {
 724           if (compile_debug)
 725             fprintf_unfiltered (gdb_stdlog,
 726                                 "ELF symbol \"%s\" relocated to zero\n",
 727                                 sym->name);
 728
 729           /* It seems to be a GCC bug, with -mcmodel=large there should be no
 730              need for _GLOBAL_OFFSET_TABLE_.  Together with -fPIE the data
 731              remain PC-relative even with _GLOBAL_OFFSET_TABLE_ as zero.  */
 732           sym->value = 0;
 733           continue;
 734         }
 735       bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
 736       switch (bmsym.minsym == NULL
 737               ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
 738         {
 739         case mst_text:
 740           sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
 741           if (compile_debug)
 742             fprintf_unfiltered (gdb_stdlog,
 743                                 "ELF mst_text symbol \"%s\" relocated to %s\n",
 744                                 sym->name,
 745                                 paddress (target_gdbarch (), sym->value));
 746           break;
 747         case mst_text_gnu_ifunc:
 748           sym->value = gnu_ifunc_resolve_addr (target_gdbarch (),
 749                                                BMSYMBOL_VALUE_ADDRESS (bmsym));
 750           if (compile_debug)
 751             fprintf_unfiltered (gdb_stdlog,
 752                                 "ELF mst_text_gnu_ifunc symbol \"%s\" "
 753                                 "relocated to %s\n",
 754                                 sym->name,
 755                                 paddress (target_gdbarch (), sym->value));
 756           break;
 757         default:
 758           warning (_("Could not find symbol \"%s\" "
 759                      "for compiled module \"%s\"."),
 760                    sym->name, filename.get ());
 761           missing_symbols++;
 762         }
 763     }
 764   if (missing_symbols)
 765     error (_("%ld symbols were missing, cannot continue."), missing_symbols);
 766
 767   bfd_map_over_sections (abfd.get (), copy_sections, symbol_table);
 768
 769   regs_type = get_regs_type (func_sym, objfile);
 770   if (regs_type == NULL)
 771     regs_addr = 0;
 772   else
 773     {
 774       /* Use read-only non-executable memory protection.  */
 775       regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
 776                                         TYPE_LENGTH (regs_type),
 777                                         GDB_MMAP_PROT_READ);
 778       gdb_assert (regs_addr != 0);
 779       munmap_list_add (&munmap_list_head, regs_addr, TYPE_LENGTH (regs_type));
 780       if (compile_debug)
 781         fprintf_unfiltered (gdb_stdlog,
 782                             "allocated %s bytes at %s for registers\n",
 783                             paddress (target_gdbarch (),
 784                                       TYPE_LENGTH (regs_type)),
 785                             paddress (target_gdbarch (), regs_addr));
 786       store_regs (regs_type, regs_addr);
 787     }
 788
 789   if (scope == COMPILE_I_PRINT_ADDRESS_SCOPE
 790       || scope == COMPILE_I_PRINT_VALUE_SCOPE)
 791     {
 792       out_value_type = get_out_value_type (func_sym, objfile, scope);
 793       if (out_value_type == NULL)
 794         {
 795           do_cleanups (cleanups);
 796           return NULL;
 797         }
 798       check_typedef (out_value_type);
 799       out_value_addr = gdbarch_infcall_mmap (target_gdbarch (),
 800                                              TYPE_LENGTH (out_value_type),
 801                                              (GDB_MMAP_PROT_READ
 802                                               | GDB_MMAP_PROT_WRITE));
 803       gdb_assert (out_value_addr != 0);
 804       munmap_list_add (&munmap_list_head, out_value_addr,
 805                        TYPE_LENGTH (out_value_type));
 806       if (compile_debug)
 807         fprintf_unfiltered (gdb_stdlog,
 808                             "allocated %s bytes at %s for printed value\n",
 809                             paddress (target_gdbarch (),
 810                                       TYPE_LENGTH (out_value_type)),
 811                             paddress (target_gdbarch (), out_value_addr));
 812     }
 813
 814   retval = XNEW (struct compile_module);
 815   retval->objfile = objfile_holder.release ();
 816   retval->source_file = xstrdup (file_names.source_file ());
 817   retval->func_sym = func_sym;
 818   retval->regs_addr = regs_addr;
 819   retval->scope = scope;
 820   retval->scope_data = scope_data;
 821   retval->out_value_type = out_value_type;
 822   retval->out_value_addr = out_value_addr;
 823
 824   /* CLEANUPS will free MUNMAP_LIST_HEAD.  */
 825   retval->munmap_list_head = munmap_list_head;
 826   munmap_list_head = NULL;
 827
 828   do_cleanups (cleanups);
 829
 830   return retval;
 831 }