* scripttempl/go32coff.sc: Don't put ${DATA_ALIGNMENT} inside an

[binutils.git] / gdb / breakpoint.c

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 457ca912cd2ea92c2b968ba7590434da7ebb2d37..c2abcd03f4b5a444eb592b7ccadbd01ff0db3745 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -90,7 +90,7 @@ static void
 watch_command PARAMS ((char *, int));
 
 static int
 watch_command PARAMS ((char *, int));
 
 static int

-can_use_hardware_watchpoint PARAMS ((struct breakpoint *));
+can_use_hardware_watchpoint PARAMS ((struct value *));

 
 static void
 tbreak_command PARAMS ((char *, int));
 
 static void
 tbreak_command PARAMS ((char *, int));


@@ -159,9 +159,18 @@ static int executing_breakpoint_commands;
 
 /* By default no support for hardware watchpoints is assumed.  */
 #ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT
 
 /* By default no support for hardware watchpoints is assumed.  */
 #ifndef TARGET_CAN_USE_HARDWARE_WATCHPOINT

-#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(B) 0
-#define target_remove_watchpoint(ADDR,LEN) -1
-#define target_insert_watchpoint(ADDR,LEN) -1
+#define TARGET_CAN_USE_HARDWARE_WATCHPOINT(TYPE,CNT,OTHERTYPE) 0
+#define target_remove_watchpoint(ADDR,LEN,TYPE) -1
+#define target_insert_watchpoint(ADDR,LEN,TYPE) -1
+#endif
+
+#ifndef target_insert_hw_breakpoint
+#define target_remove_hw_breakpoint(ADDR,SHADOW) -1
+#define target_insert_hw_breakpoint(ADDR,SHADOW) -1
+#endif
+
+#ifndef target_stopped_data_address
+#define target_stopped_data_address() 0

 #endif
 
 /* Chain of all breakpoints defined.  */
 #endif
 
 /* Chain of all breakpoints defined.  */


@@ -193,9 +202,6 @@ int default_breakpoint_valid;
 CORE_ADDR default_breakpoint_address;
 struct symtab *default_breakpoint_symtab;
 int default_breakpoint_line;
 CORE_ADDR default_breakpoint_address;
 struct symtab *default_breakpoint_symtab;
 int default_breakpoint_line;

-
-/* Flag indicating extra verbosity for xgdb.  */
-extern int xgdb_verbose;

 \f
 /* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
    Advance *PP after the string and any trailing whitespace.
 \f
 /* *PP is a string denoting a breakpoint.  Get the number of the breakpoint.
    Advance *PP after the string and any trailing whitespace.


@@ -335,6 +341,7 @@ End with a line saying just \"end\".\n", bnum);
        l = read_command_lines ();
        free_command_lines (&b->commands);
        b->commands = l;
        l = read_command_lines ();
        free_command_lines (&b->commands);
        b->commands = l;

+       breakpoints_changed ();

        return;
       }
   error ("No breakpoint number %d.", bnum);
        return;
       }
   error ("No breakpoint number %d.", bnum);


@@ -371,6 +378,8 @@ read_memory_nobpt (memaddr, myaddr, len)
     {
       if (b->type == bp_watchpoint
          || b->type == bp_hardware_watchpoint
     {
       if (b->type == bp_watchpoint
          || b->type == bp_hardware_watchpoint

+         || b->type == bp_read_watchpoint
+         || b->type == bp_access_watchpoint

          || !b->inserted)
        continue;
       else if (b->address + memory_breakpoint_size <= memaddr)
          || !b->inserted)
        continue;
       else if (b->address + memory_breakpoint_size <= memaddr)


@@ -450,11 +459,16 @@ insert_breakpoints ()
   ALL_BREAKPOINTS (b)
     if (b->type != bp_watchpoint
        && b->type != bp_hardware_watchpoint
   ALL_BREAKPOINTS (b)
     if (b->type != bp_watchpoint
        && b->type != bp_hardware_watchpoint

+       && b->type != bp_read_watchpoint
+       && b->type != bp_access_watchpoint

        && b->enable != disabled
        && ! b->inserted
        && ! b->duplicate)
       {
        && b->enable != disabled
        && ! b->inserted
        && ! b->duplicate)
       {

-       val = target_insert_breakpoint(b->address, b->shadow_contents);
+       if (b->type == bp_hardware_breakpoint)
+         val = target_insert_hw_breakpoint(b->address, b->shadow_contents);
+       else
+         val = target_insert_breakpoint(b->address, b->shadow_contents);

        if (val)
          {
            /* Can't set the breakpoint.  */
        if (val)
          {
            /* Can't set the breakpoint.  */


@@ -488,7 +502,9 @@ insert_breakpoints ()
        else
          b->inserted = 1;
       }
        else
          b->inserted = 1;
       }

-    else if (b->type == bp_hardware_watchpoint
+    else if ((b->type == bp_hardware_watchpoint ||
+             b->type == bp_read_watchpoint ||
+             b->type == bp_access_watchpoint)

             && b->enable == enabled
             && ! b->inserted
             && ! b->duplicate)
             && b->enable == enabled
             && ! b->inserted
             && ! b->duplicate)


