gdb/patches/gdb-6.3-scanmem-gcc4-aware.patch

diff -Nrup gdb-6.3.orig/gdb/printcmd.c gdb-6.3/gdb/printcmd.c
--- gdb-6.3.orig/gdb/printcmd.c	2004-09-11 06:24:50.000000000 -0400
+++ gdb-6.3/gdb/printcmd.c	2004-11-27 19:48:18.000000000 -0500
@@ -940,6 +940,195 @@ print_command (char *exp, int from_tty)
   print_command_1 (exp, 0, 1);
 }
 
+static void 
+scanmem_command(char *exp, int from_tty)
+{
+   struct expression *expr;
+   struct value *val;
+   struct format_data fmt;
+   CORE_ADDR addr;
+   unsigned char *data;
+   unsigned char *size;
+   unsigned char *pattern;
+   unsigned char typ;
+   unsigned char typc;
+   unsigned char my_buf[4];
+   unsigned int nfetch;
+   unsigned int len = 10;
+   unsigned int memsize;
+   unsigned int i;
+   int typi;
+   int errcode;
+
+   if (exp && *exp) {
+      struct type *type;
+      char *str_num = NULL;
+      char *string_to_seek = NULL;
+      char *tmp = strdup(exp);
+      char *c;
+
+      c = tmp;
+      if (*c == ' ')
+	 while (*c && *c == ' ')
+	    c++;
+
+      while (*c && *c != ' ')
+	 c++;
+
+      *c = '\0';
+      c++;
+
+      while (*c && *c == ' ')
+	 c++;
+
+      size = c;
+
+      while (*c && *c != ' ')
+	 c++;
+
+      *c = '\0';
+      c++;
+
+      while (*c && *c == ' ')
+	 c++;
+
+      typ = *c;
+      c++;
+
+      *c = '\0';
+      c++;
+
+      while (*c && *c == ' ')
+	 c++;
+      pattern = c;
+
+      printf_filtered(">>addr %s: size %s: type:%c pattern:%s<< \n",
+		      tmp, size, typ, pattern);
+
+      expr = parse_expression(tmp);
+      val = evaluate_expression(expr);
+
+      if (TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_REF)
+	 val = value_ind(val);
+
+      if (TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_FUNC
+	  && VALUE_LVAL(val) == lval_memory)
+	 addr = VALUE_ADDRESS(val);
+      else
+	 addr = value_as_address(val);
+
+      len = atoi(size);
+      data = xmalloc(len);
+      nfetch = partial_memory_read(addr, data, len, &errcode);
+
+      if (nfetch != len)
+	 printf_filtered("we can read only %i bytes\n", nfetch);
+
+      switch (typ) {
+	 case 's':
+	    memsize = strlen(pattern);
+	    if (nfetch < memsize) {
+	       printf_filtered
+		   ("we read only %i bytes and we seek for a pattern of %i bytes\n",
+		    nfetch, memsize);
+	       free(data);
+	       free(tmp);
+	       return;
+	    }
+	    for (i = 0; i <= (nfetch - memsize); i++, addr++) {
+	       if (memcmp(data + i, pattern, memsize) == 0) {
+		  printf_filtered("pattern match at ");
+		  print_address_numeric((addr), 1, gdb_stdout);
+		  printf_filtered("\n");
+	       }
+	    }
+	    break;
+	 case 'i':
+	    memsize = sizeof(int);
+	    typi = atoi(pattern);
+
+	    if (nfetch < memsize) {
+	       printf_filtered
+		   ("we read only %i bytes and we seek for a pattern of %i bytes\n",
+		    nfetch, memsize);
+	       free(data);
+	       free(tmp);
+	       return;
+	    }
+	    for (i = 0; i <= (nfetch - memsize); i++, addr++) {
+	       int *pint;
+	       pint = (unsigned char *) (data + i);
+	       if (*pint == typi) {
+		  printf_filtered("pattern match at ");
+		  print_address_numeric((addr), 1, gdb_stdout);
+		  printf_filtered("\n");
+	       }
+	    }
+	    break;
+	 case 'a':
+	    memsize = sizeof(unsigned long);
+	    if (sscanf(pattern, "0x%x", &i) == 0) {
+	       printf_filtered("cant convert to hexa %s\n", pattern);
+	       break;
+	    }
+	    my_buf[0] = (unsigned char) ((i & 0x000000FF));
+	    my_buf[1] = (unsigned char) ((i & 0x0000FF00) >> 8);
+	    my_buf[2] = (unsigned char) ((i & 0x00FF0000) >> 16);
+	    my_buf[3] = (unsigned char) ((i & 0xFF000000) >> 24);
+	    if (nfetch < memsize) {
+	       printf_filtered
+		   ("we read only %i bytes and we seek for a pattern of %i bytes\n",
+		    nfetch, memsize);
+	       free(data);
+	       free(tmp);
+	       return;
+	    }
+	    for (i = 0; i <= (nfetch - memsize); i++, addr++) {
+	       if (memcmp((data + i), my_buf, memsize) == 0) {
+		  printf_filtered("pattern match at ");
+		  print_address_numeric((addr), 1, gdb_stdout);
+		  printf_filtered("\n");
+	       }
+	    }
+	    break;
+	 case 'b':
+	 case 'c':
+	    memsize = sizeof(char);
+	    if (typ == 'c')
+	       typc = *pattern;
+	    else {
+	       if (strncmp("0x", pattern, 2) == 0) {
+		  sscanf(pattern, "0x%02x", &typc);
+	       } else
+		  typc = (unsigned char)atoi(pattern);
+	    }
+	    printf_filtered(">>>%0x2\n", (int) typc);
+	    if (nfetch < memsize) {
+	       printf_filtered
+		   ("we read only %i bytes and we seek for a pattern of %i bytes\n",
+		    nfetch, memsize);
+	       free(data);
+	       free(tmp);
+	       return;
+	    }
+	    for (i = 0; i <= (nfetch - memsize); i++, addr++) {
+	       if (*(data + i) == typc) {
+		  printf_filtered("pattern match at ");
+		  print_address_numeric((addr), 1, gdb_stdout);
+		  printf_filtered("\n");
+	       }
+	    }
+	    break;
+	 default:
+	    printf_filtered("'%c' is not a valid type\n", typ);
+	    break;
+      }
+      free(data);
+      free(tmp);
+      return;
+   }
+}
+
 /* Same as print, except in epoch, it gets its own window */
 static void
 inspect_command (char *exp, int from_tty)
