This is the mail archive of the gdb-patches@sourceware.org mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH] Forbid watchpoint on a constant value


Hi Joel, Tom, Jan

On Friday 28 May 2010 20:11:22, Joel Brobecker wrote:

> > +/* This checks if each element of EXP is not a
> > +   constant expression for a watchpoint.
> > +
> > +   Returns 1 if EXP is constant, 0 otherwise.  */
> 
> We usually use a more imperative style: "do this, do that", as opposed
> to "this does this, this does that".  The negation seems a little weird
> too.  It's no biggie, but I think that your line length is quite shorter
> than usual, making the comment a little odd... Here's a suggestion as
> a starting point:
> 
> /* Return non-zero iff EXP is an expression whose value can never change.  */

Replaced by Jan's version of it.

> > +static int
> > +watchpoint_exp_is_const (struct expression *exp)
> 
> Just a thought that crossed my mind: Can this parameter be declared as
> a const?

Fixed, and also constified the parameters from the operator_length class
of functions.

> > +	/* If it's an OP_VAR_VALUE, then we must check if the `symbol'
> > +	   element does not correspond to a function or to a constant
> > +	   value.  If it does, then it is a constant address.  */
> 
> Same stylistic remark as at the beginning: The use of the negation here
> makes things a little confusing.  How about:
> 
>   - Write something like that:
> 
>        /* Check whether the associated symbol is a constant.
>           We use the symbol class rather than the type because [...].
>           We also have to be careful that function symbols are not
>           always indicative of a constant, due to the fact that this
>           expression might be calling that function.  */

I rewrote the comment based on a new version of the patch (details below),
but thanks for the suggestion.

> > +	/* The default action is to return 0 because we are using
> > +	   the optimistic approach here: if we don't know something,
> > +	   then it is not a constant.  */
> > +	default:
> 
> Capital 'I' after the colon...

That one I didn't know :-).  One more to the list of grammar rules.

> > +	gdb_test_multiple "next" "next over global_ptr_ptr init" {
> > +	    -re ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\r\n\r\nOld value = .*\r\nNew value = 7 .*\r\n.*$gdb_prompt $" {
> > +		# We can not test for <unknown> here because NULL may be readable.
> > +		# This test does rely on *NULL != 7.
> > +		pass "next over global_ptr_ptr init"
> > +	    }
> > +	}
> > +	gdb_test_multiple "next" "next over global_ptr_ptr buffer set" {
> > +	    -re ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\r\n\r\nOld value = 7 .*\r\nNew value = 9 .*\r\n.*$gdb_prompt $" {
> > +		pass "next over global_ptr_ptr buffer set"
> > +	    }
> > +	}
> > +	gdb_test_multiple "next" "next over global_ptr_ptr pointer advance" {
> > +	    -re ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\r\n\r\nOld value = 9 .*\r\nNew value = 5 .*\r\n.*$gdb_prompt $" {
> > +		pass "next over global_ptr_ptr pointer advance"
> > +	    }
> > +	}
> 
> I'm wondering why you are using gdb_test_multiple in these cases, rather
> than just gdb_test?

Sorry about that.  Fixed.