@@ -530,11 +546,17 @@ insert_breakpoints ()
                /* If it's a memory location, then we must watch it.  */
                if (v->lval == lval_memory)
                  {
                /* If it's a memory location, then we must watch it.  */
                if (v->lval == lval_memory)
                  {

-                   int addr, len;
+                   int addr, len, type;

                    
                    addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
                    len = TYPE_LENGTH (VALUE_TYPE (v));
                    
                    addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
                    len = TYPE_LENGTH (VALUE_TYPE (v));

-                   val = target_insert_watchpoint (addr, len);
+                   type = 0;
+                    if (b->type == bp_read_watchpoint)
+                     type = 1;
+                   else if (b->type == bp_access_watchpoint)
+                     type = 2;
+
+                   val = target_insert_watchpoint (addr, len, type);

                    if (val == -1)
                      {
                        b->inserted = 0;
                    if (val == -1)
                      {
                        b->inserted = 0;


@@ -594,14 +616,21 @@ remove_breakpoint (b)
   int val;
   
   if (b->type != bp_watchpoint
   int val;
   
   if (b->type != bp_watchpoint

-      && b->type != bp_hardware_watchpoint)
+      && b->type != bp_hardware_watchpoint
+      && b->type != bp_read_watchpoint
+      && b->type != bp_access_watchpoint)

     {
     {

-      val = target_remove_breakpoint(b->address, b->shadow_contents);
+      if (b->type == bp_hardware_breakpoint)
+        val = target_remove_hw_breakpoint(b->address, b->shadow_contents);
+      else
+        val = target_remove_breakpoint(b->address, b->shadow_contents);

       if (val)
        return val;
       b->inserted = 0;
     }
       if (val)
        return val;
       b->inserted = 0;
     }

-  else if (b->type == bp_hardware_watchpoint
+  else if ((b->type == bp_hardware_watchpoint ||
+            b->type == bp_read_watchpoint ||
+           b->type == bp_access_watchpoint)

           && b->enable == enabled
           && ! b->duplicate)
     {
           && b->enable == enabled
           && ! b->duplicate)
     {


@@ -619,7 +648,7 @@ remove_breakpoint (b)
              
              addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
              len = TYPE_LENGTH (VALUE_TYPE (v));
              
              addr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
              len = TYPE_LENGTH (VALUE_TYPE (v));

-             val = target_remove_watchpoint (addr, len);
+             val = target_remove_watchpoint (addr, len, b->type);

              if (val == -1)
                b->inserted = 1;
              val = 0;
              if (val == -1)
                b->inserted = 1;
              val = 0;


@@ -676,7 +705,8 @@ breakpoint_init_inferior ()
        delete_breakpoint (b);
 
       /* Likewise for watchpoints on local expressions.  */
        delete_breakpoint (b);
 
       /* Likewise for watchpoints on local expressions.  */

-      if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
+      if ((b->type == bp_watchpoint || b->type == bp_hardware_watchpoint ||
+           b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)

          && b->exp_valid_block != NULL)
        delete_breakpoint (b);
     }
          && b->exp_valid_block != NULL)
        delete_breakpoint (b);
     }


@@ -926,22 +956,29 @@ print_it_normal (bs)
      which has since been deleted.  */
   if (bs->breakpoint_at == NULL
       || (bs->breakpoint_at->type != bp_breakpoint
      which has since been deleted.  */
   if (bs->breakpoint_at == NULL
       || (bs->breakpoint_at->type != bp_breakpoint

+         && bs->breakpoint_at->type != bp_hardware_breakpoint

          && bs->breakpoint_at->type != bp_watchpoint
          && bs->breakpoint_at->type != bp_watchpoint

+         && bs->breakpoint_at->type != bp_read_watchpoint
+         && bs->breakpoint_at->type != bp_access_watchpoint

          && bs->breakpoint_at->type != bp_hardware_watchpoint))
     return 0;
 
          && bs->breakpoint_at->type != bp_hardware_watchpoint))
     return 0;
 

-  if (bs->breakpoint_at->type == bp_breakpoint)
+  if (bs->breakpoint_at->type == bp_breakpoint ||
+      bs->breakpoint_at->type == bp_hardware_breakpoint)

     {
       /* I think the user probably only wants to see one breakpoint
         number, not all of them.  */
     {
       /* I think the user probably only wants to see one breakpoint
         number, not all of them.  */

+      annotate_breakpoint (bs->breakpoint_at->number);

       printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
       return 0;
     }
       printf_filtered ("\nBreakpoint %d, ", bs->breakpoint_at->number);
       return 0;
     }

-      
-  if (bs->old_val != NULL)
+  else if ((bs->old_val != NULL) &&
+       (bs->breakpoint_at->type == bp_watchpoint ||
+        bs->breakpoint_at->type == bp_access_watchpoint ||
+        bs->breakpoint_at->type == bp_hardware_watchpoint))

     {
     {

-      printf_filtered ("\nWatchpoint %d, ", bs->breakpoint_at->number);
-      print_expression (bs->breakpoint_at->exp, gdb_stdout);
+      annotate_watchpoint (bs->breakpoint_at->number);
+      mention (bs->breakpoint_at);

       printf_filtered ("\nOld value = ");
       value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
       printf_filtered ("\nNew value = ");
       printf_filtered ("\nOld value = ");
       value_print (bs->old_val, gdb_stdout, 0, Val_pretty_default);
       printf_filtered ("\nNew value = ");


@@ -953,6 +990,16 @@ print_it_normal (bs)
       /* More than one watchpoint may have been triggered.  */
       return -1;
     }
       /* More than one watchpoint may have been triggered.  */
       return -1;
     }

+  else if (bs->breakpoint_at->type == bp_access_watchpoint ||
+          bs->breakpoint_at->type == bp_read_watchpoint)
+    {
+      mention (bs->breakpoint_at);
+      printf_filtered ("\nValue = ");
+      value_print (bs->breakpoint_at->val, gdb_stdout, 0,
+                   Val_pretty_default);
+      printf_filtered ("\n");
+      return -1;
+    }

   /* We can't deal with it.  Maybe another member of the bpstat chain can.  */
   return -1;
 }
   /* We can't deal with it.  Maybe another member of the bpstat chain can.  */
   return -1;
 }


@@ -994,7 +1041,10 @@ static int
 breakpoint_cond_eval (exp)
      char *exp;
 {
 breakpoint_cond_eval (exp)
      char *exp;
 {

-  return !value_true (evaluate_expression ((struct expression *)exp));
+  value_ptr mark = value_mark ();
+  int i = !value_true (evaluate_expression ((struct expression *)exp));
+  value_free_to_mark (mark);
+  return i;

 }
 
 /* Allocate a new bpstat and chain it to the current one.  */
 }
 
 /* Allocate a new bpstat and chain it to the current one.  */


@@ -1161,6 +1211,9 @@ bpstat_stop_status (pc, frame_address, not_a_breakpoint)
   struct bpstat root_bs[1];
   /* Pointer to the last thing in the chain currently.  */
   bpstat bs = root_bs;
   struct bpstat root_bs[1];
   /* Pointer to the last thing in the chain currently.  */
   bpstat bs = root_bs;

+  static char message1[] =
+            "Error evaluating expression for watchpoint %d\n";
+  char message[sizeof (message1) + 30 /* slop */];

 
   /* Get the address where the breakpoint would have been.  */
   bp_addr = *pc - DECR_PC_AFTER_BREAK;
 
   /* Get the address where the breakpoint would have been.  */
   bp_addr = *pc - DECR_PC_AFTER_BREAK;


@@ -1172,11 +1225,23 @@ bpstat_stop_status (pc, frame_address, not_a_breakpoint)
 
       if (b->type != bp_watchpoint
          && b->type != bp_hardware_watchpoint
 
       if (b->type != bp_watchpoint
          && b->type != bp_hardware_watchpoint

+          && b->type != bp_read_watchpoint
+          && b->type != bp_access_watchpoint
+         && b->type != bp_hardware_breakpoint

          && b->address != bp_addr)
        continue;
 
          && b->address != bp_addr)
        continue;
 

+#ifndef DECR_PC_AFTER_HW_BREAK
+#define DECR_PC_AFTER_HW_BREAK 0
+#endif
+      if (b->type == bp_hardware_breakpoint
+         && b->address != (bp_addr - DECR_PC_AFTER_HW_BREAK))
+       continue;
+

       if (b->type != bp_watchpoint
          && b->type != bp_hardware_watchpoint
       if (b->type != bp_watchpoint
          && b->type != bp_hardware_watchpoint

+         && b->type != bp_read_watchpoint
+         && b->type != bp_access_watchpoint

          && not_a_breakpoint)
        continue;
 
          && not_a_breakpoint)
        continue;
 


@@ -1187,12 +1252,9 @@ bpstat_stop_status (pc, frame_address, not_a_breakpoint)
       bs->stop = 1;
       bs->print = 1;
 
       bs->stop = 1;
       bs->print = 1;
 

+      sprintf (message, message1, b->number);

       if (b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
        {
       if (b->type == bp_watchpoint || b->type == bp_hardware_watchpoint)
        {

-         static char message1[] =
-           "Error evaluating expression for watchpoint %d\n";
-         char message[sizeof (message1) + 30 /* slop */];
-         sprintf (message, message1, b->number);

          switch (catch_errors (watchpoint_check, (char *) bs, message,
                                RETURN_MASK_ALL))
            {
          switch (catch_errors (watchpoint_check, (char *) bs, message,
                                RETURN_MASK_ALL))
            {


@@ -1225,6 +1287,51 @@ bpstat_stop_status (pc, frame_address, not_a_breakpoint)
              break;
            }
        }
              break;
            }
        }

+      else if (b->type == bp_read_watchpoint || b->type == bp_access_watchpoint)
+        {
+         CORE_ADDR addr;
+         value_ptr v;
+          int found = 0;
+
+         addr = target_stopped_data_address();
+         if (addr == 0) continue;
+          for (v = b->val_chain; v; v = v->next)
+            {
+              if (v->lval == lval_memory)
+                {
+                  CORE_ADDR vaddr;
+
+                  vaddr = VALUE_ADDRESS (v) + VALUE_OFFSET (v);
+                 if (addr == vaddr)
+                   found = 1;
+                }
+            }
+         if (found) 
+           switch (catch_errors (watchpoint_check, (char *) bs, message,
+                        RETURN_MASK_ALL))
+             {
+                case WP_DELETED:
+                  /* We've already printed what needs to be printed.  */
+                  bs->print_it = print_it_done;
+                  /* Stop.  */
+                  break;
+                case WP_VALUE_CHANGED:
+                case WP_VALUE_NOT_CHANGED:
+                  /* Stop.  */
+                  break;
+                default:
+                  /* Can't happen.  */
+                case 0:
+                  /* Error from catch_errors.  */
+                  printf_filtered ("Watchpoint %d deleted.\n", b->number);
+                  if (b->related_breakpoint)
+                    delete_breakpoint (b->related_breakpoint);
+                  delete_breakpoint (b);
+                  /* We've already printed what needs to be printed.  */
+                  bs->print_it = print_it_done;
+                  break;
+             }
+        }

 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
       else
        real_breakpoint = 1;
 #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
       else
        real_breakpoint = 1;


@@ -1296,8 +1403,10 @@ bpstat_stop_status (pc, frame_address, not_a_breakpoint)
 
   /* The value of a hardware watchpoint hasn't changed, but the
      intermediate memory locations we are watching may have.  */
 
   /* The value of a hardware watchpoint hasn't changed, but the
      intermediate memory locations we are watching may have.  */

-  if (bs && ! bs->stop
-      && bs->breakpoint_at->type == bp_hardware_watchpoint)
+  if (bs && ! bs->stop &&
+      (bs->breakpoint_at->type == bp_hardware_watchpoint ||
+       bs->breakpoint_at->type == bp_read_watchpoint ||
+       bs->breakpoint_at->type == bp_access_watchpoint))

     {
       remove_breakpoints ();
       insert_breakpoints ();
     {
       remove_breakpoints ();
       insert_breakpoints ();


@@ -1419,6 +1528,7 @@ bpstat_what (bs)
       switch (bs->breakpoint_at->type)
        {
        case bp_breakpoint:
       switch (bs->breakpoint_at->type)
        {
        case bp_breakpoint:

+       case bp_hardware_breakpoint:

        case bp_until:
        case bp_finish:
          if (bs->stop)
        case bp_until:
        case bp_finish:
          if (bs->stop)


@@ -1433,6 +1543,8 @@ bpstat_what (bs)
          break;
        case bp_watchpoint:
        case bp_hardware_watchpoint:
          break;
        case bp_watchpoint:
        case bp_hardware_watchpoint:

+       case bp_read_watchpoint:
+       case bp_access_watchpoint:

          if (bs->stop)
            {
              if (bs->print)
          if (bs->stop)
            {
              if (bs->print)


@@ -1508,8 +1620,10 @@ breakpoint_1 (bnum, allflag)
   register struct symbol *sym;
   CORE_ADDR last_addr = (CORE_ADDR)-1;
   int found_a_breakpoint = 0;
   register struct symbol *sym;
   CORE_ADDR last_addr = (CORE_ADDR)-1;
   int found_a_breakpoint = 0;

-  static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
-                             "hardware watchpoint", "longjmp",
+  static char *bptypes[] = {"breakpoint", "hw breakpoint",
+                             "until", "finish", "watchpoint",
+                             "hw watchpoint", "read watchpoint",
+                             "acc watchpoint", "longjmp",

                              "longjmp resume", "step resume",
                              "watchpoint scope", "call dummy" };
   static char *bpdisps[] = {"del", "dis", "keep"};
                              "longjmp resume", "step resume",
                              "watchpoint scope", "call dummy" };
   static char *bpdisps[] = {"del", "dis", "keep"};


@@ -1523,19 +1637,46 @@ breakpoint_1 (bnum, allflag)
 /*  We only print out user settable breakpoints unless the allflag is set. */
        if (!allflag
            && b->type != bp_breakpoint
 /*  We only print out user settable breakpoints unless the allflag is set. */
        if (!allflag
            && b->type != bp_breakpoint

+           && b->type != bp_hardware_breakpoint

            && b->type != bp_watchpoint
            && b->type != bp_watchpoint

+           && b->type != bp_read_watchpoint
+           && b->type != bp_access_watchpoint

            && b->type != bp_hardware_watchpoint)
          continue;
 
        if (!found_a_breakpoint++)
            && b->type != bp_hardware_watchpoint)
          continue;
 
        if (!found_a_breakpoint++)

-         printf_filtered ("Num Type           Disp Enb %sWhat\n",
-                          addressprint ? "Address    " : "");
-
-       printf_filtered ("%-3d %-14s %-4s %-3c ",
-                        b->number,
-                        bptypes[(int)b->type],
-                        bpdisps[(int)b->disposition],
-                        bpenables[(int)b->enable]);
+         {
+            annotate_breakpoints_headers ();
+  
+            annotate_field (0);
+            printf_filtered ("Num ");
+            annotate_field (1);
+            printf_filtered ("Type           ");
+            annotate_field (2);
+            printf_filtered ("Disp ");
+            annotate_field (3);
+            printf_filtered ("Enb ");
+            if (addressprint)
+              {
+                annotate_field (4);
+                printf_filtered ("Address    ");
+              }
+            annotate_field (5);
+            printf_filtered ("What\n");
+  
+            annotate_breakpoints_table ();
+          }
+  
+        annotate_record ();
+        annotate_field (0);
+        printf_filtered ("%-3d ", b->number);
+        annotate_field (1);
+        printf_filtered ("%-14s ", bptypes[(int)b->type]);
+        annotate_field (2);
+        printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);
+        annotate_field (3);
+       printf_filtered ("%-3c ", bpenables[(int)b->enable]);
+

        strcpy (wrap_indent, "                           ");
        if (addressprint)
          strcat (wrap_indent, "           ");
        strcpy (wrap_indent, "                           ");
        if (addressprint)
          strcat (wrap_indent, "           ");


@@ -1543,10 +1684,18 @@ breakpoint_1 (bnum, allflag)
          {
          case bp_watchpoint:
          case bp_hardware_watchpoint:
          {
          case bp_watchpoint:
          case bp_hardware_watchpoint:

+         case bp_read_watchpoint:
+         case bp_access_watchpoint:
+           /* Field 4, the address, is omitted (which makes the columns
+              not line up too nicely with the headers, but the effect
+              is relatively readable).  */
+           if (annotation_level > 1)
+             printf_filtered ("\n\032\032field 5\n");

            print_expression (b->exp, gdb_stdout);
            break;
 
          case bp_breakpoint:
            print_expression (b->exp, gdb_stdout);
            break;
 
          case bp_breakpoint:

+         case bp_hardware_breakpoint:

          case bp_until:
          case bp_finish:
          case bp_longjmp:
          case bp_until:
          case bp_finish:
          case bp_longjmp:


@@ -1556,7 +1705,17 @@ breakpoint_1 (bnum, allflag)
          case bp_watchpoint_scope:
          case bp_call_dummy:
            if (addressprint)
          case bp_watchpoint_scope:
          case bp_call_dummy:
            if (addressprint)

-             printf_filtered ("%s ", local_hex_string_custom ((unsigned long) b->address, "08l"));
+             {
+               annotate_field (4);
+               /* FIXME-32x64: need a print_address_numeric with
+                   field width */
+               printf_filtered
+                 ("%s ",
+                  local_hex_string_custom
+                  ((unsigned long) b->address, "08l"));
+             }
+
+           annotate_field (5);

 
            last_addr = b->address;
            if (b->source_file)
 
            last_addr = b->address;
            if (b->source_file)


@@ -1581,26 +1740,41 @@ breakpoint_1 (bnum, allflag)
 
        if (b->frame)
          {
 
        if (b->frame)
          {

+            annotate_field (6);
+

            printf_filtered ("\tstop only in stack frame at ");
            printf_filtered ("\tstop only in stack frame at ");

-           print_address_numeric (b->frame, gdb_stdout);
+           print_address_numeric (b->frame, 1, gdb_stdout);

            printf_filtered ("\n");
          }
            printf_filtered ("\n");
          }

+

        if (b->cond)
          {
        if (b->cond)
          {

+            annotate_field (7);
+

            printf_filtered ("\tstop only if ");
            print_expression (b->cond, gdb_stdout);
            printf_filtered ("\n");
          }
            printf_filtered ("\tstop only if ");
            print_expression (b->cond, gdb_stdout);
            printf_filtered ("\n");
          }

+

        if (b->ignore_count)
        if (b->ignore_count)

-         printf_filtered ("\tignore next %d hits\n", b->ignore_count);
+         {
+            annotate_field (8);
+
+           printf_filtered ("\tignore next %d hits\n", b->ignore_count);
+         }
+

        if ((l = b->commands))
        if ((l = b->commands))

-         while (l)
-           {
-             fputs_filtered ("\t", gdb_stdout);
-             fputs_filtered (l->line, gdb_stdout);
-             fputs_filtered ("\n", gdb_stdout);
-             l = l->next;
-           }
+         {
+            annotate_field (9);
+
+           while (l)
+             {
+               fputs_filtered ("\t", gdb_stdout);
+               fputs_filtered (l->line, gdb_stdout);
+               fputs_filtered ("\n", gdb_stdout);
+               l = l->next;
+             }
+         }

       }
 
   if (!found_a_breakpoint)
       }
 
   if (!found_a_breakpoint)


@@ -1615,6 +1789,8 @@ breakpoint_1 (bnum, allflag)
        that a comparison of an unsigned with -1 is always false.  */
     if (last_addr != (CORE_ADDR)-1)
       set_next_address (last_addr);
        that a comparison of an unsigned with -1 is always false.  */
     if (last_addr != (CORE_ADDR)-1)
       set_next_address (last_addr);

+
+  annotate_breakpoints_table_end ();

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */


@@ -1675,7 +1851,7 @@ describe_other_breakpoints (pc)
               (others > 1) ? "," : ((others == 1) ? " and" : ""));
          }
       printf_filtered ("also set at pc ");
               (others > 1) ? "," : ((others == 1) ? " and" : ""));
          }
       printf_filtered ("also set at pc ");

-      print_address_numeric (pc, gdb_stdout);
+      print_address_numeric (pc, 1, gdb_stdout);

       printf_filtered (".\n");
     }
 }
       printf_filtered (".\n");
     }
 }


