# 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)

+{