> > +    # See above.
> > +    if [istarget "mips-idt-*"] then {
> > +	gdb_exit
> > +	gdb_start
> > +	gdb_reinitialize_dir $srcdir/$subdir
> > +	gdb_load $binfile
> > +	initialize
> 
> The "gdb_exit ... gdb_load" part of the above can be simplified by
> using: clean_restart.  I should probably add that to the wiki (we have
> a cookbook on how to write testcases).

Thanks for the tip!  Fixed.

> > +if {![istarget *-*-linux*]
> > +    && ![istarget *-*-gnu*]
> > +    && ![istarget *-*-elf*]
> > +    && ![istarget *-*-openbsd*]
> > +    && ![istarget arm-*-eabi*]
> > +    && ![istarget powerpc-*-eabi*]} {
> > +    return 0  
> > +}
> 
> We need to add a comment explaining why... Is it because we need
> a specific assembler/linker?

I strongly based this testcase on gdb.dwarf2/pieces.exp, so I added the
same comment I found there:

	# This test can only be run on targets which support DWARF-2 and use gas.
	# For now pick a sampling of likely targets.

I hope that's enough :-).

Well, here's the refreshed-and-corrected version of the patch.  One thing to
notice is that instead of doing:

	if (!TYPE_CONST (SYMBOL_TYPE (s)) != TYPE_CODE_FUNC
	...

I am now doing:

	if (!SYMBOL_CLASS (s) != LOC_BLOCK
	...

Jan kindly suggested me to do this change, and I checked the DWARF spec in
order to see if LOC_BLOCK is equivalent to TYPE_CODE_FUNC.  As it is, I
decided to replace.

Thanks.

-- 
Sergio Durigan Junior
Red Hat

gdb/ChangeLog:

2010-06-05  Jan Kratochvil  <jan.kratochvil@redhat.com>
	    Sergio Durigan Junior  <sergiodj@redhat.com>

	* breakpoint.c: Include parser-defs.h.
	(watchpoint_exp_is_const): New function.
	(watch_command_1): Call watchpoint_exp_is_const to check
	if the expression is constant.

gdb/doc/ChangeLog:

2010-06-05  Jan Kratochvil  <jan.kratochvil@redhat.com>

	* gdb.texinfo: Include information about the correct use
	of addresses in the `watch' command.

gdb/testsuite/ChangeLog:

2010-06-05  Jan Kratochvil  <jan.kratochvil@redhat.com>
	    Sergio Durigan Junior  <sergiodj@redhat.com>

	* gdb.base/watch-notconst.c: New file.
	* gdb.base/watch-notconst.S: New file.
	* gdb.base/watch-notconst2.c: New file.
	* gdb.base/watch-notconst2.S: New file.
	* gdb.base/watch-notconst.exp: New file.
	* gdb.base/watchpoint.c (global_ptr_ptr): New variable.
	(func4): Add operations on `global_ptr_ptr'.
	* gdb.base/watchpoint.exp (test_constant_watchpoint): New
	routine to test watchpoints created with a constant expression.
	(test_inaccessible_watchpoint): Include tests for watchpoints
	created with a constant expression.


diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 1fc155a..a1b335d 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -61,6 +61,7 @@
 #include "valprint.h"
 #include "jit.h"
 #include "xml-syscall.h"
+#include "parser-defs.h"
 
 /* readline include files */
 #include "readline/readline.h"
@@ -186,6 +187,8 @@ static void stopin_command (char *arg, int from_tty);
 
 static void stopat_command (char *arg, int from_tty);
 
+static int watchpoint_exp_is_const (const struct expression *exp);
+
 static char *ep_parse_optional_if_clause (char **arg);
 
 static void catch_exception_command_1 (enum exception_event_kind ex_event, 
@@ -7700,6 +7703,111 @@ stopat_command (char *arg, int from_tty)
     break_command_1 (arg, 0, from_tty);
 }
 
+/*  Return non-zero if EXP is verified as constant.  Returned zero means EXP is
+    variable.  Also the constant detection may fail for some constant
+    expressions and in such case still falsely return zero.  */
+static int
+watchpoint_exp_is_const (const struct expression *exp)
+{
+  int i = exp->nelts;
+
+  while (i > 0)
+    {
+      int oplenp, argsp;
+
+      /* We are only interested in the descriptor of each element.  */
+      operator_length (exp, i, &oplenp, &argsp);
+      i -= oplenp;
+
+      switch (exp->elts[i].opcode)
+	{
+	case BINOP_ADD:
+	case BINOP_SUB:
+	case BINOP_MUL:
+	case BINOP_DIV:
+	case BINOP_REM:
+	case BINOP_MOD:
+	case BINOP_LSH:
+	case BINOP_RSH:
+	case BINOP_LOGICAL_AND:
+	case BINOP_LOGICAL_OR:
+	case BINOP_BITWISE_AND:
+	case BINOP_BITWISE_IOR:
+	case BINOP_BITWISE_XOR:
+	case BINOP_EQUAL:
+	case BINOP_NOTEQUAL:
+	case BINOP_LESS:
+	case BINOP_GTR:
+	case BINOP_LEQ:
+	case BINOP_GEQ:
+	case BINOP_REPEAT:
+	case BINOP_COMMA:
+	case BINOP_EXP:
+	case BINOP_MIN:
+	case BINOP_MAX:
+	case BINOP_INTDIV:
+	case BINOP_CONCAT:
+	case BINOP_IN:
+	case BINOP_RANGE:
+	case TERNOP_COND:
+	case TERNOP_SLICE:
+	case TERNOP_SLICE_COUNT:
+
+	case OP_LONG:
+	case OP_DOUBLE:
+	case OP_DECFLOAT:
+	case OP_LAST:
+	case OP_COMPLEX:
+	case OP_STRING:
+	case OP_BITSTRING:
+	case OP_ARRAY:
+	case OP_TYPE:
+	case OP_NAME:
+	case OP_OBJC_NSSTRING:
+
+	case UNOP_NEG:
+	case UNOP_LOGICAL_NOT:
+	case UNOP_COMPLEMENT:
+	case UNOP_ADDR:
+	case UNOP_HIGH:
+	  /* Unary, binary and ternary operators: We have to check their
+	     operands.  If they are constant, then so is the result of
+	     that operation.  For instance, if A and B are determined to be
+	     constants, then so is "A + B".
+
+	     UNOP_IND is one exception to the rule above, because the value
+	     of *ADDR is not necessarily a constant, even when ADDR is.  */
+	  break;
+
+	case OP_VAR_VALUE:
+	  /* Check whether the associated symbol is a constant.
+	     We use SYMBOL_CLASS rather than TYPE_CONST because it's
+	     possible that a buggy compiler could mark a variable as constant
+	     even when it is not, and TYPE_CONST would return true in this
+	     case, while SYMBOL_CLASS wouldn't.
+	     We also have to check for function symbols because they are
+	     always constant.  */
+	  {
+	    struct symbol *s = exp->elts[i + 2].symbol;
+
+	    if (SYMBOL_CLASS (s) != LOC_BLOCK
+		&& SYMBOL_CLASS (s) != LOC_CONST
+		&& SYMBOL_CLASS (s) != LOC_CONST_BYTES)
+	      return 0;
+	    break;
+	  }
+
+	/* The default action is to return 0 because we are using
+	   the optimistic approach here: If we don't know something,
+	   then it is not a constant.  */
+	default:
+	  return 0;
+	}
+    }
+
+  return 1;
+}
+
 /* accessflag:  hw_write:  watch write, 
                 hw_read:   watch read, 
 		hw_access: watch access (read or write) */
@@ -7794,6 +7902,17 @@ watch_command_1 (char *arg, int accessflag, int from_tty)
   while (exp_end > exp_start && (exp_end[-1] == ' ' || exp_end[-1] == '\t'))
     --exp_end;
 
+  /* Checking if the expression is not constant.  */
+  if (watchpoint_exp_is_const (exp))
+    {
+      int len;
+
+      len = exp_end - exp_start;
+      while (len > 0 && isspace (exp_start[len - 1]))
+	len--;
+      error (_("Cannot watch constant value `%.*s'."), len, exp_start);
+    }
+
   exp_valid_block = innermost_block;
   mark = value_mark ();
   fetch_watchpoint_value (exp, &val, NULL, NULL);
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index fa7a0ec..98d4565 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -3725,6 +3725,18 @@ This command prints a list of watchpoints, using the same format as
 @code{info break} (@pxref{Set Breaks}).
 @end table
 
+If you watch for a change in a numerically entered address you need to
+dereference it, as the address itself is just a constant number which will
+never change.  @value{GDBN} refuses to create a watchpoint that watches
+a never-changing value:
+
+@smallexample
+(@value{GDBP}) watch 0x600850
+Cannot watch constant value 0x600850.
+(@value{GDBP}) watch *(int *) 0x600850
+Watchpoint 1: *(int *) 6293584
+@end smallexample
+
 @value{GDBN} sets a @dfn{hardware watchpoint} if possible.  Hardware
 watchpoints execute very quickly, and the debugger reports a change in
 value at the exact instruction where the change occurs.  If @value{GDBN}
diff --git a/gdb/testsuite/gdb.base/watchpoint.c b/gdb/testsuite/gdb.base/watchpoint.c
index 9275d88..8c212c1 100644
--- a/gdb/testsuite/gdb.base/watchpoint.c
+++ b/gdb/testsuite/gdb.base/watchpoint.c
@@ -40,6 +40,7 @@ struct foo struct1, struct2, *ptr1, *ptr2;
 int doread = 0;
 
 char *global_ptr;
+char **global_ptr_ptr;
 
 void marker1 ()
 {
@@ -119,6 +120,10 @@ func4 ()
   buf[0] = 3;
   global_ptr = buf;
   buf[0] = 7;
+  buf[1] = 5;
+  global_ptr_ptr = &global_ptr;
+  buf[0] = 9;
+  global_ptr++;
 }
 
 int main ()
diff --git a/gdb/testsuite/gdb.base/watchpoint.exp b/gdb/testsuite/gdb.base/watchpoint.exp
index 56d82e4..e2eea71 100644
--- a/gdb/testsuite/gdb.base/watchpoint.exp
+++ b/gdb/testsuite/gdb.base/watchpoint.exp
@@ -617,7 +617,19 @@ proc test_watchpoint_and_breakpoint {} {
 	}
     }
 }
-    
+
+proc test_constant_watchpoint {} {
+    gdb_test "watch 5" "Cannot watch constant value `5'." "number is constant"
+    gdb_test "watch marker1" "Cannot watch constant value `marker1'." \
+    "marker1 is constant"
+    gdb_test "watch count + 6" ".*atchpoint \[0-9\]+: count \\+ 6"
+    gdb_test_no_output "set \$expr_breakpoint_number = \$bpnum"
+    gdb_test_no_output "delete \$expr_breakpoint_number"
+    gdb_test "watch 7 + count" ".*atchpoint \[0-9\]+: 7 \\+ count"
+    gdb_test_no_output "set \$expr_breakpoint_number = \$bpnum"
+    gdb_test_no_output "delete \$expr_breakpoint_number"
+}
+
 proc test_inaccessible_watchpoint {} {
     global gdb_prompt
 
@@ -638,7 +650,8 @@ proc test_inaccessible_watchpoint {} {
 	}
 
 	gdb_test "watch *global_ptr" ".*atchpoint \[0-9\]+: \\*global_ptr"
-	gdb_test "next" ".*global_ptr = buf.*"
+	gdb_test "set \$global_ptr_breakpoint_number = \$bpnum" ""
+	gdb_test "next" ".*global_ptr = buf.*" "global_ptr next"
 	gdb_test_multiple "next" "next over ptr init" {
 	    -re ".*atchpoint \[0-9\]+: \\*global_ptr\r\n\r\nOld value = .*\r\nNew value = 3 .*\r\n.*$gdb_prompt $" {
 		# We can not test for <unknown> here because NULL may be readable.
@@ -651,6 +664,14 @@ proc test_inaccessible_watchpoint {} {
 		pass "next over buffer set"
 	    }
 	}
+	gdb_test "delete \$global_ptr_breakpoint_number" ""
+	gdb_test "watch **global_ptr_ptr" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr"
+	gdb_test "set \$global_ptr_ptr_breakpoint_number = \$bpnum" ""
+	gdb_test "next" ".*global_ptr_ptr = &global_ptr.*" "gloabl_ptr_ptr next"
+	gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = .*\r\nNew value = 7 .*" "next over global_ptr_ptr init"
+	gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = 7 .*\r\nNew value = 9 .*" "next over global_ptr_ptr buffer set"
+	gdb_test "next" ".*atchpoint \[0-9\]+: \\*\\*global_ptr_ptr\[\r\n\]+Old value = 9 .*\r\nNew value = 5 .*" "next over global_ptr_ptr pointer advance"
+	gdb_test_no_output "delete \$global_ptr_ptr_breakpoint_number"
     }
 }
     
@@ -827,6 +848,13 @@ if [initialize] then {
     test_watchpoint_and_breakpoint
 
     test_watchpoint_in_big_blob
+
+    # See above.
+    if [istarget "mips-idt-*"] then {
+	clean_restart
+    }
+
+    test_constant_watchpoint
 }
 
 # Restore old timeout
diff --git a/gdb/testsuite/gdb.dwarf2/watch-notconst.c b/gdb/testsuite/gdb.dwarf2/watch-notconst.c
new file mode 100644
index 0000000..b500fc4
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/watch-notconst.c
@@ -0,0 +1,39 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2010 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* This program will be compiled with watch-notconst2.S in order to generate a
+   single binary.
+
+   The purpose of this test is to see if GDB can still watch the
+   variable `x' (define in watch-notconst2.c:f) even when we compile
+   the program using -O2 optimization.  */
+
+int
+g (int j)
+{
+  int l = j + 2;
+  return l;
+}
+
+extern int f (int i);
+
+int
+main (int argc, char **argv)
+{
+  f (1);
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.dwarf2/watch-notconst.exp b/gdb/testsuite/gdb.dwarf2/watch-notconst.exp
new file mode 100644
index 0000000..e0b3d33
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/watch-notconst.exp
@@ -0,0 +1,44 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set test "watch-notconst"
+
+# This test can only be run on targets which support DWARF-2 and use gas.
+# For now pick a sampling of likely targets.
+if {![istarget *-*-linux*]
+    && ![istarget *-*-gnu*]
+    && ![istarget *-*-elf*]
+    && ![istarget *-*-openbsd*]
+    && ![istarget arm-*-eabi*]
+    && ![istarget powerpc-*-eabi*]} {
+    return 0  
+}
+
+# This test can only be run on x86 targets.
+if { ![istarget i?86-*] } {
+    return 0
+}
+
+if { [prepare_for_testing "${test}.exp" "${test}" \
+      {watch-notconst.c watch-notconst2.S} {nodebug}] } {
+    return -1
+}
+
+if { ![runto f] } {
+    perror "Could not run to breakpoint `f'."
+    continue
+}
+
+gdb_test "watch x" ".*\[Ww\]atchpoint 2: x" "watch x"
diff --git a/gdb/testsuite/gdb.dwarf2/watch-notconst2.S b/gdb/testsuite/gdb.dwarf2/watch-notconst2.S
new file mode 100644
index 0000000..fb99314
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/watch-notconst2.S
@@ -0,0 +1,255 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2010 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* This source file was generated from watch-notconst2.c using the following
+   command line:
+
+   gcc -m32 -dA -S -g -O2 watch-notconst2.c -o watch-notconst2.S
+
+*/
+
+	.file	"watch-notconst2.c"
+	.section	.debug_abbrev,"",@progbits
+.Ldebug_abbrev0:
+	.section	.debug_info,"",@progbits
+.Ldebug_info0:
+	.section	.debug_line,"",@progbits
+.Ldebug_line0:
+	.text
+.Ltext0:
+	.cfi_sections	.debug_frame
+	.p2align 4,,15
+.globl f
+	.type	f, @function
+f:
+.LFB0:
+	.file 1 "watch-notconst2.c"
+	# watch-notconst2.c:30
+	.loc 1 30 0
+	.cfi_startproc
+.LVL0:
+	# basic block 2
+	pushl	%ebp
+	.cfi_def_cfa_offset 8
+	movl	%esp, %ebp
+	.cfi_offset 5, -8
+	.cfi_def_cfa_register 5
+	pushl	%ebx
+	subl	$20, %esp
+	# watch-notconst2.c:30
+	.loc 1 30 0
+	movl	8(%ebp), %ebx
+	.cfi_offset 3, -12
+	# watch-notconst2.c:32
+	.loc 1 32 0
+	movl	$2, (%esp)
+	call	g
+.LVL1:
+	# watch-notconst2.c:34
+	.loc 1 34 0
+	movl	%ebx, 8(%ebp)
+	# watch-notconst2.c:35
+	.loc 1 35 0
+	addl	$20, %esp
+	popl	%ebx
+	.cfi_restore 3
+	popl	%ebp
+	.cfi_restore 5
+	.cfi_def_cfa 4, 4
+.LVL2:
+	# watch-notconst2.c:34
+	.loc 1 34 0
+	jmp	g
+	.cfi_endproc
+.LFE0:
+	.size	f, .-f
+.Letext0:
+	.section	.debug_loc,"",@progbits
+.Ldebug_loc0:
+.LLST0:
+	.long	.LVL0-.Ltext0	# Location list begin address (*.LLST0)
+	.long	.LVL1-.Ltext0	# Location list end address (*.LLST0)
+	.value	0x2	# Location expression size
+	.byte	0x35	# DW_OP_lit5
+	.byte	0x9f	# DW_OP_stack_value
+	.long	.LVL1-.Ltext0	# Location list begin address (*.LLST0)
+	.long	.LVL2-.Ltext0	# Location list end address (*.LLST0)
+	.value	0x1	# Location expression size
+	.byte	0x53	# DW_OP_reg3
+	.long	0x0	# Location list terminator begin (*.LLST0)
+	.long	0x0	# Location list terminator end (*.LLST0)
+	.section	.debug_info
+	.long	0x5c	# Length of Compilation Unit Info
+	.value	0x3	# DWARF version number
+	.long	.Ldebug_abbrev0	# Offset Into Abbrev. Section
+	.byte	0x4	# Pointer Size (in bytes)
+	.uleb128 0x1	# (DIE (0xb) DW_TAG_compile_unit)
+	.long	.LASF0	# DW_AT_producer: "GNU C 4.4.3 20100127 (Red Hat 4.4.3-4)"
+	.byte	0x1	# DW_AT_language
+	.long	.LASF1	# DW_AT_name: "watch-notconst2.c"
+	.long	.LASF2	# DW_AT_comp_dir: "/home/sergio/work/src/git/gdb-src/gdb/testsuite/gdb.base"
+	.long	.Ltext0	# DW_AT_low_pc
+	.long	.Letext0	# DW_AT_high_pc
+	.long	.Ldebug_line0	# DW_AT_stmt_list
+	.uleb128 0x2	# (DIE (0x25) DW_TAG_subprogram)
+	.byte	0x1	# DW_AT_external
+	.ascii "f\0"	# DW_AT_name
+	.byte	0x1	# DW_AT_decl_file (watch-notconst2.c)
+	.byte	0x1d	# DW_AT_decl_line
+	.byte	0x1	# DW_AT_prototyped
+	.long	0x58	# DW_AT_type
+	.long	.LFB0	# DW_AT_low_pc
+	.long	.LFE0	# DW_AT_high_pc
+	.byte	0x1	# DW_AT_frame_base
+	.byte	0x9c	# DW_OP_call_frame_cfa
+	.long	0x58	# DW_AT_sibling
+	.uleb128 0x3	# (DIE (0x3e) DW_TAG_formal_parameter)
+	.ascii "i\0"	# DW_AT_name
+	.byte	0x1	# DW_AT_decl_file (watch-notconst2.c)
+	.byte	0x1d	# DW_AT_decl_line
+	.long	0x58	# DW_AT_type
+	.byte	0x2	# DW_AT_location
+	.byte	0x91	# DW_OP_fbreg
+	.sleb128 0
+	.uleb128 0x4	# (DIE (0x4a) DW_TAG_variable)
+	.ascii "x\0"	# DW_AT_name
+	.byte	0x1	# DW_AT_decl_file (watch-notconst2.c)
+	.byte	0x1f	# DW_AT_decl_line
+	.long	0x58	# DW_AT_type
+	.long	.LLST0	# DW_AT_location
+	.byte	0x0	# end of children of DIE 0x25
+	.uleb128 0x5	# (DIE (0x58) DW_TAG_base_type)
+	.byte	0x4	# DW_AT_byte_size
+	.byte	0x5	# DW_AT_encoding
+	.ascii "int\0"	# DW_AT_name
+	.byte	0x0	# end of children of DIE 0xb
+	.section	.debug_abbrev
+	.uleb128 0x1	# (abbrev code)
+	.uleb128 0x11	# (TAG: DW_TAG_compile_unit)
+	.byte	0x1	# DW_children_yes
+	.uleb128 0x25	# (DW_AT_producer)
+	.uleb128 0xe	# (DW_FORM_strp)
+	.uleb128 0x13	# (DW_AT_language)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3	# (DW_AT_name)
+	.uleb128 0xe	# (DW_FORM_strp)
+	.uleb128 0x1b	# (DW_AT_comp_dir)
+	.uleb128 0xe	# (DW_FORM_strp)
+	.uleb128 0x11	# (DW_AT_low_pc)
+	.uleb128 0x1	# (DW_FORM_addr)
+	.uleb128 0x12	# (DW_AT_high_pc)
+	.uleb128 0x1	# (DW_FORM_addr)
+	.uleb128 0x10	# (DW_AT_stmt_list)
+	.uleb128 0x6	# (DW_FORM_data4)
+	.byte	0x0
+	.byte	0x0
+	.uleb128 0x2	# (abbrev code)
+	.uleb128 0x2e	# (TAG: DW_TAG_subprogram)
+	.byte	0x1	# DW_children_yes
+	.uleb128 0x3f	# (DW_AT_external)
+	.uleb128 0xc	# (DW_FORM_flag)
+	.uleb128 0x3	# (DW_AT_name)
+	.uleb128 0x8	# (DW_FORM_string)
+	.uleb128 0x3a	# (DW_AT_decl_file)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3b	# (DW_AT_decl_line)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x27	# (DW_AT_prototyped)
+	.uleb128 0xc	# (DW_FORM_flag)
+	.uleb128 0x49	# (DW_AT_type)
+	.uleb128 0x13	# (DW_FORM_ref4)
+	.uleb128 0x11	# (DW_AT_low_pc)
+	.uleb128 0x1	# (DW_FORM_addr)
+	.uleb128 0x12	# (DW_AT_high_pc)
+	.uleb128 0x1	# (DW_FORM_addr)
+	.uleb128 0x40	# (DW_AT_frame_base)
+	.uleb128 0xa	# (DW_FORM_block1)
+	.uleb128 0x1	# (DW_AT_sibling)
+	.uleb128 0x13	# (DW_FORM_ref4)
+	.byte	0x0
+	.byte	0x0
+	.uleb128 0x3	# (abbrev code)
+	.uleb128 0x5	# (TAG: DW_TAG_formal_parameter)
+	.byte	0x0	# DW_children_no
+	.uleb128 0x3	# (DW_AT_name)
+	.uleb128 0x8	# (DW_FORM_string)
+	.uleb128 0x3a	# (DW_AT_decl_file)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3b	# (DW_AT_decl_line)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x49	# (DW_AT_type)
+	.uleb128 0x13	# (DW_FORM_ref4)
+	.uleb128 0x2	# (DW_AT_location)
+	.uleb128 0xa	# (DW_FORM_block1)
+	.byte	0x0
+	.byte	0x0
+	.uleb128 0x4	# (abbrev code)
+	.uleb128 0x34	# (TAG: DW_TAG_variable)
+	.byte	0x0	# DW_children_no
+	.uleb128 0x3	# (DW_AT_name)
+	.uleb128 0x8	# (DW_FORM_string)
+	.uleb128 0x3a	# (DW_AT_decl_file)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3b	# (DW_AT_decl_line)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x49	# (DW_AT_type)
+	.uleb128 0x13	# (DW_FORM_ref4)
+	.uleb128 0x2	# (DW_AT_location)
+	.uleb128 0x6	# (DW_FORM_data4)
+	.byte	0x0
+	.byte	0x0
+	.uleb128 0x5	# (abbrev code)
+	.uleb128 0x24	# (TAG: DW_TAG_base_type)
+	.byte	0x0	# DW_children_no
+	.uleb128 0xb	# (DW_AT_byte_size)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3e	# (DW_AT_encoding)
+	.uleb128 0xb	# (DW_FORM_data1)
+	.uleb128 0x3	# (DW_AT_name)
+	.uleb128 0x8	# (DW_FORM_string)
+	.byte	0x0
+	.byte	0x0
+	.byte	0x0
+	.section	.debug_pubnames,"",@progbits
+	.long	0x14	# Length of Public Names Info
+	.value	0x2	# DWARF Version
+	.long	.Ldebug_info0	# Offset of Compilation Unit Info
+	.long	0x60	# Compilation Unit Length
+	.long	0x25	# DIE offset
+	.ascii "f\0"	# external name
+	.long	0x0
+	.section	.debug_aranges,"",@progbits
+	.long	0x1c	# Length of Address Ranges Info
+	.value	0x2	# DWARF Version
+	.long	.Ldebug_info0	# Offset of Compilation Unit Info
+	.byte	0x4	# Size of Address
+	.byte	0x0	# Size of Segment Descriptor
+	.value	0x0	# Pad to 8 byte boundary
+	.value	0x0
+	.long	.Ltext0	# Address
+	.long	.Letext0-.Ltext0	# Length
+	.long	0x0
+	.long	0x0
+	.section	.debug_str,"MS",@progbits,1
+.LASF1:
+	.string	"watch-notconst2.c"
+.LASF2:
+	.string	""
+.LASF0:
+	.string	"GNU C 4.4.3 20100127 (Red Hat 4.4.3-4)"
+	.ident	"GCC: (GNU) 4.4.3 20100127 (Red Hat 4.4.3-4)"
+	.section	.note.GNU-stack,"",@progbits
diff --git a/gdb/testsuite/gdb.dwarf2/watch-notconst2.c b/gdb/testsuite/gdb.dwarf2/watch-notconst2.c
new file mode 100644
index 0000000..4a70f8d
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/watch-notconst2.c
@@ -0,0 +1,35 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2010 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* The original program corresponding to watch-notconst2.S.
+
+   This program is not compiled; the .S version is used instead.
+
+   The purpose of this test is to see if GDB can still watch the
+   variable `x' even when we compile the program using -O2
+   optimization.  */
+
+extern int g (int j);
+
+int
+f (int i)
+{
+  int x = 5;
+  g (2);
+  x = i;
+  return g (x);
+}


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]