@@ -1766,6 +1942,7 @@ set_raw_breakpoint (sal)
     }
 
   check_duplicates (sal.pc);
     }
 
   check_duplicates (sal.pc);

+  breakpoints_changed ();

 
   return b;
 }
 
   return b;
 }


@@ -1837,6 +2014,45 @@ disable_longjmp_breakpoint()
       }
 }
 
       }
 }
 

+int
+hw_breakpoint_used_count()
+{
+  register struct breakpoint *b;
+  int i = 0;
+
+  ALL_BREAKPOINTS (b)
+    {
+      if (b->type == bp_hardware_breakpoint && b->enable == enabled)
+       i++;
+    }
+
+  return i;
+}
+
+int
+hw_watchpoint_used_count(type, other_type_used)
+    enum bptype type;
+    int *other_type_used;
+{
+  register struct breakpoint *b;
+  int i = 0;
+
+  *other_type_used = 0;
+  ALL_BREAKPOINTS (b)
+    {
+      if (b->enable == enabled)
+       {
+          if (b->type == type) i++;
+          else if ((b->type == bp_hardware_watchpoint ||
+              b->type == bp_read_watchpoint ||
+              b->type == bp_access_watchpoint)
+              && b->enable == enabled)
+           *other_type_used = 1;
+        }
+    }
+  return i;
+}
+

 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
    breakpoint at the target of the jmp_buf.
 
 /* Call this after hitting the longjmp() breakpoint.  Use this to set a new
    breakpoint at the target of the jmp_buf.
 


@@ -1913,9 +2129,24 @@ mention (b)
       printf_filtered ("Hardware watchpoint %d: ", b->number);
       print_expression (b->exp, gdb_stdout);
       break;
       printf_filtered ("Hardware watchpoint %d: ", b->number);
       print_expression (b->exp, gdb_stdout);
       break;

+    case bp_read_watchpoint:
+      printf_filtered ("Hardware read watchpoint %d: ", b->number);
+      print_expression (b->exp, gdb_stdout);
+      break;
+    case bp_access_watchpoint:
+      printf_filtered ("Hardware access(read/write) watchpoint %d: ",b->number);
+      print_expression (b->exp, gdb_stdout);
+      break;

     case bp_breakpoint:
       printf_filtered ("Breakpoint %d at ", b->number);
     case bp_breakpoint:
       printf_filtered ("Breakpoint %d at ", b->number);

-      print_address_numeric (b->address, gdb_stdout);
+      print_address_numeric (b->address, 1, gdb_stdout);
+      if (b->source_file)
+       printf_filtered (": file %s, line %d.",
+                        b->source_file, b->line_number);
+      break;
+    case bp_hardware_breakpoint:
+      printf_filtered ("Hardware assisted breakpoint %d at ", b->number);
+      print_address_numeric (b->address, 1, gdb_stdout);

       if (b->source_file)
        printf_filtered (": file %s, line %d.",
                         b->source_file, b->line_number);
       if (b->source_file)
        printf_filtered (": file %s, line %d.",
                         b->source_file, b->line_number);


@@ -1972,13 +2203,15 @@ set_breakpoint (s, line, tempflag, addr_string)
 #endif /* 0 */
 \f
 /* Set a breakpoint according to ARG (function, linenum or *address)
 #endif /* 0 */
 \f
 /* Set a breakpoint according to ARG (function, linenum or *address)

-   and make it temporary if TEMPFLAG is nonzero. */
+   flag: first bit  : 0 non-temporary, 1 temporary.
+        second bit : 0 normal breakpoint, 1 hardware breakpoint. */

 
 static void
 
 static void

