Index: gdb/gdb/breakpoint.c
===================================================================
--- gdb.orig/gdb/breakpoint.c	2009-12-23 17:39:55.000000000 -0200
+++ gdb/gdb/breakpoint.c	2009-12-23 17:56:27.000000000 -0200
@@ -3174,7 +3174,6 @@ watchpoints_triggered (struct target_wai
 #define BP_TEMPFLAG 1
 #define BP_HARDWAREFLAG 2
 
-/* Check watchpoint condition.  */
 
 static int
 watchpoint_check (void *p)
@@ -3245,8 +3244,12 @@ watchpoint_check (void *p)
       struct value *new_val;
 
       fetch_watchpoint_value (b->exp, &new_val, NULL, NULL);
+
+      /* We use value_equal_contents instead of value_equal because the latter
+	 coerces an array to a pointer, thus comparing just the address of the
+	 array instead of its contents.  This is not what we want.  */
       if ((b->val != NULL) != (new_val != NULL)
-	  || (b->val != NULL && !value_equal (b->val, new_val)))
+	  || (b->val != NULL && !value_equal_contents (b->val, new_val)))
 	{
 	  if (new_val != NULL)
 	    {
Index: gdb/gdb/testsuite/gdb.base/watchpoint.c
===================================================================
--- gdb.orig/gdb/testsuite/gdb.base/watchpoint.c	2009-12-23 17:39:55.000000000 -0200
+++ gdb/gdb/testsuite/gdb.base/watchpoint.c	2009-12-23 17:40:03.000000000 -0200
@@ -30,7 +30,7 @@ int ival2 = -1;
 int ival3 = -1;
 int ival4 = -1;
 int ival5 = -1;
-char buf[10];
+char buf[30];
 struct foo
 {
   int val;
@@ -95,6 +95,7 @@ func3 ()
   x = 1;				/* second x assignment */
   y = 1;
   y = 2;
+  buf[26] = 3;
 }
 
 int
Index: gdb/gdb/testsuite/gdb.base/watchpoint.exp
===================================================================
--- gdb.orig/gdb/testsuite/gdb.base/watchpoint.exp	2009-12-23 17:39:55.000000000 -0200
+++ gdb/gdb/testsuite/gdb.base/watchpoint.exp	2009-12-23 17:40:03.000000000 -0200
@@ -678,6 +678,24 @@ proc test_inaccessible_watchpoint {} {
     }
 }
     
+proc test_watchpoint_in_big_blob {} {
+    global gdb_prompt
+
+    gdb_test "watch buf" ".*atchpoint \[0-9\]+: buf"
+    send_gdb "cont\n"
+    gdb_expect {
+	-re "Continuing.*\[Ww\]atchpoint.*buf.*Old value = .*$gdb_prompt $" {
+	    pass "watchpoint on buf hit"
+	}
+	-re "Continuing.*$gdb_prompt $" {
+	    fail "watchpoint on buf hit"
+	}
+	-re ".*$gdb_prompt $" { fail "watchpoint on buf hit" ; return }
+	timeout { fail "watchpoint on buf hit (timeout)" ; return }
+	eof { fail "watchpoint on buf hit (eof)" ; return }
+    }
+}
+
 # Start with a fresh gdb.
 
 gdb_exit
@@ -842,6 +860,8 @@ if [initialize] then {
     }
 
     test_watchpoint_and_breakpoint
+
+    test_watchpoint_in_big_blob
 }
 
 # Restore old timeout
Index: gdb/gdb/valarith.c
===================================================================
--- gdb.orig/gdb/valarith.c	2009-12-23 17:44:23.000000000 -0200
+++ gdb/gdb/valarith.c	2009-12-23 17:53:15.000000000 -0200
@@ -1397,6 +1397,24 @@ value_equal (struct value *arg1, struct 
     }
 }
 
+/* Compare values based on their raw contents. Useful for arrays since
+   value_equal coerces them to pointers, thus comparing just the address
+   of the array instead of its contents.  */
+
+int
+value_equal_contents (struct value *arg1, struct value *arg2)
+{
+  struct type *type1, *type2;
+
+  type1 = check_typedef (value_type (arg1));
+  type2 = check_typedef (value_type (arg2));
+
+  return (TYPE_CODE (type1) == TYPE_CODE (type2)
+	  && TYPE_LENGTH (type1) == TYPE_LENGTH (type2)
+	  && memcmp (value_contents (arg1), value_contents (arg2),
+		     TYPE_LENGTH (type1)) == 0);
+}
+
 /* Simulate the C operator < by returning 1
    iff ARG1's contents are less than ARG2's.  */
 
Index: gdb/gdb/value.h
===================================================================
--- gdb.orig/gdb/value.h	2009-12-23 17:53:47.000000000 -0200
+++ gdb/gdb/value.h	2009-12-23 17:58:36.000000000 -0200
@@ -563,6 +563,8 @@ extern struct internalvar *lookup_intern
 
 extern int value_equal (struct value *arg1, struct value *arg2);
 
+extern int value_equal_contents (struct value *arg1, struct value *arg2);
+
 extern int value_less (struct value *arg1, struct value *arg2);
 
 extern int value_logical_not (struct value *arg1);