@@ -2138,6 +2327,17 @@ EXP may be preceded with /FMT, where FMT
 but no count or size letter (see \"x\" command).", NULL));
   set_cmd_completer (c, location_completer);
   add_com_alias ("p", "print", class_vars, 1);
+  c =
+  add_com ("scanmem", class_vars, scanmem_command,
+	"scanmem  <addr> <num> <type> <string>\n"
+	"example: scanmem  $esp 100 a 0x8048434\n"
+	" scan for this addr into the stack\n\n"
+	" scanmem  0x08048434 100 s fsck\n"
+	" seek for a string\n"
+	" scanmem  0x8048434 100 b 0x75\n"
+	" scan for the char 0x75\n"
+	" a = address c = char b = byte i = int  s = string\n"
+	"\n"); /* antilove@zolo.freelsd.net */
 
   c = add_com ("inspect", class_vars, inspect_command,
 	   "Same as \"print\" command, except that if you are running in the epoch\n\
diff -Nrup gdb-6.3.orig/gdb/valprint.c gdb-6.3/gdb/valprint.c
--- gdb-6.3.orig/gdb/valprint.c	2004-09-12 12:13:04.000000000 -0400
+++ gdb-6.3/gdb/valprint.c	2004-11-27 19:23:54.000000000 -0500
@@ -39,7 +39,7 @@
 
 /* Prototypes for local functions */
 
-static int partial_memory_read (CORE_ADDR memaddr, char *myaddr,
+int partial_memory_read (CORE_ADDR memaddr, char *myaddr,
 				int len, int *errnoptr);
 
 static void show_print (char *, int);
@@ -837,7 +837,7 @@ val_print_array_elements (struct type *t
 /* FIXME: cagney/1999-10-14: Only used by val_print_string.  Can this
    function be eliminated.  */
 
-static int
+int
 partial_memory_read (CORE_ADDR memaddr, char *myaddr, int len, int *errnoptr)
 {
   int nread;			/* Number of bytes actually read. */
1	niro	144	diff -Nrup gdb-6.3.orig/gdb/printcmd.c gdb-6.3/gdb/printcmd.c
2			--- gdb-6.3.orig/gdb/printcmd.c 2004-09-11 06:24:50.000000000 -0400
3			+++ gdb-6.3/gdb/printcmd.c 2004-11-27 19:48:18.000000000 -0500
4			@@ -940,6 +940,195 @@ print_command (char *exp, int from_tty)
5			print_command_1 (exp, 0, 1);
6			}
7
8			+static void
9			+scanmem_command(char *exp, int from_tty)
10			+{
11			+ struct expression *expr;
12			+ struct value *val;
13			+ struct format_data fmt;
14			+ CORE_ADDR addr;
15			+ unsigned char *data;
16			+ unsigned char *size;
17			+ unsigned char *pattern;
18			+ unsigned char typ;
19			+ unsigned char typc;
20			+ unsigned char my_buf[4];
21			+ unsigned int nfetch;
22			+ unsigned int len = 10;
23			+ unsigned int memsize;
24			+ unsigned int i;
25			+ int typi;
26			+ int errcode;
27			+
28			+ if (exp && *exp) {
29			+ struct type *type;
30			+ char *str_num = NULL;
31			+ char *string_to_seek = NULL;
32			+ char *tmp = strdup(exp);
33			+ char *c;
34			+
35			+ c = tmp;
36			+ if (*c == ' ')
37			+ while (c && c == ' ')
38			+ c++;
39			+
40			+ while (c && c != ' ')
41			+ c++;
42			+
43			+ *c = '\0';
44			+ c++;
45			+
46			+ while (c && c == ' ')
47			+ c++;
48			+
49			+ size = c;
50			+
51			+ while (c && c != ' ')
52			+ c++;
53			+
54			+ *c = '\0';
55			+ c++;
56			+
57			+ while (c && c == ' ')
58			+ c++;
59			+
60			+ typ = *c;
61			+ c++;
62			+
63			+ *c = '\0';
64			+ c++;
65			+
66			+ while (c && c == ' ')
67			+ c++;
68			+ pattern = c;
69			+
70			+ printf_filtered(">>addr %s: size %s: type:%c pattern:%s<< \n",
71			+ tmp, size, typ, pattern);
72			+
73			+ expr = parse_expression(tmp);
74			+ val = evaluate_expression(expr);
75			+
76			+ if (TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_REF)
77			+ val = value_ind(val);
78			+
79			+ if (TYPE_CODE(VALUE_TYPE(val)) == TYPE_CODE_FUNC
80			+ && VALUE_LVAL(val) == lval_memory)
81			+ addr = VALUE_ADDRESS(val);
82			+ else
83			+ addr = value_as_address(val);
84			+
85			+ len = atoi(size);
86			+ data = xmalloc(len);
87			+ nfetch = partial_memory_read(addr, data, len, &errcode);
88			+
89			+ if (nfetch != len)
90			+ printf_filtered("we can read only %i bytes\n", nfetch);
91			+
92			+ switch (typ) {
93			+ case 's':
94			+ memsize = strlen(pattern);
95			+ if (nfetch < memsize) {
96			+ printf_filtered
97			+ ("we read only %i bytes and we seek for a pattern of %i bytes\n",
98			+ nfetch, memsize);
99			+ free(data);
100			+ free(tmp);
101			+ return;
102			+ }
103			+ for (i = 0; i <= (nfetch - memsize); i++, addr++) {
104			+ if (memcmp(data + i, pattern, memsize) == 0) {
105			+ printf_filtered("pattern match at ");
106			+ print_address_numeric((addr), 1, gdb_stdout);
107			+ printf_filtered("\n");
108			+ }
109			+ }
110			+ break;
111			+ case 'i':
112			+ memsize = sizeof(int);
113			+ typi = atoi(pattern);
114			+
115			+ if (nfetch < memsize) {
116			+ printf_filtered
117			+ ("we read only %i bytes and we seek for a pattern of %i bytes\n",
118			+ nfetch, memsize);
119			+ free(data);
120			+ free(tmp);
121			+ return;
122			+ }
123			+ for (i = 0; i <= (nfetch - memsize); i++, addr++) {
124			+ int *pint;
125			+ pint = (unsigned char *) (data + i);
126			+ if (*pint == typi) {
127			+ printf_filtered("pattern match at ");
128			+ print_address_numeric((addr), 1, gdb_stdout);
129			+ printf_filtered("\n");
130			+ }
131			+ }
132			+ break;
133			+ case 'a':
134			+ memsize = sizeof(unsigned long);
135			+ if (sscanf(pattern, "0x%x", &i) == 0) {
136			+ printf_filtered("cant convert to hexa %s\n", pattern);
137			+ break;
138			+ }
139			+ my_buf[0] = (unsigned char) ((i & 0x000000FF));
140			+ my_buf[1] = (unsigned char) ((i & 0x0000FF00) >> 8);
141			+ my_buf[2] = (unsigned char) ((i & 0x00FF0000) >> 16);
142			+ my_buf[3] = (unsigned char) ((i & 0xFF000000) >> 24);
143			+ if (nfetch < memsize) {
144			+ printf_filtered
145			+ ("we read only %i bytes and we seek for a pattern of %i bytes\n",
146			+ nfetch, memsize);
147			+ free(data);
148			+ free(tmp);
149			+ return;
150			+ }
151			+ for (i = 0; i <= (nfetch - memsize); i++, addr++) {
152			+ if (memcmp((data + i), my_buf, memsize) == 0) {
153			+ printf_filtered("pattern match at ");
154			+ print_address_numeric((addr), 1, gdb_stdout);
155			+ printf_filtered("\n");
156			+ }
157			+ }
158			+ break;
159			+ case 'b':
160			+ case 'c':
161			+ memsize = sizeof(char);
162			+ if (typ == 'c')
163			+ typc = *pattern;
164			+ else {
165			+ if (strncmp("0x", pattern, 2) == 0) {
166			+ sscanf(pattern, "0x%02x", &typc);
167			+ } else
168			+ typc = (unsigned char)atoi(pattern);
169			+ }
170			+ printf_filtered(">>>%0x2\n", (int) typc);
171			+ if (nfetch < memsize) {
172			+ printf_filtered
173			+ ("we read only %i bytes and we seek for a pattern of %i bytes\n",
174			+ nfetch, memsize);
175			+ free(data);
176			+ free(tmp);
177			+ return;
178			+ }
179			+ for (i = 0; i <= (nfetch - memsize); i++, addr++) {
180			+ if (*(data + i) == typc) {
181			+ printf_filtered("pattern match at ");
182			+ print_address_numeric((addr), 1, gdb_stdout);
183			+ printf_filtered("\n");
184			+ }
185			+ }
186			+ break;
187			+ default:
188			+ printf_filtered("'%c' is not a valid type\n", typ);
189			+ break;
190			+ }
191			+ free(data);
192			+ free(tmp);
193			+ return;
194			+ }
195			+}
196			+
197			/* Same as print, except in epoch, it gets its own window */
198			static void
199			inspect_command (char *exp, int from_tty)
200			@@ -2138,6 +2327,17 @@ EXP may be preceded with /FMT, where FMT
201			but no count or size letter (see \"x\" command).", NULL));
202			set_cmd_completer (c, location_completer);
203			add_com_alias ("p", "print", class_vars, 1);
204			+ c =
205			+ add_com ("scanmem", class_vars, scanmem_command,
206			+ "scanmem <addr> <num> <type> <string>\n"
207			+ "example: scanmem $esp 100 a 0x8048434\n"
208			+ " scan for this addr into the stack\n\n"
209			+ " scanmem 0x08048434 100 s fsck\n"
210			+ " seek for a string\n"
211			+ " scanmem 0x8048434 100 b 0x75\n"
212			+ " scan for the char 0x75\n"
213			+ " a = address c = char b = byte i = int s = string\n"
214			+ "\n"); /* antilove@zolo.freelsd.net */
215
216			c = add_com ("inspect", class_vars, inspect_command,
217			"Same as \"print\" command, except that if you are running in the epoch\n\
218			diff -Nrup gdb-6.3.orig/gdb/valprint.c gdb-6.3/gdb/valprint.c
219			--- gdb-6.3.orig/gdb/valprint.c 2004-09-12 12:13:04.000000000 -0400
220			+++ gdb-6.3/gdb/valprint.c 2004-11-27 19:23:54.000000000 -0500
221			@@ -39,7 +39,7 @@
222
223			/* Prototypes for local functions */
224
225			-static int partial_memory_read (CORE_ADDR memaddr, char *myaddr,
226			+int partial_memory_read (CORE_ADDR memaddr, char *myaddr,
227			int len, int *errnoptr);
228
229			static void show_print (char *, int);
230			@@ -837,7 +837,7 @@ val_print_array_elements (struct type *t
231			/* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
232			function be eliminated. */
233
234			-static int
235			+int
236			partial_memory_read (CORE_ADDR memaddr, char myaddr, int len, int errnoptr)
237			{
238			int nread; /* Number of bytes actually read. */