-break_command_1 (arg, tempflag, from_tty)
+break_command_1 (arg, flag, from_tty)

      char *arg;
      char *arg;

-     int tempflag, from_tty;
+     int flag, from_tty;

 {
 {

+  int tempflag, hardwareflag;

   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   register struct expression *cond = 0;
   struct symtabs_and_lines sals;
   struct symtab_and_line sal;
   register struct expression *cond = 0;


@@ -1997,6 +2230,9 @@ break_command_1 (arg, tempflag, from_tty)
   int i;
   int thread;
 
   int i;
   int thread;
 

+  hardwareflag = flag & 2;
+  tempflag = flag & 1;
+

   sals.sals = NULL;
   sals.nelts = 0;
 
   sals.sals = NULL;
   sals.nelts = 0;
 


@@ -2104,6 +2340,17 @@ break_command_1 (arg, tempflag, from_tty)
            error ("Junk at end of arguments.");
        }
     }
            error ("Junk at end of arguments.");
        }
     }

+  if (hardwareflag)
+    {
+      int i, other_type_used, target_resources_ok;
+      i = hw_breakpoint_used_count();  
+      target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
+               bp_hardware_breakpoint, i+sals.nelts, 0);
+      if (target_resources_ok == 0)
+       error ("No hardware breakpoint support in the target.");
+      else if (target_resources_ok < 0)
+        error ("Hardware breakpoints used exceeds limit.");
+    }

 
   /* Remove the canonical strings from the cleanup, they are needed below.  */
   if (canonical != (char **)NULL)
 
   /* Remove the canonical strings from the cleanup, they are needed below.  */
   if (canonical != (char **)NULL)


