gdb/compile/compile-object-load.c

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