gdb/compile/compile-object-load.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* Load module for 'compile' command.

  3.    Copyright (C) 2014-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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 "arch-utils.h"

  34. /* Helper data for setup_sections.  */

  36. ‌struct setup_sections_data
  37. {
  38.   /* Size of all recent sections with matching LAST_PROT.  */
  39.   CORE_ADDR last_size;

  41.   /* First section matching LAST_PROT.  */
  42.   asection *last_section_first;

  44.   /* Memory protection like the prot parameter of gdbarch_infcall_mmap. */
  45.   unsigned last_prot;

  47.   /* Maximum of alignments of all sections matching LAST_PROT.
  48.      This value is always at least 1.  This value is always a power of 2.  */
  49.   CORE_ADDR last_max_alignment;
  50. };

  52. /* Place all ABFD sections next to each other obeying all constraints.  */

  54. static void
  55. ‌setup_sections (bfd *abfd, asection *sect, void *data_voidp)
  56. {
  57.   struct setup_sections_data *data = data_voidp;
  58.   CORE_ADDR alignment;
  59.   unsigned prot;

  61.   if (sect != NULL)
  62.     {
  63.       /* It is required by later bfd_get_relocated_section_contents.  */
  64.       if (sect->output_section == NULL)
  65.         sect->output_section = sect;

  67.       if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
  68.         return;

  70.       // Make the memory always readable.
  71.       prot = GDB_MMAP_PROT_READ;
  72.       if ((bfd_get_section_flags (abfd, sect) & SEC_READONLY) == 0)
  73.         prot |= GDB_MMAP_PROT_WRITE;
  74.       if ((bfd_get_section_flags (abfd, sect) & SEC_CODE) != 0)
  75.         prot |= GDB_MMAP_PROT_EXEC;

  77.       if (compile_debug)
  78.         fprintf_unfiltered (gdb_stdout,
  79.                             "module \"%s\" section \"%s\" size %s prot %u\n",
  80.                             bfd_get_filename (abfd),
  81.                             bfd_get_section_name (abfd, sect),
  82.                             paddress (target_gdbarch (),
  83.                                       bfd_get_section_size (sect)),
  84.                             prot);
  85.     }
  86.   else
  87.     prot = -1;

  89.   if (sect == NULL
  90.       || (data->last_prot != prot && bfd_get_section_size (sect) != 0))
  91.     {
  92.       CORE_ADDR addr;
  93.       asection *sect_iter;

  95.       if (data->last_size != 0)
  96.         {
  97.           addr = gdbarch_infcall_mmap (target_gdbarch (), data->last_size,
  98.                                        data->last_prot);
  99.           if (compile_debug)
  100.             fprintf_unfiltered (gdb_stdout,
  101.                                 "allocated %s bytes at %s prot %u\n",
  102.                                 paddress (target_gdbarch (), data->last_size),
  103.                                 paddress (target_gdbarch (), addr),
  104.                                 data->last_prot);
  105.         }
  106.       else
  107.         addr = 0;

  109.       if ((addr & (data->last_max_alignment - 1)) != 0)
  110.         error (_("Inferior compiled module address %s "
  111.                  "is not aligned to BFD required %s."),
  112.                paddress (target_gdbarch (), addr),
  113.                paddress (target_gdbarch (), data->last_max_alignment));

  115.       for (sect_iter = data->last_section_first; sect_iter != sect;
  116.            sect_iter = sect_iter->next)
  117.         if ((bfd_get_section_flags (abfd, sect_iter) & SEC_ALLOC) != 0)
  118.           bfd_set_section_vma (abfd, sect_iter,
  119.                                addr + bfd_get_section_vma (abfd, sect_iter));

  121.       data->last_size = 0;
  122.       data->last_section_first = sect;
  123.       data->last_prot = prot;
  124.       data->last_max_alignment = 1;
  125.     }

  127.   if (sect == NULL)
  128.     return;

  130.   alignment = ((CORE_ADDR) 1) << bfd_get_section_alignment (abfd, sect);
  131.   data->last_max_alignment = max (data->last_max_alignment, alignment);

  133.   data->last_size = (data->last_size + alignment - 1) & -alignment;

  135.   bfd_set_section_vma (abfd, sect, data->last_size);

  137.   data->last_size += bfd_get_section_size (sect);
  138.   data->last_size = (data->last_size + alignment - 1) & -alignment;
  139. }

  141. /* Helper for link_callbacks callbacks vector.  */

  143. static bfd_boolean
  144. ‌link_callbacks_multiple_definition (struct bfd_link_info *link_info,
  145.                                     struct bfd_link_hash_entry *h, bfd *nbfd,
  146.                                     asection *nsec, bfd_vma nval)
  147. {
  148.   bfd *abfd = link_info->input_bfds;

  150.   if (link_info->allow_multiple_definition)
  151.     return TRUE;
  152.   warning (_("Compiled module \"%s\": multiple symbol definitions: %s"),
  153.            bfd_get_filename (abfd), h->root.string);
  154.   return FALSE;
  155. }

  157. /* Helper for link_callbacks callbacks vector.  */

  159. static bfd_boolean
  160. ‌link_callbacks_warning (struct bfd_link_info *link_info, const char *xwarning,
  161.                         const char *symbol, bfd *abfd, asection *section,
  162.                         bfd_vma address)
  163. {
  164.   warning (_("Compiled module \"%s\" section \"%s\": warning: %s"),
  165.            bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
  166.            xwarning);
  167.   /* Maybe permit running as a module?  */
  168.   return FALSE;
  169. }

  171. /* Helper for link_callbacks callbacks vector.  */

  173. static bfd_boolean
  174. ‌link_callbacks_undefined_symbol (struct bfd_link_info *link_info,
  175.                                  const char *name, bfd *abfd, asection *section,
  176.                                  bfd_vma address, bfd_boolean is_fatal)
  177. {
  178.   warning (_("Cannot resolve relocation to \"%s\" "
  179.              "from compiled module \"%s\" section \"%s\"."),
  180.            name, bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
  181.   return FALSE;
  182. }

  184. /* Helper for link_callbacks callbacks vector.  */

  186. static bfd_boolean
  187. ‌link_callbacks_reloc_overflow (struct bfd_link_info *link_info,
  188.                                struct bfd_link_hash_entry *entry,
  189.                                const char *name, const char *reloc_name,
  190.                                bfd_vma addend, bfd *abfd, asection *section,
  191.                                bfd_vma address)
  192. {
  193.   /* TRUE is required for intra-module relocations.  */
  194.   return TRUE;
  195. }

  197. /* Helper for link_callbacks callbacks vector.  */

  199. static bfd_boolean
  200. ‌link_callbacks_reloc_dangerous (struct bfd_link_info *link_info,
  201.                                 const char *message, bfd *abfd,
  202.                                 asection *section, bfd_vma address)
  203. {
  204.   warning (_("Compiled module \"%s\" section \"%s\": dangerous "
  205.              "relocation: %s\n"),
  206.            bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
  207.            message);
  208.   return FALSE;
  209. }

  211. /* Helper for link_callbacks callbacks vector.  */

  213. static bfd_boolean
  214. ‌link_callbacks_unattached_reloc (struct bfd_link_info *link_info,
  215.                                  const char *name, bfd *abfd, asection *section,
  216.                                  bfd_vma address)
  217. {
  218.   warning (_("Compiled module \"%s\" section \"%s\": unattached "
  219.              "relocation: %s\n"),
  220.            bfd_get_filename (abfd), bfd_get_section_name (abfd, section),
  221.            name);
  222.   return FALSE;
  223. }

  225. /* Helper for link_callbacks callbacks vector.  */

  227. static void
  228. ‌link_callbacks_einfo (const char *fmt, ...)
  229. {
  230.   struct cleanup *cleanups;
  231.   va_list ap;
  232.   char *str;

  234.   va_start (ap, fmt);
  235.   str = xstrvprintf (fmt, ap);
  236.   va_end (ap);
  237.   cleanups = make_cleanup (xfree, str);

  239.   warning (_("Compile module: warning: %s"), str);

  241.   do_cleanups (cleanups);
  242. }

  244. /* Helper for bfd_get_relocated_section_contents.
  245.    Only these symbols are set by bfd_simple_get_relocated_section_contents
  246.    but bfd/ seems to use even the NULL ones without checking them first.  */

  248. ‌static const struct bfd_link_callbacks link_callbacks =
  249. {
  250.   NULL, /* add_archive_element */
  251.   link_callbacks_multiple_definition, /* multiple_definition */
  252.   NULL, /* multiple_common */
  253.   NULL, /* add_to_set */
  254.   NULL, /* constructor */
  255.   link_callbacks_warning, /* warning */
  256.   link_callbacks_undefined_symbol, /* undefined_symbol */
  257.   link_callbacks_reloc_overflow, /* reloc_overflow */
  258.   link_callbacks_reloc_dangerous, /* reloc_dangerous */
  259.   link_callbacks_unattached_reloc, /* unattached_reloc */
  260.   NULL, /* notice */
  261.   link_callbacks_einfo, /* einfo */
  262.   NULL, /* info */
  263.   NULL, /* minfo */
  264.   NULL, /* override_segment_assignment */
  265. };

  267. ‌struct link_hash_table_cleanup_data
  268. {
  269.   bfd *abfd;
  270.   bfd *link_next;
  271. };

  273. /* Cleanup callback for struct bfd_link_info.  */

  275. static void
  276. ‌link_hash_table_free (void *d)
  277. {
  278.   struct link_hash_table_cleanup_data *data = d;

  280.   if (data->abfd->is_linker_output)
  281.     (*data->abfd->link.hash->hash_table_free) (data->abfd);
  282.   data->abfd->link.next = data->link_next;
  283. }

  285. /* Relocate and store into inferior memory each section SECT of ABFD.  */

  287. static void
  288. ‌copy_sections (bfd *abfd, asection *sect, void *data)
  289. {
  290.   asymbol **symbol_table = data;
  291.   bfd_byte *sect_data, *sect_data_got;
  292.   struct cleanup *cleanups;
  293.   struct bfd_link_info link_info;
  294.   struct bfd_link_order link_order;
  295.   CORE_ADDR inferior_addr;
  296.   struct link_hash_table_cleanup_data cleanup_data;

  298.   if ((bfd_get_section_flags (abfd, sect) & (SEC_ALLOC | SEC_LOAD))
  299.       != (SEC_ALLOC | SEC_LOAD))
  300.     return;

  302.   if (bfd_get_section_size (sect) == 0)
  303.     return;

  305.   /* Mostly a copy of bfd_simple_get_relocated_section_contents which GDB
  306.      cannot use as it does not report relocations to undefined symbols.  */
  307.   memset (&link_info, 0, sizeof (link_info));
  308.   link_info.output_bfd = abfd;
  309.   link_info.input_bfds = abfd;
  310.   link_info.input_bfds_tail = &abfd->link.next;

  312.   cleanup_data.abfd = abfd;
  313.   cleanup_data.link_next = abfd->link.next;

  315.   abfd->link.next = NULL;
  316.   link_info.hash = bfd_link_hash_table_create (abfd);

  318.   cleanups = make_cleanup (link_hash_table_free, &cleanup_data);
  319.   link_info.callbacks = &link_callbacks;

  321.   memset (&link_order, 0, sizeof (link_order));
  322.   link_order.next = NULL;
  323.   link_order.type = bfd_indirect_link_order;
  324.   link_order.offset = 0;
  325.   link_order.size = bfd_get_section_size (sect);
  326.   link_order.u.indirect.section = sect;

  328.   sect_data = xmalloc (bfd_get_section_size (sect));
  329.   make_cleanup (xfree, sect_data);

  331.   sect_data_got = bfd_get_relocated_section_contents (abfd, &link_info,
  332.                                                       &link_order, sect_data,
  333.                                                       FALSE, symbol_table);

  335.   if (sect_data_got == NULL)
  336.     error (_("Cannot map compiled module \"%s\" section \"%s\": %s"),
  337.            bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
  338.            bfd_errmsg (bfd_get_error ()));
  339.   gdb_assert (sect_data_got == sect_data);

  341.   inferior_addr = bfd_get_section_vma (abfd, sect);
  342.   if (0 != target_write_memory (inferior_addr, sect_data,
  343.                                 bfd_get_section_size (sect)))
  344.     error (_("Cannot write compiled module \"%s\" section \"%s\" "
  345.              "to inferior memory range %s-%s."),
  346.            bfd_get_filename (abfd), bfd_get_section_name (abfd, sect),
  347.            paddress (target_gdbarch (), inferior_addr),
  348.            paddress (target_gdbarch (),
  349.                      inferior_addr + bfd_get_section_size (sect)));

  351.   do_cleanups (cleanups);
  352. }

  354. /* Fetch the type of first parameter of GCC_FE_WRAPPER_FUNCTION.
  355.    Return NULL if GCC_FE_WRAPPER_FUNCTION has no parameters.
  356.    Throw an error otherwise.  */

  358. static struct type *
  359. ‌get_regs_type (struct objfile *objfile)
  360. {
  361.   struct symbol *func_sym;
  362.   struct type *func_type, *regsp_type, *regs_type;

  364.   func_sym = lookup_global_symbol_from_objfile (objfile,
  365.                                                 GCC_FE_WRAPPER_FUNCTION,
  366.                                                 VAR_DOMAIN);
  367.   if (func_sym == NULL)
  368.     error (_("Cannot find function \"%s\" in compiled module \"%s\"."),
  369.            GCC_FE_WRAPPER_FUNCTION, objfile_name (objfile));

  371.   func_type = SYMBOL_TYPE (func_sym);
  372.   if (TYPE_CODE (func_type) != TYPE_CODE_FUNC)
  373.     error (_("Invalid type code %d of function \"%s\" in compiled "
  374.              "module \"%s\"."),
  375.            TYPE_CODE (func_type), GCC_FE_WRAPPER_FUNCTION,
  376.            objfile_name (objfile));

  378.   /* No register parameter present.  */
  379.   if (TYPE_NFIELDS (func_type) == 0)
  380.     return NULL;

  382.   if (TYPE_NFIELDS (func_type) != 1)
  383.     error (_("Invalid %d parameters of function \"%s\" in compiled "
  384.              "module \"%s\"."),
  385.            TYPE_NFIELDS (func_type), GCC_FE_WRAPPER_FUNCTION,
  386.            objfile_name (objfile));

  388.   regsp_type = check_typedef (TYPE_FIELD_TYPE (func_type, 0));
  389.   if (TYPE_CODE (regsp_type) != TYPE_CODE_PTR)
  390.     error (_("Invalid type code %d of first parameter of function \"%s\" "
  391.              "in compiled module \"%s\"."),
  392.            TYPE_CODE (regsp_type), GCC_FE_WRAPPER_FUNCTION,
  393.            objfile_name (objfile));

  395.   regs_type = check_typedef (TYPE_TARGET_TYPE (regsp_type));
  396.   if (TYPE_CODE (regs_type) != TYPE_CODE_STRUCT)
  397.     error (_("Invalid type code %d of dereferenced first parameter "
  398.              "of function \"%s\" in compiled module \"%s\"."),
  399.            TYPE_CODE (regs_type), GCC_FE_WRAPPER_FUNCTION,
  400.            objfile_name (objfile));

  402.   return regs_type;
  403. }

  405. /* Store all inferior registers required by REGS_TYPE to inferior memory
  406.    starting at inferior address REGS_BASE.  */

  408. static void
  409. ‌store_regs (struct type *regs_type, CORE_ADDR regs_base)
  410. {
  411.   struct gdbarch *gdbarch = target_gdbarch ();
  412.   struct regcache *regcache = get_thread_regcache (inferior_ptid);
  413.   int fieldno;

  415.   for (fieldno = 0; fieldno < TYPE_NFIELDS (regs_type); fieldno++)
  416.     {
  417.       const char *reg_name = TYPE_FIELD_NAME (regs_type, fieldno);
  418.       ULONGEST reg_bitpos = TYPE_FIELD_BITPOS (regs_type, fieldno);
  419.       ULONGEST reg_bitsize = TYPE_FIELD_BITSIZE (regs_type, fieldno);
  420.       ULONGEST reg_offset;
  421.       struct type *reg_type = check_typedef (TYPE_FIELD_TYPE (regs_type,
  422.                                                               fieldno));
  423.       ULONGEST reg_size = TYPE_LENGTH (reg_type);
  424.       int regnum;
  425.       struct value *regval;
  426.       CORE_ADDR inferior_addr;

  428.       if (strcmp (reg_name, COMPILE_I_SIMPLE_REGISTER_DUMMY) == 0)
  429.         continue;

  431.       if ((reg_bitpos % 8) != 0 || reg_bitsize != 0)
  432.         error (_("Invalid register \"%s\" position %s bits or size %s bits"),
  433.                reg_name, pulongest (reg_bitpos), pulongest (reg_bitsize));
  434.       reg_offset = reg_bitpos / 8;

  436.       if (TYPE_CODE (reg_type) != TYPE_CODE_INT
  437.           && TYPE_CODE (reg_type) != TYPE_CODE_PTR)
  438.         error (_("Invalid register \"%s\" type code %d"), reg_name,
  439.                TYPE_CODE (reg_type));

  441.       regnum = compile_register_name_demangle (gdbarch, reg_name);

  443.       regval = value_from_register (reg_type, regnum, get_current_frame ());
  444.       if (value_optimized_out (regval))
  445.         error (_("Register \"%s\" is optimized out."), reg_name);
  446.       if (!value_entirely_available (regval))
  447.         error (_("Register \"%s\" is not available."), reg_name);

  449.       inferior_addr = regs_base + reg_offset;
  450.       if (0 != target_write_memory (inferior_addr, value_contents (regval),
  451.                                     reg_size))
  452.         error (_("Cannot write register \"%s\" to inferior memory at %s."),
  453.                reg_name, paddress (gdbarch, inferior_addr));
  454.     }
  455. }

  457. /* Load OBJECT_FILE into inferior memory.  Throw an error otherwise.
  458.    Caller must fully dispose the return value by calling compile_object_run.
  459.    SOURCE_FILE's copy is stored into the returned object.
  460.    Caller should free both OBJECT_FILE and SOURCE_FILE immediatelly after this
  461.    function returns.  */

  463. struct compile_module *
  464. ‌compile_object_load (const char *object_file, const char *source_file)
  465. {
  466.   struct cleanup *cleanups, *cleanups_free_objfile;
  467.   bfd *abfd;
  468.   struct setup_sections_data setup_sections_data;
  469.   CORE_ADDR addr, func_addr, regs_addr;
  470.   struct bound_minimal_symbol bmsym;
  471.   long storage_needed;
  472.   asymbol **symbol_table, **symp;
  473.   long number_of_symbols, missing_symbols;
  474.   struct type *dptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
  475.   unsigned dptr_type_len = TYPE_LENGTH (dptr_type);
  476.   struct compile_module *retval;
  477.   struct type *regs_type;
  478.   char *filename, **matching;
  479.   struct objfile *objfile;

  481.   filename = tilde_expand (object_file);
  482.   cleanups = make_cleanup (xfree, filename);

  484.   abfd = gdb_bfd_open (filename, gnutarget, -1);
  485.   if (abfd == NULL)
  486.     error (_("\"%s\": could not open as compiled module: %s"),
  487.           filename, bfd_errmsg (bfd_get_error ()));
  488.   make_cleanup_bfd_unref (abfd);

  490.   if (!bfd_check_format_matches (abfd, bfd_object, &matching))
  491.     error (_("\"%s\": not in loadable format: %s"),
  492.           filename, gdb_bfd_errmsg (bfd_get_error (), matching));

  494.   if ((bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC)) != 0)
  495.     error (_("\"%s\": not in object format."), filename);

  497.   setup_sections_data.last_size = 0;
  498.   setup_sections_data.last_section_first = abfd->sections;
  499.   setup_sections_data.last_prot = -1;
  500.   setup_sections_data.last_max_alignment = 1;
  501.   bfd_map_over_sections (abfd, setup_sections, &setup_sections_data);
  502.   setup_sections (abfd, NULL, &setup_sections_data);

  504.   storage_needed = bfd_get_symtab_upper_bound (abfd);
  505.   if (storage_needed < 0)
  506.     error (_("Cannot read symbols of compiled module \"%s\": %s"),
  507.           filename, bfd_errmsg (bfd_get_error ()));

  509.   /* SYMFILE_VERBOSE is not passed even if FROM_TTY, user is not interested in
  510.      "Reading symbols from ..." message for automatically generated file.  */
  511.   objfile = symbol_file_add_from_bfd (abfd, filename, 0, NULL, 0, NULL);
  512.   cleanups_free_objfile = make_cleanup_free_objfile (objfile);

  514.   bmsym = lookup_minimal_symbol_text (GCC_FE_WRAPPER_FUNCTION, objfile);
  515.   if (bmsym.minsym == NULL || MSYMBOL_TYPE (bmsym.minsym) == mst_file_text)
  516.     error (_("Could not find symbol \"%s\" of compiled module \"%s\"."),
  517.            GCC_FE_WRAPPER_FUNCTION, filename);
  518.   func_addr = BMSYMBOL_VALUE_ADDRESS (bmsym);

  520.   /* The memory may be later needed
  521.      by bfd_generic_get_relocated_section_contents
  522.      called from default_symfile_relocate.  */
  523.   symbol_table = obstack_alloc (&objfile->objfile_obstack, storage_needed);
  524.   number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
  525.   if (number_of_symbols < 0)
  526.     error (_("Cannot parse symbols of compiled module \"%s\": %s"),
  527.           filename, bfd_errmsg (bfd_get_error ()));

  529.   missing_symbols = 0;
  530.   for (symp = symbol_table; symp < symbol_table + number_of_symbols; symp++)
  531.     {
  532.       asymbol *sym = *symp;

  534.       if (sym->flags != 0)
  535.         continue;
  536.       if (compile_debug)
  537.         fprintf_unfiltered (gdb_stdout,
  538.                             "lookup undefined ELF symbol \"%s\"\n",
  539.                             sym->name);
  540.       sym->flags = BSF_GLOBAL;
  541.       sym->section = bfd_abs_section_ptr;
  542.       if (strcmp (sym->name, "_GLOBAL_OFFSET_TABLE_") == 0)
  543.         {
  544.           sym->value = 0;
  545.           continue;
  546.         }
  547.       bmsym = lookup_minimal_symbol (sym->name, NULL, NULL);
  548.       switch (bmsym.minsym == NULL
  549.               ? mst_unknown : MSYMBOL_TYPE (bmsym.minsym))
  550.         {
  551.         case mst_text:
  552.           sym->value = BMSYMBOL_VALUE_ADDRESS (bmsym);
  553.           break;
  554.         default:
  555.           warning (_("Could not find symbol \"%s\" "
  556.                      "for compiled module \"%s\"."),
  557.                    sym->name, filename);
  558.           missing_symbols++;
  559.         }
  560.     }
  561.   if (missing_symbols)
  562.     error (_("%ld symbols were missing, cannot continue."), missing_symbols);

  564.   bfd_map_over_sections (abfd, copy_sections, symbol_table);

  566.   regs_type = get_regs_type (objfile);
  567.   if (regs_type == NULL)
  568.     regs_addr = 0;
  569.   else
  570.     {
  571.       /* Use read-only non-executable memory protection.  */
  572.       regs_addr = gdbarch_infcall_mmap (target_gdbarch (),
  573.                                         TYPE_LENGTH (regs_type),
  574.                                         GDB_MMAP_PROT_READ);
  575.       gdb_assert (regs_addr != 0);
  576.       store_regs (regs_type, regs_addr);
  577.     }

  579.   discard_cleanups (cleanups_free_objfile);
  580.   do_cleanups (cleanups);

  582.   retval = xmalloc (sizeof (*retval));
  583.   retval->objfile = objfile;
  584.   retval->source_file = xstrdup (source_file);
  585.   retval->func_addr = func_addr;
  586.   retval->regs_addr = regs_addr;
  587.   return retval;
  588. }