@@ -2120,7 +2367,7 @@ break_command_1 (arg, tempflag, from_tty)
       b = set_raw_breakpoint (sal);
       set_breakpoint_count (breakpoint_count + 1);
       b->number = breakpoint_count;
       b = set_raw_breakpoint (sal);
       set_breakpoint_count (breakpoint_count + 1);
       b->number = breakpoint_count;

-      b->type = bp_breakpoint;
+      b->type = hardwareflag ? bp_hardware_breakpoint : bp_breakpoint;

       b->cond = cond;
       b->thread = thread;
 
       b->cond = cond;
       b->thread = thread;
 


@@ -2165,6 +2412,8 @@ resolve_sal_pc (sal)
     }
 }
 
     }
 }
 

+#define BP_TEMPFLAG 1
+#define BP_HARDWAREFLAG 2

 void
 break_command (arg, from_tty)
      char *arg;
 void
 break_command (arg, from_tty)
      char *arg;


@@ -2178,21 +2427,50 @@ tbreak_command (arg, from_tty)
      char *arg;
      int from_tty;
 {
      char *arg;
      int from_tty;
 {

-  break_command_1 (arg, 1, from_tty);
+  break_command_1 (arg, BP_TEMPFLAG, from_tty);
+}
+
+static void
+hbreak_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  break_command_1 (arg, BP_HARDWAREFLAG, from_tty);
+}
+
+static void
+thbreak_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  break_command_1 (arg, (BP_TEMPFLAG | BP_HARDWAREFLAG), from_tty);

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */

+/* accessflag:  0: watch write, 1: watch read, 2: watch access(read or write)
+*/

 static void
 static void

-watch_command (arg, from_tty)
+watch_command_1 (arg, accessflag, from_tty)

      char *arg;
      char *arg;

+     int accessflag;

      int from_tty;
 {
   struct breakpoint *b;
   struct symtab_and_line sal;
   struct expression *exp;
   struct block *exp_valid_block;
      int from_tty;
 {
   struct breakpoint *b;
   struct symtab_and_line sal;
   struct expression *exp;
   struct block *exp_valid_block;

-  struct value *val;
+  struct value *val, *mark;

   FRAME frame, prev_frame;
   FRAME frame, prev_frame;

+  char *exp_start = NULL;
+  char *exp_end = NULL;
+  char *tok, *end_tok;
+  int toklen;
+  char *cond_start = NULL;
+  char *cond_end = NULL;
+  struct expression *cond = NULL;
+  int i, other_type_used, target_resources_ok;
+  enum bptype bp_type;
+  int mem_cnt = 0;

 
   sal.pc = 0;
   sal.symtab = NULL;
 
   sal.pc = 0;
   sal.symtab = NULL;


@@ -2200,13 +2478,51 @@ watch_command (arg, from_tty)
   
   /* Parse arguments.  */
   innermost_block = NULL;
   
   /* Parse arguments.  */
   innermost_block = NULL;

-  exp = parse_expression (arg);
+  exp_start = arg;
+  exp = parse_exp_1 (&arg, 0, 0);
+  exp_end = arg;

   exp_valid_block = innermost_block;
   exp_valid_block = innermost_block;

+  mark = value_mark ();

   val = evaluate_expression (exp);
   release_value (val);
   if (VALUE_LAZY (val))
     value_fetch_lazy (val);
 
   val = evaluate_expression (exp);
   release_value (val);
   if (VALUE_LAZY (val))
     value_fetch_lazy (val);
 

+  tok = arg;
+  while (*tok == ' ' || *tok == '\t')
+    tok++;
+  end_tok = tok;
+
+  while (*end_tok != ' ' && *end_tok != '\t' && *end_tok != '\000')
+    end_tok++;
+
+  toklen = end_tok - tok;
+  if (toklen >= 1 && strncmp (tok, "if", toklen) == 0)
+    {
+      tok = cond_start = end_tok + 1;
+      cond = parse_exp_1 (&tok, 0, 0);
+      cond_end = tok;
+    }
+  if (*tok)
+    error("Junk at end of command.");
+
+  if (accessflag == 1) bp_type = bp_read_watchpoint;
+  else if (accessflag == 2) bp_type = bp_access_watchpoint;
+  else bp_type = bp_hardware_watchpoint;
+
+  mem_cnt = can_use_hardware_watchpoint (val);
+  if (mem_cnt == 0 && bp_type != bp_hardware_watchpoint)
+    error ("Expression cannot be implemented with read/access watchpoint.");
+  if (mem_cnt != 0) { 
+    i = hw_watchpoint_used_count (bp_type, &other_type_used);
+    target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
+               bp_type, i + mem_cnt, other_type_used);
+    if (target_resources_ok == 0 && bp_type != bp_hardware_watchpoint)
+      error ("Target does not have this type of hardware watchpoint support.");
+    if (target_resources_ok < 0 && bp_type != bp_hardware_watchpoint)
+      error ("Target resources have been allocated for other types of watchpoints.");
+  }
+  

   /* Now set up the breakpoint.  */
   b = set_raw_breakpoint (sal);
   set_breakpoint_count (breakpoint_count + 1);
   /* Now set up the breakpoint.  */
   b = set_raw_breakpoint (sal);
   set_breakpoint_count (breakpoint_count + 1);


@@ -2214,11 +2530,14 @@ watch_command (arg, from_tty)
   b->disposition = donttouch;
   b->exp = exp;
   b->exp_valid_block = exp_valid_block;
   b->disposition = donttouch;
   b->exp = exp;
   b->exp_valid_block = exp_valid_block;

+  b->exp_string = savestring (exp_start, exp_end - exp_start);

   b->val = val;
   b->val = val;

-  b->cond = 0;
-  b->cond_string = NULL;
-  b->exp_string = savestring (arg, strlen (arg));
-
+  b->cond = cond;
+  if (cond_start)
+    b->cond_string = savestring (cond_start, cond_end - cond_start);
+  else
+    b->cond_string = 0;
+         

   frame = block_innermost_frame (exp_valid_block);
   if (frame)
     {
   frame = block_innermost_frame (exp_valid_block);
   if (frame)
     {


@@ -2226,10 +2545,10 @@ watch_command (arg, from_tty)
       b->watchpoint_frame = FRAME_FP (frame);
     }
   else
       b->watchpoint_frame = FRAME_FP (frame);
     }
   else

-    b->watchpoint_frame = NULL;
+    b->watchpoint_frame = (CORE_ADDR)0;

 
 

-  if (can_use_hardware_watchpoint (b))
-    b->type = bp_hardware_watchpoint;
+  if (mem_cnt && target_resources_ok > 0)
+    b->type = bp_type;

   else
     b->type = bp_watchpoint;
 
   else
     b->type = bp_watchpoint;
 


@@ -2268,41 +2587,59 @@ watch_command (arg, from_tty)
          b->related_breakpoint = scope_breakpoint;
        }
     }
          b->related_breakpoint = scope_breakpoint;
        }
     }

