X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgcore.c;h=07c1997bfdff4479666f509bf3b76ef5ceeaf9ff;hb=a102602bc56e418f9794d653ef103a65f08a5a49;hp=620be54dd99215010eabacde6ffa2220bfd3d6e8;hpb=85e1311a3cf4df0eafe2886a29fc753054b71e37;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/gcore.c b/gdb/gcore.c index 620be54dd9..07c1997bfd 100644 --- a/gdb/gcore.c +++ b/gdb/gcore.c @@ -1,6 +1,6 @@ /* Generate a core file for the inferior process. - Copyright (C) 2001-2013 Free Software Foundation, Inc. + Copyright (C) 2001-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -29,11 +29,14 @@ #include "completer.h" #include "gcore.h" #include "cli/cli-decode.h" -#include "gdb_assert.h" #include #include "regcache.h" #include "regset.h" #include "gdb_bfd.h" +#include "readline/tilde.h" +#include +#include "common/gdb_unlinker.h" +#include "byte-vector.h" /* The largest amount of memory to read from the target at once. We must throttle it to limit the amount of memory used by GDB during @@ -48,25 +51,24 @@ static int gcore_memory_sections (bfd *); /* create_gcore_bfd -- helper for gcore_command (exported). Open a new bfd core file for output, and return the handle. */ -bfd * +gdb_bfd_ref_ptr create_gcore_bfd (const char *filename) { - bfd *obfd = gdb_bfd_openw (filename, default_gcore_target ()); + gdb_bfd_ref_ptr obfd (gdb_bfd_openw (filename, default_gcore_target ())); - if (!obfd) + if (obfd == NULL) error (_("Failed to open '%s' for output."), filename); - bfd_set_format (obfd, bfd_core); - bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ()); + bfd_set_format (obfd.get (), bfd_core); + bfd_set_arch_mach (obfd.get (), default_gcore_arch (), default_gcore_mach ()); return obfd; } -/* write_gcore_file -- helper for gcore_command (exported). - Compose and write the corefile data to the core file. */ - +/* write_gcore_file_1 -- do the actual work of write_gcore_file. */ -void -write_gcore_file (bfd *obfd) +static void +write_gcore_file_1 (bfd *obfd) { + struct cleanup *cleanup; void *note_data = NULL; int note_size = 0; asection *note_sec = NULL; @@ -80,6 +82,8 @@ write_gcore_file (bfd *obfd) else note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, ¬e_size); + cleanup = make_cleanup (xfree, note_data); + if (note_data == NULL || note_size == 0) error (_("Target does not support core file generation.")); @@ -103,16 +107,34 @@ write_gcore_file (bfd *obfd) /* Write out the contents of the note section. */ if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size)) warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ())); + + do_cleanups (cleanup); } -static void -do_bfd_delete_cleanup (void *arg) +/* write_gcore_file -- helper for gcore_command (exported). + Compose and write the corefile data to the core file. */ + +void +write_gcore_file (bfd *obfd) { - bfd *obfd = arg; - const char *filename = obfd->filename; + struct gdb_exception except = exception_none; + + target_prepare_to_generate_core (); - gdb_bfd_unref (arg); - unlink (filename); + TRY + { + write_gcore_file_1 (obfd); + } + CATCH (e, RETURN_MASK_ALL) + { + except = e; + } + END_CATCH + + target_done_generating_core (); + + if (except.reason < 0) + throw_exception (except); } /* gcore_command -- implements the 'gcore' command. @@ -121,42 +143,38 @@ do_bfd_delete_cleanup (void *arg) static void gcore_command (char *args, int from_tty) { - struct cleanup *old_chain; - char *corefilename, corefilename_buffer[40]; - bfd *obfd; + gdb::unique_xmalloc_ptr corefilename; /* No use generating a corefile without a target process. */ if (!target_has_execution) noprocess (); if (args && *args) - corefilename = args; + corefilename.reset (tilde_expand (args)); else { /* Default corefile name is "core.PID". */ - xsnprintf (corefilename_buffer, sizeof (corefilename_buffer), - "core.%d", PIDGET (inferior_ptid)); - corefilename = corefilename_buffer; + corefilename.reset (xstrprintf ("core.%d", ptid_get_pid (inferior_ptid))); } if (info_verbose) fprintf_filtered (gdb_stdout, - "Opening corefile '%s' for output.\n", corefilename); + "Opening corefile '%s' for output.\n", + corefilename.get ()); /* Open the output file. */ - obfd = create_gcore_bfd (corefilename); + gdb_bfd_ref_ptr obfd (create_gcore_bfd (corefilename.get ())); - /* Need a cleanup that will close and delete the file. */ - old_chain = make_cleanup (do_bfd_delete_cleanup, obfd); + /* Arrange to unlink the file on failure. */ + gdb::unlinker unlink_file (corefilename.get ()); /* Call worker function. */ - write_gcore_file (obfd); + write_gcore_file (obfd.get ()); /* Succeeded. */ - fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename); + unlink_file.keep (); - discard_cleanups (old_chain); - gdb_bfd_unref (obfd); + fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename.get ()); } static unsigned long @@ -266,13 +284,13 @@ call_target_sbrk (int sbrk_arg) struct value *sbrk_fn, *ret; bfd_vma tmp; - if (lookup_minimal_symbol ("sbrk", NULL, NULL) != NULL) + if (lookup_minimal_symbol ("sbrk", NULL, NULL).minsym != NULL) { sbrk_fn = find_function_in_inferior ("sbrk", &sbrk_objf); if (sbrk_fn == NULL) return (bfd_vma) 0; } - else if (lookup_minimal_symbol ("_sbrk", NULL, NULL) != NULL) + else if (lookup_minimal_symbol ("_sbrk", NULL, NULL).minsym != NULL) { sbrk_fn = find_function_in_inferior ("_sbrk", &sbrk_objf); if (sbrk_fn == NULL) @@ -285,7 +303,7 @@ call_target_sbrk (int sbrk_arg) target_sbrk_arg = value_from_longest (builtin_type (gdbarch)->builtin_int, sbrk_arg); gdb_assert (target_sbrk_arg); - ret = call_function_by_hand (sbrk_fn, 1, &target_sbrk_arg); + ret = call_function_by_hand (sbrk_fn, NULL, 1, &target_sbrk_arg); if (ret == NULL) return (bfd_vma) 0; @@ -364,9 +382,9 @@ make_output_phdrs (bfd *obfd, asection *osec, void *ignored) int p_type = 0; /* FIXME: these constants may only be applicable for ELF. */ - if (strncmp (bfd_section_name (obfd, osec), "load", 4) == 0) + if (startswith (bfd_section_name (obfd, osec), "load")) p_type = PT_LOAD; - else if (strncmp (bfd_section_name (obfd, osec), "note", 4) == 0) + else if (startswith (bfd_section_name (obfd, osec), "note")) p_type = PT_NOTE; else p_type = PT_NULL; @@ -387,7 +405,7 @@ static int gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read, int write, int exec, int modified, void *data) { - bfd *obfd = data; + bfd *obfd = (bfd *) data; asection *osec; flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD; @@ -469,8 +487,9 @@ gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read, return 0; } -static int -objfile_find_memory_regions (find_memory_region_ftype func, void *obfd) +int +objfile_find_memory_regions (struct target_ops *self, + find_memory_region_ftype func, void *obfd) { /* Use objfile data to create memory sections. */ struct objfile *objfile; @@ -530,20 +549,17 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored) { bfd_size_type size, total_size = bfd_section_size (obfd, osec); file_ptr offset = 0; - struct cleanup *old_chain = NULL; - void *memhunk; /* Read-only sections are marked; we don't have to copy their contents. */ if ((bfd_get_section_flags (obfd, osec) & SEC_LOAD) == 0) return; /* Only interested in "load" sections. */ - if (strncmp ("load", bfd_section_name (obfd, osec), 4) != 0) + if (!startswith (bfd_section_name (obfd, osec), "load")) return; - size = min (total_size, MAX_COPY_BYTES); - memhunk = xmalloc (size); - old_chain = make_cleanup (xfree, memhunk); + size = std::min (total_size, (bfd_size_type) MAX_COPY_BYTES); + gdb::byte_vector memhunk (size); while (total_size > 0) { @@ -551,7 +567,7 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored) size = total_size; if (target_read_memory (bfd_section_vma (obfd, osec) + offset, - memhunk, size) != 0) + memhunk.data (), size) != 0) { warning (_("Memory read failed for corefile " "section, %s bytes at %s."), @@ -559,7 +575,8 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored) paddress (target_gdbarch (), bfd_section_vma (obfd, osec))); break; } - if (!bfd_set_section_contents (obfd, osec, memhunk, offset, size)) + if (!bfd_set_section_contents (obfd, osec, memhunk.data (), + offset, size)) { warning (_("Failed to write corefile contents (%s)."), bfd_errmsg (bfd_get_error ())); @@ -569,8 +586,6 @@ gcore_copy_callback (bfd *obfd, asection *osec, void *ignored) total_size -= size; offset += size; } - - do_cleanups (old_chain); /* Frees MEMHUNK. */ } static int @@ -605,5 +620,4 @@ Save a core file with the current state of the debugged process.\n\ Argument is optional filename. Default filename is 'core.'.")); add_com_alias ("gcore", "generate-core-file", class_files, 1); - exec_set_find_memory_regions (objfile_find_memory_regions); }