# When this file is updated in an existing source tree, it gets re-applied
# during the next build using "patch -N --fuzz=0", which ignores patches
# that have already been applied. However, if a gdb file has been modified
# multiple times, the subsequent patching may fail to recognize that a
# given patch has been previously applied, and will attempt to re-apply it.
# To prevent any uninintended consequences, this file also acts as a
# shell script that can restore any gdb file to its original state prior
# to all subsequent patch applications.
# The gdb-7.6-ppc64le-support.patch will have modified both files below
# during the initial build, so continue previous behavior.
if [ "$1" = "PPC64" ]
then
exit 0
fi
tar xvzmf gdb-7.6.tar.gz \
gdb-7.6/gdb/symtab.c \
gdb-7.6/gdb/printcmd.c
exit 0
--- gdb-7.6/libiberty/Makefile.in.orig
+++ gdb-7.6/libiberty/Makefile.in
@@ -175,6 +175,7 @@ REQUIRED_OFILES = \
./getruntime.$(objext) ./hashtab.$(objext) ./hex.$(objext) \
./lbasename.$(objext) ./lrealpath.$(objext) \
./make-relative-prefix.$(objext) ./make-temp-file.$(objext) \
+ ./mkstemps.$(objext) \
./objalloc.$(objext) \
./obstack.$(objext) \
./partition.$(objext) ./pexecute.$(objext) ./physmem.$(objext) \
@@ -206,7 +207,7 @@ CONFIGURED_OFILES = ./asprintf.$(objext)
./index.$(objext) ./insque.$(objext) \
./memchr.$(objext) ./memcmp.$(objext) ./memcpy.$(objext) \
./memmem.$(objext) ./memmove.$(objext) \
- ./mempcpy.$(objext) ./memset.$(objext) ./mkstemps.$(objext) \
+ ./mempcpy.$(objext) ./memset.$(objext) \
./pex-djgpp.$(objext) ./pex-msdos.$(objext) \
./pex-unix.$(objext) ./pex-win32.$(objext) \
./putenv.$(objext) \
--- gdb-7.6/opcodes/i386-dis.c.orig
+++ gdb-7.6/opcodes/i386-dis.c
@@ -11510,6 +11510,10 @@ print_insn (bfd_vma pc, disassemble_info
threebyte = *++codep;
dp = &dis386_twobyte[threebyte];
need_modrm = twobyte_has_modrm[*codep];
+ if (dp->name && ((strcmp(dp->name, "ud2a") == 0) || (strcmp(dp->name, "ud2") == 0))) {
+ extern int kernel_BUG_encoding_bytes(void);
+ codep += kernel_BUG_encoding_bytes();
+ }
codep++;
}
else
--- gdb-7.6/gdb/dwarf2read.c.orig
+++ gdb-7.6/gdb/dwarf2read.c
@@ -2670,7 +2670,11 @@ read_index_from_section (struct objfile
indices. */
if (version < 4)
{
+#ifdef CRASH_MERGE
+ static int warning_printed = 1;
+#else
static int warning_printed = 0;
+#endif
if (!warning_printed)
{
warning (_("Skipping obsolete .gdb_index section in %s."),
@@ -2689,7 +2693,11 @@ read_index_from_section (struct objfile
"set use-deprecated-index-sections on". */
if (version < 6 && !deprecated_ok)
{
+#ifdef CRASH_MERGE
+ static int warning_printed = 1;
+#else
static int warning_printed = 0;
+#endif
if (!warning_printed)
{
warning (_("\
--- gdb-7.6/gdb/amd64-linux-nat.c.orig
+++ gdb-7.6/gdb/amd64-linux-nat.c
@@ -45,6 +45,17 @@
/* ezannoni-2003-07-09: I think this is fixed. The extraneous defs have
been removed from ptrace.h in the kernel. However, better safe than
sorry. */
+#ifdef CRASH_MERGE
+/*
+ * When compiling within a 2.6.25-based Fedora build environment with
+ * gcc 4.3, four new "typedef unsigned int u32;" declarations were
+ * required due to a new ptrace_bts_config structure declaration in
+ * "asm-x86/ptrace-abi.h" that used u32 members, but u32 is defined in
+ * "asm-x86/types.h" within a __KERNEL__ section. They've been changed
+ * to __u32, but this patch remains for building in that environment.
+ */
+typedef unsigned int u32;
+#endif
#include <asm/ptrace.h>
#include <sys/reg.h>
#include "gdb_proc_service.h"
--- gdb-7.6/gdb/symfile.c.orig
+++ gdb-7.6/gdb/symfile.c
@@ -693,7 +693,26 @@ default_symfile_offsets (struct objfile
for (cur_sec = abfd->sections; cur_sec != NULL; cur_sec = cur_sec->next)
/* We do not expect this to happen; just skip this step if the
relocatable file has a section with an assigned VMA. */
- if (bfd_section_vma (abfd, cur_sec) != 0)
+ if (bfd_section_vma (abfd, cur_sec) != 0
+ /*
+ * Kernel modules may have some non-zero VMAs, i.e., like the
+ * __ksymtab and __ksymtab_gpl sections in this example:
+ *
+ * Section Headers:
+ * [Nr] Name Type Address Offset
+ * Size EntSize Flags Link Info Align
+ * ...
+ * [ 8] __ksymtab PROGBITS 0000000000000060 0000ad90
+ * 0000000000000010 0000000000000000 A 0 0 16
+ * [ 9] .rela__ksymtab RELA 0000000000000000 0000ada0
+ * 0000000000000030 0000000000000018 43 8 8
+ * [10] __ksymtab_gpl PROGBITS 0000000000000070 0000add0
+ * 00000000000001a0 0000000000000000 A 0 0 16
+ * ...
+ *
+ * but they should be treated as if they are NULL.
+ */
+ && strncmp (bfd_get_section_name (abfd, cur_sec), "__k", 3) != 0)
break;
if (cur_sec == NULL)
@@ -1122,6 +1141,12 @@ symbol_file_add_with_addrs_or_offsets (b
error (_("Not confirmed."));
objfile = allocate_objfile (abfd, flags | (mainline ? OBJF_MAINLINE : 0));
+#ifdef CRASH_MERGE
+ if (add_flags & SYMFILE_MAINLINE) {
+ extern struct objfile *gdb_kernel_objfile;
+ gdb_kernel_objfile = objfile;
+ }
+#endif
if (parent)
add_separate_debug_objfile (objfile, parent);
@@ -1484,6 +1509,9 @@ find_separate_debug_file (const char *di
VEC (char_ptr) *debugdir_vec;
struct cleanup *back_to;
int ix;
+#ifdef CRASH_MERGE
+ extern int check_specified_module_tree(char *, char *);
+#endif
/* Set I to max (strlen (canon_dir), strlen (dir)). */
i = strlen (dir);
@@ -1513,6 +1541,15 @@ find_separate_debug_file (const char *di
if (separate_debug_file_exists (debugfile, crc32, objfile))
return debugfile;
+#ifdef CRASH_MERGE
+{
+ if (check_specified_module_tree(objfile->name, debugfile) &&
+ separate_debug_file_exists(debugfile, crc32, objfile)) {
+ return debugfile;
+ }
+}
+#endif
+
/* Then try in the global debugfile directories.
Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
@@ -1583,6 +1620,10 @@ find_separate_debug_file_by_debuglink (s
char *debugfile;
unsigned long crc32;
struct cleanup *cleanups;
+#ifdef CRASH_MERGE
+ char *name_copy;
+ extern char *check_specified_kernel_debug_file();
+#endif
debuglink = get_debug_link_info (objfile, &crc32);
@@ -1635,6 +1676,12 @@ find_separate_debug_file_by_debuglink (s
}
do_cleanups (cleanups);
+#ifdef CRASH_MERGE
+ if (debugfile == NULL) {
+ name_copy = check_specified_kernel_debug_file();
+ return (name_copy ? xstrdup(name_copy) : NULL);
+ }
+#endif
return debugfile;
}
@@ -2409,8 +2456,10 @@ add_symbol_file_command (char *args, int
so we can't determine what section names are valid. */
}
+#ifndef CRASH_MERGE
if (from_tty && (!query ("%s", "")))
error (_("Not confirmed."));
+#endif
symbol_file_add (filename, from_tty ? SYMFILE_VERBOSE : 0,
section_addrs, flags);
@@ -3690,6 +3739,15 @@ bfd_byte *
symfile_relocate_debug_section (struct objfile *objfile,
asection *sectp, bfd_byte *buf)
{
+#ifdef CRASH_MERGE
+ /* Executable files have all the relocations already resolved.
+ * Handle files linked with --emit-relocs.
+ * http://sources.redhat.com/ml/gdb/2006-08/msg00137.html
+ */
+ bfd *abfd = objfile->obfd;
+ if ((abfd->flags & EXEC_P) != 0)
+ return NULL;
+#endif
gdb_assert (objfile->sf->sym_relocate);
return (*objfile->sf->sym_relocate) (objfile, sectp, buf);
--- gdb-7.6/gdb/cli/cli-cmds.c.orig
+++ gdb-7.6/gdb/cli/cli-cmds.c
@@ -466,6 +466,10 @@ show_script_ext_mode (struct ui_file *fi
If SEARCH_PATH is non-zero, and the file isn't found in cwd,
search for it in the source search path. */
+#ifdef CRASH_MERGE
+static int crash_from_tty = 0;
+#endif
+
int
find_and_open_script (const char *script_file, int search_path,
FILE **streamp, char **full_pathp)
@@ -508,6 +512,32 @@ find_and_open_script (const char *script
return 0;
}
+#ifdef CRASH_MERGE
+ /*
+ * Only allow trusted versions of .gdbinit files to be
+ * sourced during session initialization.
+ */
+ if (crash_from_tty == -1)
+ {
+ struct stat statbuf;
+ FILE *stream = *streamp;
+ int fd = fileno (stream);
+ if (fstat (fd, &statbuf) < 0)
+ {
+ perror_with_name (*full_pathp);
+ fclose (stream);
+ return 0;
+ }
+ if (statbuf.st_uid != getuid () || (statbuf.st_mode & S_IWOTH))
+ {
+ extern void untrusted_file(FILE *, char *);
+ untrusted_file(NULL, *full_pathp);
+ fclose (stream);
+ return 0;
+ }
+ }
+#endif
+
return 1;
}
@@ -566,7 +596,11 @@ source_script_with_search (const char *f
If the source command was invoked interactively, throw an
error. Otherwise (e.g. if it was invoked by a script),
silently ignore the error. */
+#ifdef CRASH_MERGE
+ if (from_tty > 0)
+#else
if (from_tty)
+#endif
perror_with_name (file);
else
return;
@@ -589,7 +623,14 @@ source_script_with_search (const char *f
void
source_script (char *file, int from_tty)
{
+#ifdef CRASH_MERGE
+ crash_from_tty = from_tty;
+#endif
source_script_with_search (file, from_tty, 0);
+#ifdef CRASH_MERGE
+ crash_from_tty = 0;
+#endif
+
}
/* Return the source_verbose global variable to its previous state
--- gdb-7.6/gdb/psymtab.c.orig
+++ gdb-7.6/gdb/psymtab.c
@@ -305,10 +305,14 @@ find_pc_sect_psymtab (struct objfile *ob
struct minimal_symbol *msymbol)
{
struct partial_symtab *pst;
+#ifdef CRASH_MERGE
+ extern int gdb_line_number_callback(unsigned long, unsigned long, unsigned long);
+#endif
/* Try just the PSYMTABS_ADDRMAP mapping first as it has better granularity
than the later used TEXTLOW/TEXTHIGH one. */
+#ifndef __i386__
if (objfile->psymtabs_addrmap != NULL)
{
pst = addrmap_find (objfile->psymtabs_addrmap, pc);
@@ -343,6 +347,7 @@ find_pc_sect_psymtab (struct objfile *ob
}
next:
+#endif
/* Existing PSYMTABS_ADDRMAP mapping is present even for PARTIAL_SYMTABs
which still have no corresponding full SYMTABs read. But it is not
@@ -361,7 +366,12 @@ find_pc_sect_psymtab (struct objfile *ob
best_pst = find_pc_sect_psymtab_closer (objfile, pc, section, pst,
msymbol);
+#ifdef CRASH_MERGE
+ if ((best_pst != NULL) &&
+ gdb_line_number_callback(pc, pst->textlow, pst->texthigh))
+#else
if (best_pst != NULL)
+#endif
return best_pst;
}
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -1198,7 +1198,9 @@ demangle_for_lookup (const char *name, e
doesn't affect these calls since they are looking for a known
variable and thus can probably assume it will never hit the C++
code). */
-
+#ifdef CRASH_MERGE
+static void gdb_bait_and_switch(char *, struct symbol *);
+#endif
struct symbol *
lookup_symbol_in_language (const char *name, const struct block *block,
const domain_enum domain, enum language lang,
@@ -1212,17 +1214,30 @@ lookup_symbol_in_language (const char *n
is_a_field_of_this);
do_cleanups (cleanup);
+#ifdef CRASH_MERGE
+ if (returnval && (domain == VAR_DOMAIN))
+ gdb_bait_and_switch((char *)modified_name, returnval);
+#endif
+
return returnval;
}
/* Behave like lookup_symbol_in_language, but performed with the
current language. */
+#ifdef CRASH_MERGE
+static struct block *gdb_get_crash_block(void);
+#endif
+
struct symbol *
lookup_symbol (const char *name, const struct block *block,
domain_enum domain,
struct field_of_this_result *is_a_field_of_this)
{
+#ifdef CRASH_MERGE
+ if (!block)
+ block = gdb_get_crash_block();
+#endif
return lookup_symbol_in_language (name, block, domain,
current_language->la_language,
is_a_field_of_this);
@@ -5100,3 +5115,662 @@ When enabled, debugging messages are pri
observer_attach_executable_changed (symtab_observer_executable_changed);
}
+
+#ifdef CRASH_MERGE
+#include "gdb-stabs.h"
+#include "version.h"
+#define GDB_COMMON
+#include "../../defs.h"
+
+static void get_member_data(struct gnu_request *, struct type *);
+static void dump_enum(struct type *, struct gnu_request *);
+static void eval_enum(struct type *, struct gnu_request *);
+static void gdb_get_line_number(struct gnu_request *);
+static void gdb_get_datatype(struct gnu_request *);
+static void gdb_get_symbol_type(struct gnu_request *);
+static void gdb_command_exists(struct gnu_request *);
+static void gdb_debug_command(struct gnu_request *);
+static void gdb_function_numargs(struct gnu_request *);
+static void gdb_add_symbol_file(struct gnu_request *);
+static void gdb_delete_symbol_file(struct gnu_request *);
+static void gdb_patch_symbol_values(struct gnu_request *);
+extern void replace_ui_file_FILE(struct ui_file *, FILE *);
+static void get_user_print_option_address(struct gnu_request *);
+extern int get_frame_offset(CORE_ADDR);
+static void gdb_set_crash_block(struct gnu_request *);
+void gdb_command_funnel(struct gnu_request *);
+
+struct objfile *gdb_kernel_objfile = { 0 };
+
+static ulong gdb_merge_flags = 0;
+#define KERNEL_SYMBOLS_PATCHED (0x1)
+
+#undef STREQ
+#define STREQ(A, B) (A && B && (strcmp(A, B) == 0))
+
+/*
+ * All commands from above come through here.
+ */
+void
+gdb_command_funnel(struct gnu_request *req)
+{
+ struct symbol *sym;
+
+ if (req->command != GNU_VERSION) {
+ replace_ui_file_FILE(gdb_stdout, req->fp);
+ replace_ui_file_FILE(gdb_stderr, req->fp);
+ do_cleanups(all_cleanups());
+ }
+
+ switch (req->command)
+ {
+ case GNU_VERSION:
+ req->buf = (char *)version;
+ break;
+
+ case GNU_PASS_THROUGH:
+ execute_command(req->buf,
+ req->flags & GNU_FROM_TTY_OFF ? FALSE : TRUE);
+ break;
+
+ case GNU_USER_PRINT_OPTION:
+ get_user_print_option_address(req);
+ break;
+
+ case GNU_RESOLVE_TEXT_ADDR:
+ sym = find_pc_function(req->addr);
+ if (!sym || TYPE_CODE(sym->type) != TYPE_CODE_FUNC)
+ req->flags |= GNU_COMMAND_FAILED;
+ break;
+
+ case GNU_DISASSEMBLE:
+ if (req->addr2)
+ sprintf(req->buf, "disassemble 0x%lx 0x%lx",
+ req->addr, req->addr2);
+ else
+ sprintf(req->buf, "disassemble 0x%lx", req->addr);
+ execute_command(req->buf, TRUE);
+ break;
+
+ case GNU_ADD_SYMBOL_FILE:
+ gdb_add_symbol_file(req);
+ break;
+
+ case GNU_DELETE_SYMBOL_FILE:
+ gdb_delete_symbol_file(req);
+ break;
+
+ case GNU_GET_LINE_NUMBER:
+ gdb_get_line_number(req);
+ break;
+
+ case GNU_GET_DATATYPE:
+ gdb_get_datatype(req);
+ break;
+
+ case GNU_GET_SYMBOL_TYPE:
+ gdb_get_symbol_type(req);
+ break;
+
+ case GNU_COMMAND_EXISTS:
+ gdb_command_exists(req);
+ break;
+
+ case GNU_ALPHA_FRAME_OFFSET:
+ req->value = 0;
+ break;
+
+ case GNU_FUNCTION_NUMARGS:
+ gdb_function_numargs(req);
+ break;
+
+ case GNU_DEBUG_COMMAND:
+ gdb_debug_command(req);
+ break;
+
+ case GNU_PATCH_SYMBOL_VALUES:
+ gdb_patch_symbol_values(req);
+ break;
+
+ case GNU_SET_CRASH_BLOCK:
+ gdb_set_crash_block(req);
+ break;
+
+ default:
+ req->flags |= GNU_COMMAND_FAILED;
+ break;
+ }
+}
+
+/*
+ * Given a PC value, return the file and line number.
+ */
+static void
+gdb_get_line_number(struct gnu_request *req)
+{
+ struct symtab_and_line sal;
+ struct symbol *sym;
+ CORE_ADDR pc;
+
+#define LASTCHAR(s) (s[strlen(s)-1])
+
+ /*
+ * Prime the addrmap pump.
+ */
+ if (req->name)
+ sym = lookup_symbol(req->name, 0, VAR_DOMAIN, 0);
+
+ pc = req->addr;
+
+ sal = find_pc_line(pc, 0);
+
+ if (!sal.symtab) {
+ req->buf[0] = '\0';
+ return;
+ }
+
+ if (sal.symtab->filename && sal.symtab->dirname) {
+ if (sal.symtab->filename[0] == '/')
+ sprintf(req->buf, "%s: %d",
+ sal.symtab->filename, sal.line);
+ else
+ sprintf(req->buf, "%s%s%s: %d",
+ sal.symtab->dirname,
+ LASTCHAR(sal.symtab->dirname) == '/' ? "" : "/",
+ sal.symtab->filename, sal.line);
+ }
+}
+
+
+/*
+ * General purpose routine for determining datatypes.
+ */
+
+static void
+gdb_get_datatype(struct gnu_request *req)
+{
+ register struct cleanup *old_chain = NULL;
+ register struct type *type;
+ register struct type *typedef_type;
+ struct expression *expr;
+ struct symbol *sym;
+ register int i;
+ struct field *nextfield;
+ struct value *val;
+
+ if (gdb_CRASHDEBUG(2))
+ console("gdb_get_datatype [%s] (a)\n", req->name);
+
+ req->typecode = TYPE_CODE_UNDEF;
+
+ /*
+ * lookup_symbol() will pick up struct and union names.
+ */
+ sym = lookup_symbol(req->name, 0, STRUCT_DOMAIN, 0);
+ if (sym) {
+ req->typecode = TYPE_CODE(sym->type);
+ req->length = TYPE_LENGTH(sym->type);
+ if (req->member)
+ get_member_data(req, sym->type);
+
+ if (TYPE_CODE(sym->type) == TYPE_CODE_ENUM) {
+ if (req->flags & GNU_PRINT_ENUMERATORS)
+ dump_enum(sym->type, req);
+ }
+
+ return;
+ }
+
+ /*
+ * Otherwise parse the expression.
+ */
+ if (gdb_CRASHDEBUG(2))
+ console("gdb_get_datatype [%s] (b)\n", req->name);
+
+ expr = parse_expression(req->name);
+
+ old_chain = make_cleanup(free_current_contents, &expr);
+
+
+ switch (expr->elts[0].opcode)
+ {
+ case OP_VAR_VALUE:
+ if (gdb_CRASHDEBUG(2))
+ console("expr->elts[0].opcode: OP_VAR_VALUE\n");
+ type = expr->elts[2].symbol->type;
+ if (req->flags & GNU_VAR_LENGTH_TYPECODE) {
+ req->typecode = TYPE_CODE(type);
+ req->length = TYPE_LENGTH(type);
+ }
+ if (TYPE_CODE(type) == TYPE_CODE_ENUM) {
+ req->typecode = TYPE_CODE(type);
+ req->value = SYMBOL_VALUE(expr->elts[2].symbol);
+ req->tagname = (char *)TYPE_TAG_NAME(type);
+ if (!req->tagname) {
+ val = evaluate_type(expr);
+ eval_enum(value_type(val), req);
+ }
+ }
+ break;
+
+ case OP_TYPE:
+ if (gdb_CRASHDEBUG(2))
+ console("expr->elts[0].opcode: OP_TYPE\n");
+ type = expr->elts[1].type;
+
+ req->typecode = TYPE_CODE(type);
+ req->length = TYPE_LENGTH(type);
+
+ if (TYPE_CODE(type) == TYPE_CODE_TYPEDEF) {
+ req->is_typedef = TYPE_CODE_TYPEDEF;
+ if ((typedef_type = check_typedef(type))) {
+ req->typecode = TYPE_CODE(typedef_type);
+ req->length = TYPE_LENGTH(typedef_type);
+ type = typedef_type;
+ }
+ }
+
+ if (TYPE_CODE(type) == TYPE_CODE_ENUM) {
+ if (req->is_typedef)
+ if (req->flags & GNU_PRINT_ENUMERATORS) {
+ if (req->is_typedef)
+ fprintf_filtered(gdb_stdout,
+ "typedef ");
+ dump_enum(type, req);
+ }
+ }
+
+ if (req->member)
+ get_member_data(req, type);
+
+ break;
+
+ default:
+ if (gdb_CRASHDEBUG(2))
+ console("expr->elts[0].opcode: %d (?)\n",
+ expr->elts[0].opcode);
+ break;
+
+ }
+
+ do_cleanups(old_chain);
+}
+
+/*
+ * More robust enum list dump that gdb's, showing the value of each
+ * identifier, each on its own line.
+ */
+static void
+dump_enum(struct type *type, struct gnu_request *req)
+{
+ register int i;
+ int len;
+ int lastval;
+
+ len = TYPE_NFIELDS (type);
+ lastval = 0;
+ if (TYPE_TAG_NAME(type))
+ fprintf_filtered(gdb_stdout,
+ "enum %s {\n", TYPE_TAG_NAME (type));
+ else
+ fprintf_filtered(gdb_stdout, "enum {\n");
+
+ for (i = 0; i < len; i++) {
+ fprintf_filtered(gdb_stdout, " %s",
+ TYPE_FIELD_NAME (type, i));
+ if (lastval != TYPE_FIELD_BITPOS (type, i)) {
+ fprintf_filtered (gdb_stdout, " = %d",
+ TYPE_FIELD_BITPOS (type, i));
+ lastval = TYPE_FIELD_BITPOS (type, i);
+ } else
+ fprintf_filtered(gdb_stdout, " = %d", lastval);
+ fprintf_filtered(gdb_stdout, "\n");
+ lastval++;
+ }
+ if (TYPE_TAG_NAME(type))
+ fprintf_filtered(gdb_stdout, "};\n");
+ else
+ fprintf_filtered(gdb_stdout, "} %s;\n", req->name);
+}
+
+/*
+ * Given an enum type with no tagname, determine its value.
+ */
+static void
+eval_enum(struct type *type, struct gnu_request *req)
+{
+ register int i;
+ int len;
+ int lastval;
+
+ len = TYPE_NFIELDS (type);
+ lastval = 0;
+
+ for (i = 0; i < len; i++) {
+ if (lastval != TYPE_FIELD_BITPOS (type, i)) {
+ lastval = TYPE_FIELD_BITPOS (type, i);
+ }
+ if (STREQ(TYPE_FIELD_NAME(type, i), req->name)) {
+ req->tagname = "(unknown)";
+ req->value = lastval;
+ return;
+ }
+ lastval++;
+ }
+}
+
+/*
+ * Walk through a struct type's list of fields looking for the desired
+ * member field, and when found, return its relevant data.
+ */
+static void
+get_member_data(struct gnu_request *req, struct type *type)
+{
+ register short i;
+ struct field *nextfield;
+ short nfields;
+ struct type *typedef_type;
+
+ req->member_offset = -1;
+
+ nfields = TYPE_MAIN_TYPE(type)->nfields;
+ nextfield = TYPE_MAIN_TYPE(type)->flds_bnds.fields;
+
+ if (nfields == 0) {
+ struct type *newtype;
+ newtype = lookup_transparent_type(req->name);
+ if (newtype) {
+ console("get_member_data(%s.%s): switching type from %lx to %lx\n",
+ req->name, req->member, type, newtype);
+ nfields = TYPE_MAIN_TYPE(newtype)->nfields;
+ nextfield = TYPE_MAIN_TYPE(newtype)->flds_bnds.fields;
+ }
+ }
+
+ for (i = 0; i < nfields; i++) {
+ if (STREQ(req->member, nextfield->name)) {
+ req->member_offset = nextfield->loc.bitpos;
+ req->member_length = TYPE_LENGTH(nextfield->type);
+ req->member_typecode = TYPE_CODE(nextfield->type);
+ if ((req->member_typecode == TYPE_CODE_TYPEDEF) &&
+ (typedef_type = check_typedef(nextfield->type)))
+ req->member_length = TYPE_LENGTH(typedef_type);
+ return;
+ }
+ nextfield++;
+ }
+}
+
+/*
+ * Check whether a command exists. If it doesn't, the command will be
+ * returned indirectly via the error_hook.
+ */
+static void
+gdb_command_exists(struct gnu_request *req)
+{
+ extern struct cmd_list_element *cmdlist;
+ register struct cmd_list_element *c;
+
+ req->value = FALSE;
+ c = lookup_cmd(&req->name, cmdlist, "", 0, 1);
+ req->value = TRUE;
+}
+
+static void
+gdb_function_numargs(struct gnu_request *req)
+{
+ struct symbol *sym;
+
+ sym = find_pc_function(req->pc);
+
+ if (!sym || TYPE_CODE(sym->type) != TYPE_CODE_FUNC) {
+ req->flags |= GNU_COMMAND_FAILED;
+ return;
+ }
+
+ req->value = (ulong)TYPE_NFIELDS(sym->type);
+}
+
+struct load_module *gdb_current_load_module = NULL;
+
+static void
+gdb_add_symbol_file(struct gnu_request *req)
+{
+ register struct objfile *loaded_objfile = NULL;
+ register struct objfile *objfile;
+ register struct minimal_symbol *m;
+ struct load_module *lm;
+ int external, subsequent, found;
+ off_t offset;
+ ulong value, adjusted;
+ struct symbol *sym;
+ struct expression *expr;
+ struct cleanup *old_chain;
+ int i;
+ int allsect = 0;
+ char *secname;
+ char buf[80];
+
+ gdb_current_load_module = lm = (struct load_module *)req->addr;
+
+ req->name = lm->mod_namelist;
+ gdb_delete_symbol_file(req);
+
+ if ((lm->mod_flags & MOD_NOPATCH) == 0) {
+ for (i = 0 ; i < lm->mod_sections; i++) {
+ if (STREQ(lm->mod_section_data[i].name, ".text") &&
+ (lm->mod_section_data[i].flags & SEC_FOUND))
+ allsect = 1;
+ }
+
+ if (!allsect) {
+ sprintf(req->buf, "add-symbol-file %s 0x%lx %s", lm->mod_namelist,
+ lm->mod_text_start ? lm->mod_text_start : lm->mod_base,
+ lm->mod_flags & MOD_DO_READNOW ? "-readnow" : "");
+ if (lm->mod_data_start) {
+ sprintf(buf, " -s .data 0x%lx", lm->mod_data_start);
+ strcat(req->buf, buf);
+ }
+ if (lm->mod_bss_start) {
+ sprintf(buf, " -s .bss 0x%lx", lm->mod_bss_start);
+ strcat(req->buf, buf);
+ }
+ if (lm->mod_rodata_start) {
+ sprintf(buf, " -s .rodata 0x%lx", lm->mod_rodata_start);
+ strcat(req->buf, buf);
+ }
+ } else {
+ sprintf(req->buf, "add-symbol-file %s 0x%lx %s", lm->mod_namelist,
+ lm->mod_text_start, lm->mod_flags & MOD_DO_READNOW ?
+ "-readnow" : "");
+ for (i = 0; i < lm->mod_sections; i++) {
+ secname = lm->mod_section_data[i].name;
+ if ((lm->mod_section_data[i].flags & SEC_FOUND) &&
+ !STREQ(secname, ".text")) {
+ sprintf(buf, " -s %s 0x%lx", secname,
+ lm->mod_section_data[i].offset + lm->mod_base);
+ strcat(req->buf, buf);
+ }
+ }
+ }
+ }
+
+ if (gdb_CRASHDEBUG(1))
+ fprintf_filtered(gdb_stdout, "%s\n", req->buf);
+
+ execute_command(req->buf, FALSE);
+
+ ALL_OBJFILES(objfile) {
+ if (same_file(objfile->name, lm->mod_namelist)) {
+ loaded_objfile = objfile;
+ break;
+ }
+ }
+
+ if (!loaded_objfile)
+ req->flags |= GNU_COMMAND_FAILED;
+}
+
+static void
+gdb_delete_symbol_file(struct gnu_request *req)
+{
+ register struct objfile *objfile;
+
+ ALL_OBJFILES(objfile) {
+ if (STREQ(objfile->name, req->name) ||
+ same_file(objfile->name, req->name)) {
+ free_objfile(objfile);
+ break;
+ }
+ }
+
+ if (gdb_CRASHDEBUG(2)) {
+ fprintf_filtered(gdb_stdout, "current object files:\n");
+ ALL_OBJFILES(objfile)
+ fprintf_filtered(gdb_stdout, " %s\n", objfile->name);
+ }
+}
+
+/*
+ * Walk through all minimal_symbols, patching their values with the
+ * correct addresses.
+ */
+static void
+gdb_patch_symbol_values(struct gnu_request *req)
+{
+ struct minimal_symbol *msymbol;
+ struct objfile *objfile;
+
+ req->name = PATCH_KERNEL_SYMBOLS_START;
+ patch_kernel_symbol(req);
+
+ ALL_MSYMBOLS (objfile, msymbol)
+ {
+ req->name = (char *)msymbol->ginfo.name;
+ req->addr = (ulong)(&SYMBOL_VALUE_ADDRESS(msymbol));
+ if (!patch_kernel_symbol(req)) {
+ req->flags |= GNU_COMMAND_FAILED;
+ break;
+ }
+ }
+
+ req->name = PATCH_KERNEL_SYMBOLS_STOP;
+ patch_kernel_symbol(req);
+
+ clear_symtab_users(0);
+ gdb_merge_flags |= KERNEL_SYMBOLS_PATCHED;
+}
+
+static void
+gdb_get_symbol_type(struct gnu_request *req)
+{
+ struct expression *expr;
+ struct value *val;
+ struct cleanup *old_chain = NULL;
+ struct type *type;
+ struct type *target_type;
+
+ req->typecode = TYPE_CODE_UNDEF;
+
+ expr = parse_expression (req->name);
+ old_chain = make_cleanup (free_current_contents, &expr);
+ val = evaluate_type (expr);
+
+ type = value_type(val);
+
+ req->type_name = (char *)TYPE_MAIN_TYPE(type)->name;
+ req->typecode = TYPE_MAIN_TYPE(type)->code;
+ req->length = type->length;
+ target_type = TYPE_MAIN_TYPE(type)->target_type;
+
+ if (target_type) {
+ req->target_typename = (char *)TYPE_MAIN_TYPE(target_type)->name;
+ req->target_typecode = TYPE_MAIN_TYPE(target_type)->code;
+ req->target_length = target_type->length;
+ }
+
+ if (req->member)
+ get_member_data(req, type);
+
+ do_cleanups (old_chain);
+}
+
+static void
+gdb_debug_command(struct gnu_request *req)
+{
+
+}
+
+/*
+ * Only necessary on "patched" kernel symbol sessions, and called only by
+ * lookup_symbol(), pull a symbol value bait-and-switch operation by altering
+ * either a data symbol's address value or a text symbol's block start address.
+ */
+static void
+gdb_bait_and_switch(char *name, struct symbol *sym)
+{
+ struct minimal_symbol *msym;
+ struct block *block;
+
+ if ((gdb_merge_flags & KERNEL_SYMBOLS_PATCHED) &&
+ (msym = lookup_minimal_symbol(name, NULL, gdb_kernel_objfile))) {
+ if (sym->aclass == LOC_BLOCK) {
+ block = (struct block *)SYMBOL_BLOCK_VALUE(sym);
+ BLOCK_START(block) = SYMBOL_VALUE_ADDRESS(msym);
+ } else
+ SYMBOL_VALUE_ADDRESS(sym) = SYMBOL_VALUE_ADDRESS(msym);
+ }
+}
+
+#include "valprint.h"
+
+void
+get_user_print_option_address(struct gnu_request *req)
+{
+ extern struct value_print_options user_print_options;
+
+ req->addr = 0;
+
+ if (strcmp(req->name, "output_format") == 0)
+ req->addr = (ulong)&user_print_options.output_format;
+ if (strcmp(req->name, "print_max") == 0)
+ req->addr = (ulong)&user_print_options.print_max;
+ if (strcmp(req->name, "prettyprint_structs") == 0)
+ req->addr = (ulong)&user_print_options.prettyprint_structs;
+ if (strcmp(req->name, "prettyprint_arrays") == 0)
+ req->addr = (ulong)&user_print_options.prettyprint_arrays;
+ if (strcmp(req->name, "repeat_count_threshold") == 0)
+ req->addr = (ulong)&user_print_options.repeat_count_threshold;
+ if (strcmp(req->name, "stop_print_at_null") == 0)
+ req->addr = (ulong)&user_print_options.stop_print_at_null;
+ if (strcmp(req->name, "output_radix") == 0)
+ req->addr = (ulong)&output_radix;
+}
+
+CORE_ADDR crash_text_scope;
+
+static void
+gdb_set_crash_block(struct gnu_request *req)
+{
+ if (!req->addr) { /* debug */
+ crash_text_scope = 0;
+ return;
+ }
+
+ if ((req->addr2 = (ulong)block_for_pc(req->addr)))
+ crash_text_scope = req->addr;
+ else {
+ crash_text_scope = 0;
+ req->flags |= GNU_COMMAND_FAILED;
+ }
+}
+
+static struct block *
+gdb_get_crash_block(void)
+{
+ if (crash_text_scope)
+ return block_for_pc(crash_text_scope);
+ else
+ return NULL;
+}
+#endif
--- gdb-7.6/gdb/c-typeprint.c.orig
+++ gdb-7.6/gdb/c-typeprint.c
@@ -1097,7 +1097,8 @@ c_type_print_base (struct type *type, st
fprintf_filtered (stream, "static ");
c_print_type (TYPE_FIELD_TYPE (type, i),
TYPE_FIELD_NAME (type, i),
- stream, show - 1, level + 4,
+ stream, strlen(TYPE_FIELD_NAME (type, i)) ?
+ show - 1 : show, level + 4,
&local_flags);
if (!field_is_static (&TYPE_FIELD (type, i))
&& TYPE_FIELD_PACKED (type, i))
--- gdb-7.6/gdb/xml-syscall.c.orig
+++ gdb-7.6/gdb/xml-syscall.c
@@ -38,7 +38,11 @@
static void
syscall_warn_user (void)
{
+#ifdef CRASH_MERGE
+ static int have_warned = 1;
+#else
static int have_warned = 0;
+#endif
if (!have_warned)
{
have_warned = 1;
--- gdb-7.6/gdb/exceptions.c.orig
+++ gdb-7.6/gdb/exceptions.c
@@ -218,6 +218,10 @@ exceptions_state_mc_action_iter_1 (void)
/* Return EXCEPTION to the nearest containing catch_errors(). */
+#ifdef CRASH_MERGE
+void (*error_hook) (void) ATTRIBUTE_NORETURN;
+#endif
+
void
throw_exception (struct gdb_exception exception)
{
@@ -225,6 +229,13 @@ throw_exception (struct gdb_exception ex
immediate_quit = 0;
do_cleanups (all_cleanups ());
+#ifdef CRASH_MERGE
+ if (error_hook) {
+ fprintf_filtered(gdb_stderr, "%s\n", exception.message);
+ (*error_hook)();
+ } else
+ fprintf_filtered(gdb_stderr, "gdb called without error_hook: %s\n", exception.message);
+#endif
/* Jump to the containing catch_errors() call, communicating REASON
to that call via setjmp's return value. Note that REASON can't
--- gdb-7.6/gdb/valprint.h.orig
+++ gdb-7.6/gdb/valprint.h
@@ -152,11 +152,17 @@ extern void print_function_pointer_addre
struct gdbarch *gdbarch,
CORE_ADDR address,
struct ui_file *stream);
-
+#ifdef CRASH_MERGE
+extern int valprint_read_string (CORE_ADDR addr, int len, int width,
+ unsigned int fetchlimit,
+ enum bfd_endian byte_order, gdb_byte **buffer,
+ int *bytes_read);
+#else
extern int read_string (CORE_ADDR addr, int len, int width,
unsigned int fetchlimit,
enum bfd_endian byte_order, gdb_byte **buffer,
int *bytes_read);
+#endif
extern void val_print_optimized_out (struct ui_file *stream);
--- gdb-7.6/gdb/target.c.orig
+++ gdb-7.6/gdb/target.c
@@ -1779,6 +1779,13 @@ target_xfer_partial (struct target_ops *
int
target_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
{
+#ifdef CRASH_MERGE
+ extern int gdb_readmem_callback(unsigned long, void *, int, int);
+ if (gdb_readmem_callback(memaddr, (void *)myaddr, len, 0))
+ return 0;
+ else
+ return EIO;
+#endif
/* Dispatch to the topmost target, not the flattened current_target.
Memory accesses check target->to_has_(all_)memory, and the
flattened target doesn't inherit those. */
@@ -1814,6 +1821,13 @@ target_read_stack (CORE_ADDR memaddr, gd
int
target_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
{
+#ifdef CRASH_MERGE
+ extern int gdb_readmem_callback(unsigned long, void *, int, int);
+ if (gdb_readmem_callback(memaddr, (void *)myaddr, len, 1))
+ return 0;
+ else
+ return EIO;
+#endif
/* Dispatch to the topmost target, not the flattened current_target.
Memory accesses check target->to_has_(all_)memory, and the
flattened target doesn't inherit those. */
--- gdb-7.6/gdb/printcmd.c.orig
+++ gdb-7.6/gdb/printcmd.c
@@ -1001,11 +1001,62 @@ print_command_1 (char *exp, int voidprin
}
static void
+print_command_2 (char *exp, int inspect, int voidprint)
+{
+ struct expression *expr;
+ struct cleanup *old_chain = 0;
+ char format = 0;
+ struct value *val;
+ struct format_data fmt;
+ int cleanup = 0;
+
+ if (exp && *exp == '/')
+ {
+ exp++;
+ fmt = decode_format (&exp, last_format, 0);
+ validate_format (fmt, "print");
+ last_format = format = fmt.format;
+ }
+ else
+ {
+ fmt.count = 1;
+ fmt.format = 0;
+ fmt.size = 0;
+ fmt.raw = 0;
+ }
+
+ if (exp && *exp)
+ {
+ expr = parse_expression (exp);
+ old_chain = make_cleanup (free_current_contents, &expr);
+ cleanup = 1;
+ val = evaluate_expression (expr);
+ }
+ else
+ val = access_value_history (0);
+
+ printf_filtered ("%d %d %d %d %d %d\n",
+ TYPE_CODE (check_typedef(value_type (val))),
+ TYPE_UNSIGNED (check_typedef(value_type (val))),
+ TYPE_LENGTH (check_typedef(value_type(val))),
+ value_offset (val), value_bitpos (val), value_bitsize(val));
+
+ if (cleanup)
+ do_cleanups (old_chain);
+}
+
+static void
print_command (char *exp, int from_tty)
{
print_command_1 (exp, 1);
}
+static void
+printm_command (char *exp, int from_tty)
+{
+ print_command_2 (exp, 0, 1);
+}
+
/* Same as print, except it doesn't print void results. */
static void
call_command (char *exp, int from_tty)
@@ -2593,6 +2644,12 @@ EXP may be preceded with /FMT, where FMT
but no count or size letter (see \"x\" command)."));
set_cmd_completer (c, expression_completer);
add_com_alias ("p", "print", class_vars, 1);
+
+ c = add_com ("printm", class_vars, printm_command, _("\
+Similar to \"print\" command, but it used to print the type, size, offset,\n\
+bitpos and bitsize of the expression EXP."));
+ set_cmd_completer (c, expression_completer);
+
add_com_alias ("inspect", "print", class_vars, 1);
add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
--- gdb-7.6/gdb/ui-file.c.orig
+++ gdb-7.6/gdb/ui-file.c
@@ -671,6 +671,17 @@ gdb_fopen (char *name, char *mode)
return stdio_file_new (f, 1);
}
+#ifdef CRASH_MERGE
+void
+replace_ui_file_FILE(struct ui_file *file, FILE *fp)
+{
+ struct stdio_file *stdio_file;
+
+ stdio_file = (struct stdio_file *)ui_file_data(file);
+ stdio_file->file = fp;
+}
+#endif
+
/* ``struct ui_file'' implementation that maps onto two ui-file objects. */
static ui_file_write_ftype tee_file_write;
--- gdb-7.6/gdb/main.c.orig
+++ gdb-7.6/gdb/main.c
@@ -806,7 +806,7 @@ captured_main (void *data)
{
print_gdb_version (gdb_stdout);
wrap_here ("");
- printf_filtered ("\n");
+ printf_filtered ("\n\n");
exit (0);
}
@@ -853,6 +853,13 @@ captured_main (void *data)
}
}
+#ifdef CRASH_MERGE
+{
+ extern void update_gdb_hooks(void);
+ update_gdb_hooks();
+}
+#endif
+
/* FIXME: cagney/2003-02-03: The big hack (part 2 of 2) that lets
GDB retain the old MI1 interpreter startup behavior. Output the
copyright message after the interpreter is installed when it is
@@ -880,7 +887,11 @@ captured_main (void *data)
processed; it sets global parameters, which are independent of
what file you are debugging or what directory you are in. */
if (system_gdbinit && !inhibit_gdbinit)
+#ifdef CRASH_MERGE
+ catch_command_errors (source_script, system_gdbinit, -1, RETURN_MASK_ALL);
+#else
catch_command_errors (source_script, system_gdbinit, 0, RETURN_MASK_ALL);
+#endif
/* Read and execute $HOME/.gdbinit file, if it exists. This is done
*before* all the command line arguments are processed; it sets
@@ -888,7 +899,11 @@ captured_main (void *data)
debugging or what directory you are in. */
if (home_gdbinit && !inhibit_gdbinit && !inhibit_home_gdbinit)
+#ifdef CRASH_MERGE
+ catch_command_errors (source_script, home_gdbinit, -1, RETURN_MASK_ALL);
+#else
catch_command_errors (source_script, home_gdbinit, 0, RETURN_MASK_ALL);
+#endif
/* Process '-ix' and '-iex' options early. */
for (i = 0; VEC_iterate (cmdarg_s, cmdarg_vec, i, cmdarg_p); i++)
@@ -929,8 +944,12 @@ captured_main (void *data)
catch_command_errors returns non-zero on success! */
if (catch_command_errors (exec_file_attach, execarg,
!batch_flag, RETURN_MASK_ALL))
+#ifdef CRASH_MERGE
+ catch_command_errors (symbol_file_add_main, symarg, 0, RETURN_MASK_ALL);
+#else
catch_command_errors (symbol_file_add_main, symarg,
!batch_flag, RETURN_MASK_ALL);
+#endif
}
else
{
@@ -992,8 +1011,12 @@ captured_main (void *data)
{
auto_load_local_gdbinit_loaded = 1;
+#ifdef CRASH_MERGE
+ catch_command_errors (source_script, local_gdbinit, -1, RETURN_MASK_ALL);
+#else
catch_command_errors (source_script, local_gdbinit, 0,
RETURN_MASK_ALL);
+#endif
}
}
@@ -1039,6 +1062,12 @@ captured_main (void *data)
while (1)
{
catch_errors (captured_command_loop, 0, "", RETURN_MASK_ALL);
+#ifdef CRASH_MERGE
+ {
+ int console(char *, ...);
+ console("<CAPTURED_MAIN WHILE LOOP>\n");
+ }
+#endif
}
/* No exit -- exit is through quit_command. */
}
@@ -1053,6 +1082,23 @@ gdb_main (struct captured_main_args *arg
return 1;
}
+#ifdef CRASH_MERGE
+/*
+ * NOTE: adapted from gdb.c, which is no longer built in; changed name of
+ * original main() to gdb_main_entry() for use as crash entry point
+ */
+int
+gdb_main_entry (int argc, char **argv)
+{
+ struct captured_main_args args;
+ memset (&args, 0, sizeof args);
+ args.argc = argc;
+ args.argv = argv;
+ args.use_windows = 0;
+ args.interpreter_p = INTERP_CONSOLE;
+ return gdb_main (&args);
+}
+#endif
/* Don't use *_filtered for printing help. We don't want to prompt
for continue no matter how small the screen or how much we're going
--- gdb-7.6/gdb/valprint.c.orig
+++ gdb-7.6/gdb/valprint.c
@@ -1768,8 +1768,13 @@ partial_memory_read (CORE_ADDR memaddr,
this function instead? */
int
+#ifdef CRASH_MERGE
+valprint_read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
+ enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
+#else
read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
+#endif
{
int found_nul; /* Non-zero if we found the nul char. */
int errcode; /* Errno returned from bad reads. */
@@ -2472,8 +2477,13 @@ val_print_string (struct type *elttype,
fetchlimit = (len == -1 ? options->print_max : min (len,
options->print_max));
+#ifdef CRASH_MERGE
+ errcode = valprint_read_string (addr, len, width, fetchlimit, byte_order,
+ &buffer, &bytes_read);
+#else
errcode = read_string (addr, len, width, fetchlimit, byte_order,
&buffer, &bytes_read);
+#endif
old_chain = make_cleanup (xfree, buffer);
addr += bytes_read;
--- gdb-7.6/gdb/Makefile.in.orig
+++ gdb-7.6/gdb/Makefile.in
@@ -422,7 +422,7 @@ CONFIG_UNINSTALL = @CONFIG_UNINSTALL@
# It is also possible that you will need to add -I/usr/include/sys if
# your system doesn't have fcntl.h in /usr/include (which is where it
# should be according to Posix).
-DEFS = @DEFS@
+DEFS = -DCRASH_MERGE @DEFS@
GDB_CFLAGS = -I. -I$(srcdir) -I$(srcdir)/common -I$(srcdir)/config \
-DLOCALEDIR="\"$(localedir)\"" $(DEFS)
@@ -934,7 +934,7 @@ COMMON_OBS = $(DEPFILES) $(CONFIG_OBS) $
TSOBS = inflow.o
-SUBDIRS = doc @subdirs@ data-directory $(GNULIB_BUILDDIR)
+SUBDIRS = build_no_subdirs
CLEANDIRS = $(SUBDIRS)
# List of subdirectories in the build tree that must exist.
@@ -969,8 +969,8 @@ generated_files = config.h observer.h ob
$(COMPILE) $<
$(POSTCOMPILE)
-all: gdb$(EXEEXT) $(CONFIG_ALL)
- @$(MAKE) $(FLAGS_TO_PASS) DO=all "DODIRS=`echo $(SUBDIRS) | sed 's/testsuite//'`" subdir_do
+all: gdb$(EXEEXT)
+ @$(MAKE) -s $(FLAGS_TO_PASS) DO=all "DODIRS=`echo $(SUBDIRS) | sed 's/testsuite//'`" subdir_do
installcheck:
@@ -1172,15 +1172,16 @@ libgdb.a: $(LIBGDB_OBS)
# Removing the old gdb first works better if it is running, at least on SunOS.
gdb$(EXEEXT): gdb.o $(LIBGDB_OBS) $(ADD_DEPS) $(CDEPS) $(TDEPLIBS)
- rm -f gdb$(EXEEXT)
+ @rm -f gdb$(EXEEXT)
+ @(cd ../..; make --no-print-directory GDB_FLAGS=-DGDB_7_6 library)
$(CC_LD) $(INTERNAL_LDFLAGS) $(WIN32LDAPP) \
- -o gdb$(EXEEXT) gdb.o $(LIBGDB_OBS) \
- $(TDEPLIBS) $(TUI_LIBRARY) $(CLIBS) $(LOADLIBES)
+ -o $(shell /bin/cat mergeobj) $(LIBGDB_OBS) \
+ $(TDEPLIBS) $(TUI_LIBRARY) $(CLIBS) $(LOADLIBES) $(shell /bin/cat mergelibs)
# Convenience rule to handle recursion.
$(LIBGNU) $(GNULIB_H): all-lib
all-lib: $(GNULIB_BUILDDIR)/Makefile
- @$(MAKE) $(FLAGS_TO_PASS) DO=all DODIRS=$(GNULIB_BUILDDIR) subdir_do
+ @$(MAKE) $(FLAGS_TO_PASS) DO=all DODIRS=$(GNULIB_BUILDDIR) subdir_do -s
.PHONY: all-lib
# Convenience rule to handle recursion.
@@ -1389,12 +1390,12 @@ $(srcdir)/copying.c: @MAINTAINER_MODE_TR
mv $(srcdir)/copying.tmp $(srcdir)/copying.c
version.c: Makefile version.in
- rm -f version.c-tmp version.c
- echo '#include "version.h"' >> version.c-tmp
- echo 'const char version[] = "'"`sed q ${srcdir}/version.in`"'";' >> version.c-tmp
- echo 'const char host_name[] = "$(host_alias)";' >> version.c-tmp
- echo 'const char target_name[] = "$(target_alias)";' >> version.c-tmp
- mv version.c-tmp version.c
+ @rm -f version.c-tmp version.c
+ @echo '#include "version.h"' >> version.c-tmp
+ @echo 'const char version[] = "'"`sed q ${srcdir}/version.in`"'";' >> version.c-tmp
+ @echo 'const char host_name[] = "$(host_alias)";' >> version.c-tmp
+ @echo 'const char target_name[] = "$(target_alias)";' >> version.c-tmp
+ @mv version.c-tmp version.c
observer.h: observer.sh doc/observer.texi
${srcdir}/observer.sh h ${srcdir}/doc/observer.texi observer.h
--- gdb-7.6/gdb/c-lang.c.orig
+++ gdb-7.6/gdb/c-lang.c
@@ -307,7 +307,11 @@ c_get_string (struct value *value, gdb_b
{
CORE_ADDR addr = value_as_address (value);
+#ifdef CRASH_MERGE
+ err = valprint_read_string (addr, *length, width, fetchlimit,
+#else
err = read_string (addr, *length, width, fetchlimit,
+#endif
byte_order, buffer, length);
if (err)
{
--- gdb-7.6/readline/rltypedefs.h.orig
+++ gdb-7.6/readline/rltypedefs.h
@@ -31,10 +31,10 @@ extern "C" {
#if !defined (_FUNCTION_DEF)
# define _FUNCTION_DEF
-typedef int Function ();
-typedef void VFunction ();
-typedef char *CPFunction ();
-typedef char **CPPFunction ();
+typedef int Function (void);
+typedef void VFunction (void);
+typedef char *CPFunction (void);
+typedef char **CPPFunction (void);
#endif /* _FUNCTION_DEF */
--- gdb-7.6/readline/readline.h.orig
+++ gdb-7.6/readline/readline.h
@@ -378,7 +378,7 @@ extern int rl_crlf PARAMS((void));
#if defined (USE_VARARGS) && defined (PREFER_STDARG)
extern int rl_message (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
#else
-extern int rl_message ();
+extern int rl_message (void);
#endif
extern int rl_show_char PARAMS((int));
--- gdb-7.6/readline/misc.c.orig
+++ gdb-7.6/readline/misc.c
@@ -405,7 +405,7 @@ _rl_history_set_point ()
#if defined (VI_MODE)
if (rl_editing_mode == vi_mode && _rl_keymap != vi_insertion_keymap)
- rl_point = 0;
+ rl_point = rl_end;
#endif /* VI_MODE */
if (rl_editing_mode == emacs_mode)
--- gdb-7.6/Makefile.in.orig
+++ gdb-7.6/Makefile.in
@@ -342,6 +342,9 @@ AR_FOR_BUILD = @AR_FOR_BUILD@
AS_FOR_BUILD = @AS_FOR_BUILD@
CC_FOR_BUILD = @CC_FOR_BUILD@
CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
+ifeq (${CRASH_TARGET}, PPC64)
+CFLAGS_FOR_BUILD += -m64 -fPIC
+endif
CXXFLAGS_FOR_BUILD = @CXXFLAGS_FOR_BUILD@
CXX_FOR_BUILD = @CXX_FOR_BUILD@
DLLTOOL_FOR_BUILD = @DLLTOOL_FOR_BUILD@
@@ -407,6 +410,9 @@ GNATBIND = @GNATBIND@
GNATMAKE = @GNATMAKE@
CFLAGS = @CFLAGS@
+ifeq (${CRASH_TARGET}, PPC64)
+CFLAGS += -m64 -fPIC
+endif
LDFLAGS = @LDFLAGS@
LIBCFLAGS = $(CFLAGS)
CXXFLAGS = @CXXFLAGS@
--- gdb-7.6/gdb/defs.h.orig
+++ gdb-7.6/gdb/defs.h
@@ -802,4 +802,8 @@ enum block_enum
#include "utils.h"
+#ifdef CRASH_MERGE
+extern int gdb_main_entry(int, char **);
+extern void replace_ui_file_FILE(struct ui_file *, FILE *);
+#endif
#endif /* #ifndef DEFS_H */
--- gdb-7.6/bfd/elflink.c.orig
+++ gdb-7.6/bfd/elflink.c
@@ -4730,7 +4730,7 @@ error_free_dyn:
struct elf_link_hash_entry *hlook;
asection *slook;
bfd_vma vlook;
- size_t i, j, idx;
+ size_t i, j, idx = 0;
hlook = weaks;
weaks = hlook->u.weakdef;
--- gdb-7.6/gdb/s390-nat.c.orig
+++ gdb-7.6/gdb/s390-nat.c
@@ -37,6 +37,8 @@
#include <sys/ucontext.h>
#include <elf.h>
+#include <sys/uio.h>
+
#ifndef HWCAP_S390_HIGH_GPRS
#define HWCAP_S390_HIGH_GPRS 512
#endif
--- gdb-7.6/gdb/printcmd.c.orig
+++ gdb-7.6/gdb/printcmd.c
@@ -573,11 +573,21 @@ print_address_symbolic (struct gdbarch *
int unmapped = 0;
int offset = 0;
int line = 0;
+#ifdef CRASH_MERGE
+ extern int gdb_print_callback(unsigned long);
+#endif
/* Throw away both name and filename. */
struct cleanup *cleanup_chain = make_cleanup (free_current_contents, &name);
make_cleanup (free_current_contents, &filename);
+#ifdef CRASH_MERGE
+ if (!gdb_print_callback(addr)) {
+ do_cleanups (cleanup_chain);
+ return 0;
+ }
+#endif
+
if (build_address_symbolic (gdbarch, addr, do_demangle, &name, &offset,
&filename, &line, &unmapped))
{
--- gdb-7.6/bfd/bfd-in.h.orig
+++ gdb-7.6/bfd/bfd-in.h
@@ -294,9 +294,6 @@ typedef struct bfd_section *sec_ptr;
#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
-#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)
-#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)
-#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)
/* Find the address one past the end of SEC. */
#define bfd_get_section_limit(bfd, sec) \
(((bfd)->direction != write_direction && (sec)->rawsize != 0 \
@@ -519,7 +516,6 @@ extern void warn_deprecated (const char
#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
-#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)
extern bfd_boolean bfd_cache_close
(bfd *abfd);
--- gdb-7.6/bfd/bfd-in2.h.orig
+++ gdb-7.6/bfd/bfd-in2.h
@@ -301,9 +301,6 @@ typedef struct bfd_section *sec_ptr;
#define bfd_is_com_section(ptr) (((ptr)->flags & SEC_IS_COMMON) != 0)
-#define bfd_set_section_vma(bfd, ptr, val) (((ptr)->vma = (ptr)->lma = (val)), ((ptr)->user_set_vma = TRUE), TRUE)
-#define bfd_set_section_alignment(bfd, ptr, val) (((ptr)->alignment_power = (val)),TRUE)
-#define bfd_set_section_userdata(bfd, ptr, val) (((ptr)->userdata = (val)),TRUE)
/* Find the address one past the end of SEC. */
#define bfd_get_section_limit(bfd, sec) \
(((bfd)->direction != write_direction && (sec)->rawsize != 0 \
@@ -526,7 +523,6 @@ extern void warn_deprecated (const char
#define bfd_get_symbol_leading_char(abfd) ((abfd)->xvec->symbol_leading_char)
-#define bfd_set_cacheable(abfd,bool) (((abfd)->cacheable = bool), TRUE)
extern bfd_boolean bfd_cache_close
(bfd *abfd);
@@ -1572,6 +1568,32 @@ struct relax_table {
int size;
};
+/* Note: the following are provided as inline functions rather than macros
+ because not all callers use the return value. A macro implementation
+ would use a comma expression, eg: "((ptr)->foo = val, TRUE)" and some
+ compilers will complain about comma expressions that have no effect. */
+static inline bfd_boolean
+bfd_set_section_userdata (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, void * val)
+{
+ ptr->userdata = val;
+ return TRUE;
+}
+
+static inline bfd_boolean
+bfd_set_section_vma (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, bfd_vma val)
+{
+ ptr->vma = ptr->lma = val;
+ ptr->user_set_vma = TRUE;
+ return TRUE;
+}
+
+static inline bfd_boolean
+bfd_set_section_alignment (bfd * abfd ATTRIBUTE_UNUSED, asection * ptr, unsigned int val)
+{
+ ptr->alignment_power = val;
+ return TRUE;
+}
+
/* These sections are global, and are managed by BFD. The application
and target back end are not permitted to change the values in
these sections. */
@@ -6095,6 +6117,14 @@ struct bfd
unsigned int selective_search : 1;
};
+/* See note beside bfd_set_section_userdata. */
+static inline bfd_boolean
+bfd_set_cacheable (bfd * abfd, bfd_boolean val)
+{
+ abfd->cacheable = val;
+ return TRUE;
+}
+
typedef enum bfd_error
{
bfd_error_no_error = 0,
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5405,7 +5405,7 @@ dump_enum(struct type *type, struct gnu_
{
register int i;
int len;
- int lastval;
+ long long lastval;
len = TYPE_NFIELDS (type);
lastval = 0;
@@ -5418,12 +5418,12 @@ dump_enum(struct type *type, struct gnu_
for (i = 0; i < len; i++) {
fprintf_filtered(gdb_stdout, " %s",
TYPE_FIELD_NAME (type, i));
- if (lastval != TYPE_FIELD_BITPOS (type, i)) {
- fprintf_filtered (gdb_stdout, " = %d",
- TYPE_FIELD_BITPOS (type, i));
- lastval = TYPE_FIELD_BITPOS (type, i);
+ if (lastval != TYPE_FIELD_ENUMVAL (type, i)) {
+ fprintf_filtered (gdb_stdout, " = %s",
+ plongest(TYPE_FIELD_ENUMVAL (type, i)));
+ lastval = TYPE_FIELD_ENUMVAL (type, i);
} else
- fprintf_filtered(gdb_stdout, " = %d", lastval);
+ fprintf_filtered(gdb_stdout, " = %s", plongest(lastval));
fprintf_filtered(gdb_stdout, "\n");
lastval++;
}
--- gdb-7.6/gdb/aarch64-linux-nat.c.orig
+++ gdb-7.6/gdb/aarch64-linux-nat.c
@@ -32,6 +32,7 @@
#include "elf/common.h"
#include <sys/ptrace.h>
+#include <asm/ptrace.h>
#include <sys/utsname.h>
#include "gregset.h"
--- gdb-7.6/sim/igen/Makefile.in.orig
+++ gdb-7.6/sim/igen/Makefile.in
@@ -117,7 +117,7 @@ IGEN_OBJS=\
gen.o
igen: igen.o $(IGEN_OBJS)
- $(CC_FOR_BUILD) $(BUILD_LDFLAGS) -o igen igen.o $(IGEN_OBJS) $(LIBIBERTY_LIB)
+ $(CC_FOR_BUILD) $(BUILD_CFLAGS) $(BUILD_LDFLAGS) -o igen igen.o $(IGEN_OBJS) $(LIBIBERTY_LIB)
igen.o: igen.c misc.h filter_host.h lf.h table.h ld-decode.h ld-cache.h ld-insn.h filter.h gen-model.h gen-itable.h gen-icache.h gen-idecode.h gen-engine.h gen-semantics.h gen-support.h gen.h igen.h
$(CC_FOR_BUILD) $(BUILD_CFLAGS) -c $(srcdir)/igen.c
--- gdb-7.6/sim/mips/cp1.c.orig
+++ gdb-7.6/sim/mips/cp1.c
@@ -1359,7 +1359,7 @@ fp_rsqrt2(sim_cpu *cpu,
/* Conversion operations. */
uword64
-convert (sim_cpu *cpu,
+sim_mips_convert (sim_cpu *cpu,
address_word cia,
int rm,
uword64 op,
--- gdb-7.6/sim/mips/sim-main.h.orig
+++ gdb-7.6/sim/mips/sim-main.h
@@ -770,8 +770,8 @@ unsigned64 fp_nmadd (SIM_STATE, unsigned64 op1, unsigned64 op2,
unsigned64 fp_nmsub (SIM_STATE, unsigned64 op1, unsigned64 op2,
unsigned64 op3, FP_formats fmt);
#define NegMultiplySub(op1,op2,op3,fmt) fp_nmsub(SIM_ARGS, op1, op2, op3, fmt)
-unsigned64 convert (SIM_STATE, int rm, unsigned64 op, FP_formats from, FP_formats to);
-#define Convert(rm,op,from,to) convert (SIM_ARGS, rm, op, from, to)
+unsigned64 sim_mips_convert (SIM_STATE, int rm, unsigned64 op, FP_formats from, FP_formats to);
+#define Convert(rm,op,from,to) sim_mips_convert (SIM_ARGS, rm, op, from, to)
unsigned64 convert_ps (SIM_STATE, int rm, unsigned64 op, FP_formats from,
FP_formats to);
#define ConvertPS(rm,op,from,to) convert_ps (SIM_ARGS, rm, op, from, to)
--- gdb-7.6/readline/util.c
+++ gdb-7.6/readline/util.c
@@ -493,10 +493,13 @@ _rl_trace (va_alist)
if (_rl_tracefp == 0)
_rl_tropen ();
+ if (!_rl_tracefp)
+ goto out;
vfprintf (_rl_tracefp, format, args);
fprintf (_rl_tracefp, "\n");
fflush (_rl_tracefp);
+out:
va_end (args);
}
@@ -509,16 +512,17 @@ _rl_tropen ()
fclose (_rl_tracefp);
sprintf (fnbuf, "/var/tmp/rltrace.%ld", getpid());
unlink(fnbuf);
- _rl_tracefp = fopen (fnbuf, "w+");
+ _rl_tracefp = fopen (fnbuf, "w+xe");
return _rl_tracefp != 0;
}
int
_rl_trclose ()
{
- int r;
+ int r = 0;
- r = fclose (_rl_tracefp);
+ if (_rl_tracefp)
+ r = fclose (_rl_tracefp);
_rl_tracefp = 0;
return r;
}
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5447,9 +5447,9 @@ eval_enum(struct type *type, struct gnu_
lastval = 0;
for (i = 0; i < len; i++) {
- if (lastval != TYPE_FIELD_BITPOS (type, i)) {
- lastval = TYPE_FIELD_BITPOS (type, i);
- }
+ if (lastval != TYPE_FIELD_ENUMVAL (type, i))
+ lastval = TYPE_FIELD_ENUMVAL (type, i);
+
if (STREQ(TYPE_FIELD_NAME(type, i), req->name)) {
req->tagname = "(unknown)";
req->value = lastval;
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5236,6 +5236,12 @@ gdb_command_funnel(struct gnu_request *r
gdb_set_crash_block(req);
break;
+ case GNU_GET_FUNCTION_RANGE:
+ sym = lookup_symbol(req->name, 0, VAR_DOMAIN, 0);
+ if (!find_pc_partial_function(req->pc, NULL, &req->addr, &req->addr2))
+ req->flags |= GNU_COMMAND_FAILED;
+ break;
+
default:
req->flags |= GNU_COMMAND_FAILED;
break;
--- gdb-7.6/opcodes/i386-dis.c.orig
+++ gdb-7.6/opcodes/i386-dis.c
@@ -11300,6 +11300,29 @@ get_sib (disassemble_info *info)
}
}
+static char *
+check_for_extensions(struct dis_private *priv)
+{
+ unsigned char ModRM;
+
+ if ((priv->the_buffer[0] == 0x66) &&
+ (priv->the_buffer[1] == 0x0f) &&
+ (priv->the_buffer[2] == 0xae)) {
+ ModRM = priv->the_buffer[3];
+ if (ModRM == 0xf8)
+ return "pcommit";
+
+ switch ((ModRM >> 3))
+ {
+ case 0x6:
+ return "clwb";
+ case 0x7:
+ return "clflushopt";
+ }
+ }
+ return NULL;
+}
+
static int
print_insn (bfd_vma pc, disassemble_info *info)
{
@@ -11312,6 +11335,7 @@ print_insn (bfd_vma pc, disassemble_info
struct dis_private priv;
int prefix_length;
int default_prefixes;
+ char *extension;
priv.orig_sizeflag = AFLAG | DFLAG;
if ((info->mach & bfd_mach_i386_i386) != 0)
@@ -11575,6 +11599,7 @@ print_insn (bfd_vma pc, disassemble_info
need_vex = 0;
need_vex_reg = 0;
vex_w_done = 0;
+ extension = NULL;
if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
{
@@ -11610,9 +11635,14 @@ print_insn (bfd_vma pc, disassemble_info
name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
if (name == NULL)
name = INTERNAL_DISASSEMBLER_ERROR;
- (*info->fprintf_func) (info->stream, "%s", name);
- return 1;
- }
+ if ((extension = check_for_extensions(&priv))) {
+ strcpy(obuf, extension);
+ obufp = &obuf[strlen(obuf)];
+ } else {
+ (*info->fprintf_func) (info->stream, "%s", name);
+ return 1;
+ }
+ }
}
/* Check if the REX prefix is used. */
@@ -11637,7 +11667,7 @@ print_insn (bfd_vma pc, disassemble_info
all_prefixes[last_data_prefix] = 0;
prefix_length = 0;
- for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
+ for (i = 0; !extension && i < (int) ARRAY_SIZE (all_prefixes); i++)
if (all_prefixes[i])
{
const char *name;
@@ -11655,7 +11685,8 @@ print_insn (bfd_vma pc, disassemble_info
return MAX_CODE_LENGTH;
}
- obufp = mnemonicendp;
+ if (!extension)
+ obufp = mnemonicendp;
for (i = strlen (obuf) + prefix_length; i < 6; i++)
oappend (" ");
oappend (" ");
--- gdb-7.6/bfd/coff-i386.c.orig
+++ gdb-7.6/bfd/coff-i386.c
@@ -141,7 +141,7 @@ coff_i386_reloc (bfd *abfd,
#define DOIT(x) \
x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
- if (diff != 0)
+ if (diff != 0)
{
reloc_howto_type *howto = reloc_entry->howto;
unsigned char *addr = (unsigned char *) data + reloc_entry->address;
--- gdb-7.6/bfd/coff-x86_64.c.orig
+++ gdb-7.6/bfd/coff-x86_64.c
@@ -139,7 +139,7 @@ coff_amd64_reloc (bfd *abfd,
#define DOIT(x) \
x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
- if (diff != 0)
+ if (diff != 0)
{
reloc_howto_type *howto = reloc_entry->howto;
unsigned char *addr = (unsigned char *) data + reloc_entry->address;
--- gdb-7.6/opcodes/arm-dis.c.orig
+++ gdb-7.6/opcodes/arm-dis.c
@@ -2103,7 +2103,7 @@ print_insn_coprocessor (bfd_vma pc,
/* Is ``imm'' a negative number? */
if (imm & 0x40)
- imm |= (-1 << 7);
+ imm -= 0x80;
func (stream, "%d", imm);
}
diff -up gdb-7.6/bfd/elf64-ppc.c.orig gdb-7.6/bfd/elf64-ppc.c
--- gdb-7.6/bfd/elf64-ppc.c.orig 2016-02-02 11:04:25.436527347 -0500
+++ gdb-7.6/bfd/elf64-ppc.c 2016-02-02 11:11:51.926468454 -0500
@@ -11743,7 +11743,7 @@ ppc64_elf_size_stubs (struct bfd_link_in
stub_sec = stub_sec->next)
if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
- & (-1 << htab->plt_stub_align));
+ & -(1 << htab->plt_stub_align));
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
@@ -12093,7 +12093,7 @@ ppc64_elf_build_stubs (bfd_boolean emit_
stub_sec = stub_sec->next)
if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
stub_sec->size = ((stub_sec->size + (1 << htab->plt_stub_align) - 1)
- & (-1 << htab->plt_stub_align));
+ & -(1 << htab->plt_stub_align));
for (stub_sec = htab->stub_bfd->sections;
stub_sec != NULL;
--- gdb-7.6/include/opcode/ppc.h.orig
+++ gdb-7.6/include/opcode/ppc.h
@@ -278,7 +278,7 @@ extern const unsigned int num_powerpc_op
/* Use with the shift field of a struct powerpc_operand to indicate
that BITM and SHIFT cannot be used to determine where the operand
goes in the insn. */
-#define PPC_OPSHIFT_INV (-1 << 31)
+#define PPC_OPSHIFT_INV (-1U << 31)
/* Values defined for the flags field of a struct powerpc_operand. */
--- gdb-7.6/opcodes/mips-dis.c.orig
+++ gdb-7.6/opcodes/mips-dis.c
@@ -245,18 +245,6 @@ static const char * const mips_cp0_names
"c0_taglo", "c0_taghi", "c0_errorepc", "$31"
};
-static const struct mips_cp0sel_name mips_cp0sel_names_mipsr5900[] =
-{
- { 24, 2, "c0_iab" },
- { 24, 3, "c0_iabm" },
- { 24, 4, "c0_dab" },
- { 24, 5, "c0_dabm" },
- { 24, 6, "c0_dvb" },
- { 24, 7, "c0_dvbm" },
- { 25, 1, "c0_perfcnt,1" },
- { 25, 2, "c0_perfcnt,2" }
-};
-
static const char * const mips_cp0_names_mips3264[32] =
{
"c0_index", "c0_random", "c0_entrylo0", "c0_entrylo1",
--- gdb-7.6/gdb/ada-lang.c.orig
+++ gdb-7.6/gdb/ada-lang.c
@@ -10503,7 +10503,7 @@ ada_evaluate_subexp (struct type *expect
}
else
arg1 = ada_value_struct_elt (arg1, &exp->elts[pc + 2].string, 0);
- arg1 = unwrap_value (arg1);
+ arg1 = unwrap_value (arg1);
return ada_to_fixed_value (arg1);
case OP_TYPE:
--- gdb-7.6/gdb/linux-record.c.orig
+++ gdb-7.6/gdb/linux-record.c
@@ -112,7 +112,7 @@ record_linux_sockaddr (struct regcache *
"memory at addr = 0x%s len = %d.\n",
phex_nz (len, tdep->size_pointer),
tdep->size_int);
- return -1;
+ return -1;
}
addrlen = (int) extract_unsigned_integer (a, tdep->size_int, byte_order);
if (addrlen <= 0 || addrlen > tdep->size_sockaddr)
@@ -150,7 +150,7 @@ record_linux_msghdr (struct regcache *re
"len = %d.\n",
phex_nz (addr, tdep->size_pointer),
tdep->size_msghdr);
- return -1;
+ return -1;
}
/* msg_name msg_namelen */
@@ -186,7 +186,7 @@ record_linux_msghdr (struct regcache *re
"len = %d.\n",
phex_nz (addr,tdep->size_pointer),
tdep->size_iovec);
- return -1;
+ return -1;
}
tmpaddr = (CORE_ADDR) extract_unsigned_integer (iov,
tdep->size_pointer,
@@ -948,7 +948,7 @@ Do you want to stop the program?"),
"memory at addr = 0x%s len = %d.\n",
OUTPUT_REG (tmpulongest, tdep->arg2),
tdep->size_ulong);
- return -1;
+ return -1;
}
tmpulongest = extract_unsigned_integer (a, tdep->size_ulong,
byte_order);
--- gdb-7.6/gdb/inflow.c.orig
+++ gdb-7.6/gdb/inflow.c
@@ -391,7 +391,7 @@ terminal_ours_1 (int output_only)
if (tinfo->run_terminal != NULL || gdb_has_a_terminal () == 0)
return;
- {
+ {
#ifdef SIGTTOU
/* Ignore this signal since it will happen when we try to set the
pgrp. */
--- gdb-7.6/gdb/printcmd.c.orig
+++ gdb-7.6/gdb/printcmd.c
@@ -1045,7 +1045,7 @@ print_command_2 (char *exp, int inspect,
else
val = access_value_history (0);
- printf_filtered ("%d %d %d %d %d %d\n",
+ printf_filtered ("%d %d %d %d %d %d\n",
TYPE_CODE (check_typedef(value_type (val))),
TYPE_UNSIGNED (check_typedef(value_type (val))),
TYPE_LENGTH (check_typedef(value_type(val))),
--- gdb-7.6/gdb/c-typeprint.c.orig
+++ gdb-7.6/gdb/c-typeprint.c
@@ -1293,7 +1293,7 @@ c_type_print_base (struct type *type, st
if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
fprintf_filtered (stream, "\n");
- for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
+ for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
{
struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5139,6 +5139,8 @@ static void get_user_print_option_addres
extern int get_frame_offset(CORE_ADDR);
static void gdb_set_crash_block(struct gnu_request *);
void gdb_command_funnel(struct gnu_request *);
+static long lookup_struct_contents(struct gnu_request *);
+static void iterate_datatypes(struct gnu_request *);
struct objfile *gdb_kernel_objfile = { 0 };
@@ -5242,6 +5244,14 @@ gdb_command_funnel(struct gnu_request *r
req->flags |= GNU_COMMAND_FAILED;
break;
+ case GNU_LOOKUP_STRUCT_CONTENTS:
+ req->value = lookup_struct_contents(req);
+ break;
+
+ case GNU_GET_NEXT_DATATYPE:
+ iterate_datatypes(req);
+ break;
+
default:
req->flags |= GNU_COMMAND_FAILED;
break;
@@ -5779,4 +5789,135 @@ gdb_get_crash_block(void)
else
return NULL;
}
+
+static long
+lookup_struct_contents(struct gnu_request *req)
+{
+ int i;
+ long r;
+ struct field *f;
+ struct main_type *m;
+ const char *n;
+ struct main_type *top_m = (struct main_type *)req->addr;
+ char *type_name = req->type_name;
+
+ if (!top_m || !type_name)
+ return 0;
+
+ for (i = 0; i < top_m->nfields; i++)
+ {
+ f = top_m->flds_bnds.fields + i;
+ if (!f->type)
+ continue;
+ m = f->type->main_type;
+
+ // If the field is an array, check the target type -
+ // it might be structure, or might not be.
+ // - struct request_sock *syn_table[0];
+ // here m->target_type->main_type->code is expected
+ // to be TYPE_CODE_PTR
+ // - struct list_head vec[TVN_SIZE];
+ // here m->target_type->main_type->code should be
+ // TYPE_CODE_STRUCT
+ if (m->code == TYPE_CODE_ARRAY && m->target_type)
+ m = m->target_type->main_type;
+
+ /* Here is a recursion.
+ * If we have struct variable (not pointer),
+ * scan this inner structure
+ */
+ if (m->code == TYPE_CODE_STRUCT) {
+ req->addr = (ulong)m;
+ r = lookup_struct_contents(req);
+ req->addr = (ulong)top_m;
+ if (r)
+ return 1;
+ }
+
+ if (m->code == TYPE_CODE_PTR && m->target_type)
+ m = m->target_type->main_type;
+ if (m->name)
+ n = m->name;
+ else if (m->tag_name)
+ n = m->tag_name;
+ else
+ continue;
+
+ if (strstr(n, type_name))
+ return 1;
+ }
+
+ return 0;
+}
+
+static void
+iterate_datatypes (struct gnu_request *req)
+{
+ static struct block_iterator bi; // Keeping this static will simplify code
+ struct block *b;
+ int do_return = 0;
+ struct global_iterator *gi = &req->global_iterator;
+
+ if (gi->finished)
+ return;
+
+ if (gi->obj == NULL)
+ {
+ gi->obj = current_program_space->objfiles;
+ gi->symtab = NULL;
+ do_return = 1; // The initial case - we don't need to make next step.
+ }
+
+ for (; gi->obj; gi->obj = gi->obj->next, gi->symtab = NULL)
+ {
+ if (gi->symtab == NULL)
+ {
+ // Symtab `symtab` is nullified for every objfile
+ if (gi->obj->sf)
+ gi->obj->sf->qf->expand_all_symtabs(gi->obj);
+ gi->symtab = gi->obj->symtabs;
+ gi->sym = NULL;
+ }
+
+ for (; gi->symtab; gi->symtab = gi->symtab->next, gi->block_index = -1)
+ {
+ if (!gi->symtab->primary)
+ continue;
+
+ if (gi->block_index == -1)
+ {
+ gi->block_index = GLOBAL_BLOCK;
+ gi->sym = NULL;
+ }
+ for (; gi->block_index <= STATIC_BLOCK; gi->block_index++, gi->sym = NULL)
+ {
+ if (!gi->sym)
+ {
+ b = BLOCKVECTOR_BLOCK(BLOCKVECTOR(gi->symtab), gi->block_index);
+ gi->sym = block_iterator_first(b, &bi);
+ }
+ for (; gi->sym; gi->sym = block_iterator_next(&bi))
+ {
+ QUIT;
+
+ if (SYMBOL_CLASS (gi->sym) != LOC_TYPEDEF)
+ continue;
+
+ // Iteration 1 (do_return == 0): initialization
+ // Iteration 2 (do_return == 1): iterate symbol
+ if (do_return++ == 0)
+ continue;
+
+ // Yield the current symbol and its size
+ req->addr = (ulong)(gi->sym->type->main_type);
+ req->name = (char *)(gi->sym->ginfo.name);
+ req->length = gi->sym->type->length;
+
+ return;
+ }
+ }
+ }
+ }
+ gi->finished = 1;
+}
#endif
--- gdb-7.6/bfd/elf64-s390.c.orig
+++ gdb-7.6/bfd/elf64-s390.c
@@ -323,10 +323,10 @@ elf_s390_reloc_name_lookup (bfd *abfd AT
&& strcasecmp (elf_howto_table[i].name, r_name) == 0)
return &elf_howto_table[i];
- if (strcasecmp (elf64_s390_vtinherit_howto.name, r_name) == 0)
- return &elf64_s390_vtinherit_howto;
- if (strcasecmp (elf64_s390_vtentry_howto.name, r_name) == 0)
- return &elf64_s390_vtentry_howto;
+ if (strcasecmp (elf64_s390_vtinherit_howto.name, r_name) == 0)
+ return &elf64_s390_vtinherit_howto;
+ if (strcasecmp (elf64_s390_vtentry_howto.name, r_name) == 0)
+ return &elf64_s390_vtentry_howto;
return NULL;
}
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5122,7 +5122,7 @@ When enabled, debugging messages are pri
#define GDB_COMMON
#include "../../defs.h"
-static void get_member_data(struct gnu_request *, struct type *);
+static void get_member_data(struct gnu_request *, struct type *, long, int);
static void dump_enum(struct type *, struct gnu_request *);
static void eval_enum(struct type *, struct gnu_request *);
static void gdb_get_line_number(struct gnu_request *);
@@ -5327,7 +5327,7 @@ gdb_get_datatype(struct gnu_request *req
req->typecode = TYPE_CODE(sym->type);
req->length = TYPE_LENGTH(sym->type);
if (req->member)
- get_member_data(req, sym->type);
+ get_member_data(req, sym->type, 0, 1);
if (TYPE_CODE(sym->type) == TYPE_CODE_ENUM) {
if (req->flags & GNU_PRINT_ENUMERATORS)
@@ -5397,7 +5397,7 @@ gdb_get_datatype(struct gnu_request *req
}
if (req->member)
- get_member_data(req, type);
+ get_member_data(req, type, 0, 1);
break;
@@ -5480,7 +5480,7 @@ eval_enum(struct type *type, struct gnu_
* member field, and when found, return its relevant data.
*/
static void
-get_member_data(struct gnu_request *req, struct type *type)
+get_member_data(struct gnu_request *req, struct type *type, long offset, int is_first)
{
register short i;
struct field *nextfield;
@@ -5492,7 +5492,7 @@ get_member_data(struct gnu_request *req,
nfields = TYPE_MAIN_TYPE(type)->nfields;
nextfield = TYPE_MAIN_TYPE(type)->flds_bnds.fields;
- if (nfields == 0) {
+ if (nfields == 0 && is_first /* The first call */) {
struct type *newtype;
newtype = lookup_transparent_type(req->name);
if (newtype) {
@@ -5505,13 +5505,18 @@ get_member_data(struct gnu_request *req,
for (i = 0; i < nfields; i++) {
if (STREQ(req->member, nextfield->name)) {
- req->member_offset = nextfield->loc.bitpos;
+ req->member_offset = offset + nextfield->loc.bitpos;
req->member_length = TYPE_LENGTH(nextfield->type);
req->member_typecode = TYPE_CODE(nextfield->type);
if ((req->member_typecode == TYPE_CODE_TYPEDEF) &&
(typedef_type = check_typedef(nextfield->type)))
req->member_length = TYPE_LENGTH(typedef_type);
return;
+ } else if (*nextfield->name == 0) { /* Anonymous struct/union */
+ get_member_data(req, nextfield->type,
+ offset + nextfield->loc.bitpos, 0);
+ if (req->member_offset != -1)
+ return;
}
nextfield++;
}
@@ -5706,7 +5711,7 @@ gdb_get_symbol_type(struct gnu_request *
}
if (req->member)
- get_member_data(req, type);
+ get_member_data(req, type, 0, 1);
do_cleanups (old_chain);
}
diff -up gdb-7.6/bfd/configure.orig gdb-7.6/bfd/configure
--- gdb-7.6/bfd/configure.orig 2017-02-17 17:19:51.654898822 -0500
+++ gdb-7.6/bfd/configure 2017-02-17 17:19:57.922038757 -0500
@@ -12193,7 +12193,7 @@ fi
NO_WERROR=
if test "${ERROR_ON_WARNING}" = yes ; then
- GCC_WARN_CFLAGS="$GCC_WARN_CFLAGS -Werror"
+ GCC_WARN_CFLAGS="$GCC_WARN_CFLAGS"
NO_WERROR="-Wno-error"
fi
diff -up gdb-7.6/opcodes/configure.orig gdb-7.6/opcodes/configure
--- gdb-7.6/opcodes/configure.orig 2017-02-17 17:19:08.849943016 -0500
+++ gdb-7.6/opcodes/configure 2017-02-17 17:19:23.256264699 -0500
@@ -11539,7 +11539,7 @@ fi
NO_WERROR=
if test "${ERROR_ON_WARNING}" = yes ; then
- GCC_WARN_CFLAGS="$GCC_WARN_CFLAGS -Werror"
+ GCC_WARN_CFLAGS="$GCC_WARN_CFLAGS"
NO_WERROR="-Wno-error"
fi
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5266,6 +5266,7 @@ gdb_get_line_number(struct gnu_request *
{
struct symtab_and_line sal;
struct symbol *sym;
+ struct objfile *objfile;
CORE_ADDR pc;
#define LASTCHAR(s) (s[strlen(s)-1])
@@ -5281,8 +5282,22 @@ gdb_get_line_number(struct gnu_request *
sal = find_pc_line(pc, 0);
if (!sal.symtab) {
- req->buf[0] = '\0';
- return;
+ /*
+ * If a module address line number can't be found, it's typically
+ * due to its addrmap still containing offset values because its
+ * objfile doesn't have full symbols loaded.
+ */
+ if (req->lm) {
+ objfile = req->lm->loaded_objfile;
+ if (!objfile_has_full_symbols(objfile) && objfile->sf) {
+ objfile->sf->qf->expand_all_symtabs(objfile);
+ sal = find_pc_line(pc, 0);
+ }
+ }
+ if (!sal.symtab) {
+ req->buf[0] = '\0';
+ return;
+ }
}
if (sal.symtab->filename && sal.symtab->dirname) {
@@ -5557,7 +5572,6 @@ struct load_module *gdb_current_load_mod
static void
gdb_add_symbol_file(struct gnu_request *req)
{
- register struct objfile *loaded_objfile = NULL;
register struct objfile *objfile;
register struct minimal_symbol *m;
struct load_module *lm;
@@ -5576,6 +5590,7 @@ gdb_add_symbol_file(struct gnu_request *
req->name = lm->mod_namelist;
gdb_delete_symbol_file(req);
+ lm->loaded_objfile = NULL;
if ((lm->mod_flags & MOD_NOPATCH) == 0) {
for (i = 0 ; i < lm->mod_sections; i++) {
@@ -5623,12 +5638,15 @@ gdb_add_symbol_file(struct gnu_request *
ALL_OBJFILES(objfile) {
if (same_file(objfile->name, lm->mod_namelist)) {
- loaded_objfile = objfile;
+ if (objfile->separate_debug_objfile)
+ lm->loaded_objfile = objfile->separate_debug_objfile;
+ else
+ lm->loaded_objfile = objfile;
break;
}
}
- if (!loaded_objfile)
+ if (!lm->loaded_objfile)
req->flags |= GNU_COMMAND_FAILED;
}
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5500,7 +5500,7 @@ get_member_data(struct gnu_request *req,
register short i;
struct field *nextfield;
short nfields;
- struct type *typedef_type;
+ struct type *typedef_type, *target_type;
req->member_offset = -1;
@@ -5523,6 +5523,13 @@ get_member_data(struct gnu_request *req,
req->member_offset = offset + nextfield->loc.bitpos;
req->member_length = TYPE_LENGTH(nextfield->type);
req->member_typecode = TYPE_CODE(nextfield->type);
+ req->member_main_type_name = (char *)TYPE_NAME(nextfield->type);
+ req->member_main_type_tag_name = (char *)TYPE_TAG_NAME(nextfield->type);
+ target_type = TYPE_TARGET_TYPE(nextfield->type);
+ if (target_type) {
+ req->member_target_type_name = (char *)TYPE_NAME(target_type);
+ req->member_target_type_tag_name = (char *)TYPE_TAG_NAME(target_type);
+ }
if ((req->member_typecode == TYPE_CODE_TYPEDEF) &&
(typedef_type = check_typedef(nextfield->type)))
req->member_length = TYPE_LENGTH(typedef_type);
--- gdb-7.6/gdb/symtab.c.orig
+++ gdb-7.6/gdb/symtab.c
@@ -5727,6 +5727,7 @@ gdb_get_symbol_type(struct gnu_request *
req->type_name = (char *)TYPE_MAIN_TYPE(type)->name;
req->typecode = TYPE_MAIN_TYPE(type)->code;
req->length = type->length;
+ req->type_tag_name = (char *)TYPE_TAG_NAME(type);
target_type = TYPE_MAIN_TYPE(type)->target_type;
if (target_type) {
--- gdb-7.6/gdb/common/linux-ptrace.c.orig
+++ gdb-7.6/gdb/common/linux-ptrace.c
@@ -108,14 +108,14 @@ linux_ptrace_test_ret_to_nx (void)
".globl linux_ptrace_test_ret_to_nx_instr;"
"linux_ptrace_test_ret_to_nx_instr:"
"ret"
- : : "r" (return_address) : "%esp", "memory");
+ : : "r" (return_address) : "memory");
#elif defined __x86_64__
asm volatile ("pushq %0;"
".globl linux_ptrace_test_ret_to_nx_instr;"
"linux_ptrace_test_ret_to_nx_instr:"
"ret"
: : "r" ((uint64_t) (uintptr_t) return_address)
- : "%rsp", "memory");
+ : "memory");
#else
# error "!__i386__ && !__x86_64__"
#endif