-
+  value_free_to_mark (mark);

   mention (b);
 }
 
   mention (b);
 }
 

-/* Return nonzero if the watchpoint described by B can be handled
-   completely in hardware.  If the watchpoint can not be handled
+/* Return count of locations need to be watched and can be handled
+   in hardware.  If the watchpoint can not be handled

    in hardware return zero.  */
 
 static int
    in hardware return zero.  */
 
 static int

-can_use_hardware_watchpoint (b)
-     struct breakpoint *b;
+can_use_hardware_watchpoint (v)
+     struct value *v;

 {
 {

-  value_ptr mark = value_mark ();
-  value_ptr v = evaluate_expression (b->exp);
-  int found_memory = 0;
+  int found_memory_cnt = 0;

        
   /* Make sure all the intermediate values are in memory.  Also make sure
      we found at least one memory expression.  Guards against watch 0x12345,
      which is meaningless, but could cause errors if one tries to insert a 
      hardware watchpoint for the constant expression.  */
        
   /* Make sure all the intermediate values are in memory.  Also make sure
      we found at least one memory expression.  Guards against watch 0x12345,
      which is meaningless, but could cause errors if one tries to insert a 
      hardware watchpoint for the constant expression.  */

-  for ( ; v != mark; v = v->next)
+  for ( ; v; v = v->next)

     {
     {

-      if (!(v->lval == lval_memory)
-         || v->lval == not_lval
-         || (v->lval != not_lval
-             && v->modifiable == false))
+      if (v->lval == lval_memory)
+       {
+         if (TYPE_LENGTH (VALUE_TYPE (v)) <= REGISTER_SIZE)
+           found_memory_cnt++;
+        }
+      else if (v->lval != not_lval && v->modifiable == 0)

        return 0;
        return 0;

-      else
-       if (v->lval == lval_memory)
-         found_memory = 1;

     }
 
   /* The expression itself looks suitable for using a hardware
      watchpoint, but give the target machine a chance to reject it.  */
     }
 
   /* The expression itself looks suitable for using a hardware
      watchpoint, but give the target machine a chance to reject it.  */

-  return found_memory && TARGET_CAN_USE_HARDWARE_WATCHPOINT (b);
+  return found_memory_cnt;
+}
+
+static void watch_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  watch_command_1 (arg, 0, from_tty);
+}
+
+static void rwatch_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  watch_command_1 (arg, 1, from_tty);
+}
+
+static void awatch_command (arg, from_tty)
+     char *arg;
+     int from_tty;
+{
+  watch_command_1 (arg, 2, from_tty);

 }
 
 \f
 }
 
 \f


@@ -2748,6 +3085,8 @@ clear_command (arg, from_tty)
        while (b->next
               && b->next->type != bp_watchpoint
               && b->next->type != bp_hardware_watchpoint
        while (b->next
               && b->next->type != bp_watchpoint
               && b->next->type != bp_hardware_watchpoint

+              && b->next->type != bp_read_watchpoint
+              && b->next->type != bp_access_watchpoint

               && (sal.pc
                   ? b->next->address == sal.pc
                   : (b->next->source_file != NULL
               && (sal.pc
                   ? b->next->address == sal.pc
                   : (b->next->source_file != NULL


@@ -2771,6 +3110,7 @@ clear_command (arg, from_tty)
 
       if (found->next) from_tty = 1; /* Always report if deleted more than one */
       if (from_tty) printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");
 
       if (found->next) from_tty = 1; /* Always report if deleted more than one */
       if (from_tty) printf_unfiltered ("Deleted breakpoint%s ", found->next ? "s" : "");

+      breakpoints_changed ();

       while (found)
        {
          if (from_tty) printf_unfiltered ("%d ", found->number);
       while (found)
        {
          if (from_tty) printf_unfiltered ("%d ", found->number);


@@ -2822,7 +3162,9 @@ delete_breakpoint (bpt)
   /* If this breakpoint was inserted, and there is another breakpoint
      at the same address, we need to insert the other breakpoint.  */
   if (bpt->inserted
   /* If this breakpoint was inserted, and there is another breakpoint
      at the same address, we need to insert the other breakpoint.  */
   if (bpt->inserted

-      && bpt->type != bp_hardware_watchpoint)
+      && bpt->type != bp_hardware_watchpoint
+      && bpt->type != bp_read_watchpoint
+      && bpt->type != bp_access_watchpoint)

     {
       ALL_BREAKPOINTS (b)
        if (b->address == bpt->address
     {
       ALL_BREAKPOINTS (b)
        if (b->address == bpt->address


@@ -2854,11 +3196,7 @@ delete_breakpoint (bpt)
   if (bpt->source_file != NULL)
     free (bpt->source_file);
 
   if (bpt->source_file != NULL)
     free (bpt->source_file);
 

-  if (xgdb_verbose && bpt->type == bp_breakpoint)
-    {
-      target_terminal_ours_for_output ();
-      printf_unfiltered ("breakpoint #%d deleted\n", bpt->number);
-    }
+  breakpoints_changed ();

 
   /* Be sure no bpstat's are pointing at it after it's been freed.  */
   /* FIXME, how can we find all bpstat's?
 
   /* Be sure no bpstat's are pointing at it after it's been freed.  */
   /* FIXME, how can we find all bpstat's?


@@ -2899,6 +3237,7 @@ breakpoint_re_set_one (bint)
      char *bint;
 {
   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */
      char *bint;
 {
   struct breakpoint *b = (struct breakpoint *)bint;  /* get past catch_errs */

+  struct value *mark;

   int i;
   struct symtabs_and_lines sals;
   char *s;
   int i;
   struct symtabs_and_lines sals;
   char *s;


@@ -2907,6 +3246,7 @@ breakpoint_re_set_one (bint)
   switch (b->type)
     {
     case bp_breakpoint:
   switch (b->type)
     {
     case bp_breakpoint:

+    case bp_hardware_breakpoint:

       if (b->addr_string == NULL)
        {
          /* Anything without a string can't be re-set. */
       if (b->addr_string == NULL)
        {
          /* Anything without a string can't be re-set. */


@@ -2962,6 +3302,10 @@ breakpoint_re_set_one (bint)
              check_duplicates (b->address);
 
              mention (b);
              check_duplicates (b->address);
 
              mention (b);

+
+             /* Might be better to do this just once per breakpoint_re_set,
+                rather than once for every breakpoint.  */
+             breakpoints_changed ();

            }
          b->enable = save_enable;      /* Restore it, this worked. */
        }
            }
          b->enable = save_enable;      /* Restore it, this worked. */
        }


@@ -2970,6 +3314,8 @@ breakpoint_re_set_one (bint)
 
     case bp_watchpoint:
     case bp_hardware_watchpoint:
 
     case bp_watchpoint:
     case bp_hardware_watchpoint:

+    case bp_read_watchpoint:
+    case bp_access_watchpoint:

       innermost_block = NULL;
       /* The issue arises of what context to evaluate this in.  The same
         one as when it was set, but what does that mean when symbols have
       innermost_block = NULL;
       /* The issue arises of what context to evaluate this in.  The same
         one as when it was set, but what does that mean when symbols have


@@ -2981,6 +3327,7 @@ breakpoint_re_set_one (bint)
       /* So for now, just use a global context.  */
       b->exp = parse_expression (b->exp_string);
       b->exp_valid_block = innermost_block;
       /* So for now, just use a global context.  */
       b->exp = parse_expression (b->exp_string);
       b->exp_valid_block = innermost_block;

+      mark = value_mark ();

       b->val = evaluate_expression (b->exp);
       release_value (b->val);
       if (VALUE_LAZY (b->val))
       b->val = evaluate_expression (b->exp);
       release_value (b->val);
       if (VALUE_LAZY (b->val))


@@ -2993,6 +3340,7 @@ breakpoint_re_set_one (bint)
        }
       if (b->enable == enabled)
        mention (b);
        }
       if (b->enable == enabled)
        mention (b);

+      value_free_to_mark (mark);

       break;
 
     default:
       break;
 
     default:


@@ -3067,6 +3415,7 @@ set_ignore_count (bptnum, count, from_tty)
        else
          printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
                  count, bptnum);
        else
          printf_filtered ("Will ignore next %d crossings of breakpoint %d.",
                  count, bptnum);

+       breakpoints_changed ();

        return;
       }
 
        return;
       }
 


@@ -3105,6 +3454,7 @@ ignore_command (args, from_tty)
                    longest_to_int (value_as_long (parse_and_eval (p))),
                    from_tty);
   printf_filtered ("\n");
                    longest_to_int (value_as_long (parse_and_eval (p))),
                    from_tty);
   printf_filtered ("\n");

+  breakpoints_changed ();

 }
 \f
 /* Call FUNCTION on each of the breakpoints
 }
 \f
 /* Call FUNCTION on each of the breakpoints


@@ -3150,14 +3500,26 @@ enable_breakpoint (bpt)
 {
   FRAME save_selected_frame = NULL;
   int save_selected_frame_level = -1;
 {
   FRAME save_selected_frame = NULL;
   int save_selected_frame_level = -1;

+  int target_resources_ok, other_type_used;
+  struct value *mark;

   
   

+  if (bpt->type == bp_hardware_breakpoint)
+    {
+      int i;
+      i = hw_breakpoint_used_count();
+      target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT( 
+               bp_hardware_breakpoint, i+1, 0);
+      if (target_resources_ok == 0)
+        error ("No hardware breakpoint support in the target.");
+      else if (target_resources_ok < 0)
+        error ("Hardware breakpoints used exceeds limit.");
+    }

   bpt->enable = enabled;
   bpt->enable = enabled;

-
-  if (xgdb_verbose && bpt->type == bp_breakpoint)
-    printf_unfiltered ("breakpoint #%d enabled\n", bpt->number);
-
+  breakpoints_changed ();

   check_duplicates (bpt->address);
   check_duplicates (bpt->address);

-  if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint)
+
+  if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
+      bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)

     {
       if (bpt->exp_valid_block != NULL)
        {
     {
       if (bpt->exp_valid_block != NULL)
        {


@@ -3177,14 +3539,36 @@ is valid is not currently in scope.\n", bpt->number);
        }
 
       value_free (bpt->val);
        }
 
       value_free (bpt->val);

-
+      mark = value_mark ();

       bpt->val = evaluate_expression (bpt->exp);
       release_value (bpt->val);
       if (VALUE_LAZY (bpt->val))
        value_fetch_lazy (bpt->val);
 
       bpt->val = evaluate_expression (bpt->exp);
       release_value (bpt->val);
       if (VALUE_LAZY (bpt->val))
        value_fetch_lazy (bpt->val);
 

+      if (bpt->type == bp_hardware_watchpoint ||
+           bpt->type == bp_read_watchpoint ||
+           bpt->type == bp_access_watchpoint)
+      {
+        int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
+        int mem_cnt = can_use_hardware_watchpoint(bpt->val);
+        target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
+                bpt->type, i+mem_cnt, other_type_used);
+        /* we can consider of type is bp_hardware_watchpoint, convert to 
+          bp_watchpoint in the following condition */
+        if (target_resources_ok < 0)
+         {
+             printf_filtered("\
+Cannot enable watchpoint %d because target watch resources\n\
+have been allocated for other watchpoints.\n", bpt->number);
+           bpt->enable = disabled;
+           value_free_to_mark (mark);
+           return;
+          }
+      }
+

       if (save_selected_frame_level >= 0)
        select_frame (save_selected_frame, save_selected_frame_level);
       if (save_selected_frame_level >= 0)
        select_frame (save_selected_frame, save_selected_frame_level);

+      value_free_to_mark (mark);

     }
 }
 
     }
 }
 


@@ -3200,8 +3584,11 @@ enable_command (args, from_tty)
       switch (bpt->type)
        {
        case bp_breakpoint:
       switch (bpt->type)
        {
        case bp_breakpoint:

+       case bp_hardware_breakpoint:

        case bp_watchpoint:
        case bp_hardware_watchpoint:
        case bp_watchpoint:
        case bp_hardware_watchpoint:

+       case bp_read_watchpoint:
+       case bp_access_watchpoint:

          enable_breakpoint (bpt);
        default:
          continue;
          enable_breakpoint (bpt);
        default:
          continue;


@@ -3222,8 +3609,7 @@ disable_breakpoint (bpt)
 
   bpt->enable = disabled;
 
 
   bpt->enable = disabled;
 

-  if (xgdb_verbose && bpt->type == bp_breakpoint)
-    printf_filtered ("breakpoint #%d disabled\n", bpt->number);
+  breakpoints_changed ();

 
   check_duplicates (bpt->address);
 }
 
   check_duplicates (bpt->address);
 }


@@ -3240,8 +3626,11 @@ disable_command (args, from_tty)
       switch (bpt->type)
        {
        case bp_breakpoint:
       switch (bpt->type)
        {
        case bp_breakpoint:

-       case bp_watchpoint:
-       case bp_hardware_watchpoint:
+        case bp_hardware_breakpoint:
+        case bp_watchpoint:
+        case bp_hardware_watchpoint:
+        case bp_read_watchpoint:
+        case bp_access_watchpoint:

          disable_breakpoint (bpt);
        default:
          continue;
          disable_breakpoint (bpt);
        default:
          continue;


@@ -3254,10 +3643,79 @@ static void
 enable_once_breakpoint (bpt)
      struct breakpoint *bpt;
 {
 enable_once_breakpoint (bpt)
      struct breakpoint *bpt;
 {

+  FRAME save_selected_frame = NULL;
+  int save_selected_frame_level = -1;
+  int target_resources_ok, other_type_used;
+  struct value *mark;
+
+  if (bpt->type == bp_hardware_breakpoint) 
+    {   
+      int i;
+      i = hw_breakpoint_used_count();
+      target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
+               bp_hardware_breakpoint, i+1, 0);
+      if (target_resources_ok == 0)
+        error ("No hardware breakpoint support in the target.");
+      else if (target_resources_ok < 0)
+        error ("Hardware breakpoints used exceeds limit.");
+    }
+

   bpt->enable = enabled;
   bpt->disposition = disable;
   bpt->enable = enabled;
   bpt->disposition = disable;

-

   check_duplicates (bpt->address);
   check_duplicates (bpt->address);

+  breakpoints_changed ();
+
+  if (bpt->type == bp_watchpoint || bpt->type == bp_hardware_watchpoint ||
+      bpt->type == bp_read_watchpoint || bpt->type == bp_access_watchpoint)
+    {
+      if (bpt->exp_valid_block != NULL)
+       {
+         FRAME fr = find_frame_addr_in_frame_chain (bpt->watchpoint_frame);
+         if (fr == NULL)
+           {
+             printf_filtered ("\
+Cannot enable watchpoint %d because the block in which its expression\n\
+is valid is not currently in scope.\n", bpt->number);
+             bpt->enable = disabled;
+             return;
+           }
+
+         save_selected_frame = selected_frame;
+         save_selected_frame_level = selected_frame_level;
+         select_frame (fr, -1);
+       }
+
+      value_free (bpt->val);
+      mark = value_mark ();
+      bpt->val = evaluate_expression (bpt->exp);
+      release_value (bpt->val);
+      if (VALUE_LAZY (bpt->val))
+       value_fetch_lazy (bpt->val);
+
+      if (bpt->type == bp_hardware_watchpoint ||
+           bpt->type == bp_read_watchpoint ||
+           bpt->type == bp_access_watchpoint)
+      {
+        int i = hw_watchpoint_used_count (bpt->type, &other_type_used);
+        int mem_cnt = can_use_hardware_watchpoint(bpt->val);
+        target_resources_ok = TARGET_CAN_USE_HARDWARE_WATCHPOINT(
+                bpt->type, i+mem_cnt, other_type_used);
+        /* we can consider of type is bp_hardware_watchpoint, convert to 
+          bp_watchpoint in the following condition */
+        if (target_resources_ok < 0)
+         {
+             printf_filtered("\
+Cannot enable watchpoint %d because target watch resources\n\
+have been allocated for other watchpoints.\n", bpt->number);
+           bpt->enable = disabled;
+           value_free_to_mark (mark);
+          }
+      }
+
+      if (save_selected_frame_level >= 0)
+       select_frame (save_selected_frame, save_selected_frame_level);
+      value_free_to_mark (mark);
+    }

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */


@@ -3277,6 +3735,7 @@ enable_delete_breakpoint (bpt)
   bpt->disposition = delete;
 
   check_duplicates (bpt->address);
   bpt->disposition = delete;
 
   check_duplicates (bpt->address);

+  breakpoints_changed ();

 }
 
 /* ARGSUSED */
 }
 
 /* ARGSUSED */


@@ -3342,6 +3801,16 @@ Like \"break\" except the breakpoint is only temporary,\n\
 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
 by using \"enable delete\" on the breakpoint number.");
 
 so it will be deleted when hit.  Equivalent to \"break\" followed\n\
 by using \"enable delete\" on the breakpoint number.");
 

+  add_com ("hbreak", class_breakpoint, hbreak_command,
+          "Set a hardware assisted  breakpoint. Args like \"break\" command.\n\
+Like \"break\" except the breakpoint requires hardware support,\n\
+some target hardware may not have this support.");
+
+  add_com ("thbreak", class_breakpoint, thbreak_command,
+          "Set a temporary hardware assisted breakpoint. Args like \"break\" command.\n\
+Like \"hbreak\" except the breakpoint is only temporary,\n\
+so it will be deleted when hit.");
+

   add_prefix_cmd ("enable", class_breakpoint, enable_command,
                  "Enable some breakpoints.\n\
 Give breakpoint numbers (separated by spaces) as arguments.\n\
   add_prefix_cmd ("enable", class_breakpoint, enable_command,
                  "Enable some breakpoints.\n\
 Give breakpoint numbers (separated by spaces) as arguments.\n\


@@ -3493,6 +3962,16 @@ Do \"help breakpoints\" for info on other commands dealing with breakpoints.");
 A watchpoint stops execution of your program whenever the value of\n\
 an expression changes.");
 
 A watchpoint stops execution of your program whenever the value of\n\
 an expression changes.");
 

+  add_com ("rwatch", class_breakpoint, rwatch_command,
+          "Set a read watchpoint for an expression.\n\
+A watchpoint stops execution of your program whenever the value of\n\
+an expression is read.");
+
+  add_com ("awatch", class_breakpoint, awatch_command,
+          "Set a watchpoint for an expression.\n\
+A watchpoint stops execution of your program whenever the value of\n\
+an expression is either read or written.");
+

   add_info ("watchpoints", breakpoints_info,
            "Synonym for ``info breakpoints''.");
 }
   add_info ("watchpoints", breakpoints_info,
            "Synonym for ``info breakpoints''.");
 }