home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #16 / NN_1992_16.iso / spool / gnu / gdb / bug / 906 < prev    next >
Encoding:
Text File  |  1992-07-27  |  31.7 KB  |  1,049 lines
  1. Newsgroups: gnu.gdb.bug
  2. Path: sparky!uunet!cis.ohio-state.edu!mermaid.micro.umn.edu!daney
  3. From: daney@mermaid.micro.umn.edu (Dave Daney)
  4. Subject: Debug register use for ISC 2.2.1 (Sys v/386 R3.2)
  5. Message-ID: <199207271614.AA07753@mermaid.micro.umn.edu>
  6. Sender: gnulists@ai.mit.edu
  7. Organization: GNUs Not Usenet
  8. Distribution: gnu
  9. Date: Mon, 27 Jul 1992 06:14:50 GMT
  10. Approved: bug-gdb@prep.ai.mit.edu
  11. Lines: 1036
  12.  
  13. I have had several requests for my patches for debug register use for
  14. Interactive 2.2.1 so I am posting the slightly modified for gdb-4.6 version.
  15.  
  16. I think someone told me they work on SCO also but I have not ever seen it
  17. so I make no claims to that, actually I probably shouldn't claim it works
  18. on anything.
  19.  
  20. I have made a few modifications to gdb-4.6 to use the hardware debug
  21. registers on the 386 running Interactive 2.2.1 (Sys V/386 Rel3.2).
  22.  
  23. They are implemented as a new type of breakpoint(I called it an Accesspoint).
  24. I thought that they should be seperate from watchpoints because watchpoints break
  25. on a whole expression changing.  Which  is different than a breakpoint on a memory
  26. access, they (watchpoints) probably are usefull even with accesspoints.  Any how
  27. there are two new commands to implement Accesspoints.
  28.  
  29. wbreak:  Break on a memory write to a location.
  30. abreak:  Break on a memory access (read or write) to a location.
  31.  
  32. They can be set on any expression that evaluates to some thing located in a
  33. memory location.
  34.  
  35. Special note:  To set an access breakpoint on location 0 (good for catching
  36. reads or writes from a NULL pointer).
  37.  
  38. abreak *(int *)0
  39.  
  40. All of the rest of the breakpoint commands work on Accesspoints (info, enable, 
  41. disable, delete, ... .  I haven't had any problems with them, although I have only
  42. had this going on gdb-4.6 for a couple of days.  However I have been using this
  43. with gdb-4.5 ever since it came out.
  44.  
  45. I think It is fairly straight forward.  I didn't make any info files for this.
  46.  
  47.  
  48. I put the machine dependant parts in i386-xdep.c most of the rest of it is
  49. in breakpoint.c.  Several other files just had the
  50. struct target_ops XXXXX_target structures modified.
  51.  
  52. I think(hope) that all of the changes are inside of
  53. #ifdef HAVE_MEM_BEEAKPOINT
  54. #endif
  55. blocks so hopefully this will not break any thing if you don't define
  56. -DHAVE_MEM_BREAKPOINT
  57. not positive about this however.  I hope this addition fits into the
  58. scheme of gdb and does not break things for other systems. Let me know.
  59.  
  60.  
  61. On the 386 there are only four Access breakpoint registers, they can be set
  62. for one, two, and four byte accesses.  The addresses must be properly aligned.
  63. The code in i386-xdep.c takes all of this into account, it will use as many
  64. registers as necessary to cover the requested area.  If the registers are
  65. exausted it will disable the Accesspoint.  There is a bug(feature) here, if
  66. multiple registers are needed and at least one is available it  will fill from
  67. the bottom of the area requested. Then it will report no more registers and disable
  68. the Access point.  It does not deallocate the registers from the failed attempt.
  69. When execution is resumed (continue) the access point is still set on the first
  70. portion of the area.  If it is hit you will get some message about a SIGTRAP, but
  71. the Accesspoint information will not print.  In short, set Accesspoints on
  72. small properly aligned objects.
  73.  
  74.  
  75.  
  76. I configured like this:
  77.  
  78. configure i386-none-sysv32
  79.  
  80. Here is how I made it.  The trad-core things are to get corefiles to read on this
  81. machine, but trad-core.c needs to be patched for it to work (see other posting).
  82. For other 386 systems perhaps just -DHAVE_MEM_BREAKPOINT is sufficient.
  83. I have a feeling that the things in i386-xdep.c might be different for other 
  84. systems.
  85.  
  86. gmake CC=gcc HDEFINES="-D_POSIX_SOURCE -DTRAD_CORE" HDEPFILES=trad-core.o\
  87. READLINE_DEFINES="-D_POSIX_VERSION -D_POSIX_SOURCE" LOADLIBES=-lcposix\
  88. USER_CFLAGS=-DHAVE_MEM_BREAKPOINT CFLAGS="-g -O2"
  89.  
  90.  
  91.  
  92.  
  93. *** breakpoint.c    Mon Jul  6 12:10:37 1992
  94. --- ../../gdb-4.6.new/gdb/breakpoint.c    Fri Jul 24 16:14:04 1992
  95. ***************
  96. *** 133,139 ****
  97. --- 133,152 ----
  98.   static void
  99.   set_breakpoint_count PARAMS ((int));
  100.   
  101. + #ifdef HAVE_MEM_BREAKPOINT
  102.   
  103. + static void
  104. + write_access_breakpoint_command PARAMS ((char *, int));
  105. + 
  106. + static void
  107. + rw_access_breakpoint_command PARAMS ((char *, int));
  108. + 
  109. + static void
  110. + access_breakpoint_command PARAMS ((char *, int, enum access_break_type));
  111. + 
  112. + #endif /* HAVE_MEM_BREAKPOINT */
  113. + 
  114. + 
  115.   extern int addressprint;        /* Print machine addresses? */
  116.   extern int demangle;            /* Print de-mangled symbol names? */
  117.   
  118. ***************
  119. *** 433,438 ****
  120. --- 446,454 ----
  121.   
  122.     ALL_BREAKPOINTS (b)
  123.       if (b->type != bp_watchpoint
  124. + #ifdef HAVE_MEM_BREAKPOINT
  125. +     && b->type != bp_accesspoint
  126. + #endif
  127.       && b->enable != disabled
  128.       && ! b->inserted
  129.       && ! b->duplicate)
  130. ***************
  131. *** 449,455 ****
  132.           if (!disabled_breaks)
  133.             {
  134.               fprintf (stderr,
  135. !              "Cannot insert breakpoint %d:\n", b->number);
  136.               printf_filtered ("Disabling shared library breakpoints:\n");
  137.             }
  138.           disabled_breaks = 1;
  139. --- 465,471 ----
  140.           if (!disabled_breaks)
  141.             {
  142.               fprintf (stderr,
  143. !                  "Cannot insert breakpoint %d:\n", b->number);
  144.               printf_filtered ("Disabling shared library breakpoints:\n");
  145.             }
  146.           disabled_breaks = 1;
  147. ***************
  148. *** 461,467 ****
  149.           fprintf (stderr, "Cannot insert breakpoint %d:\n", b->number);
  150.   #ifdef ONE_PROCESS_WRITETEXT
  151.           fprintf (stderr,
  152. !           "The same program may be running in another process.\n");
  153.   #endif
  154.           memory_error (val, b->address);    /* which bombs us out */
  155.             }
  156. --- 477,483 ----
  157.           fprintf (stderr, "Cannot insert breakpoint %d:\n", b->number);
  158.   #ifdef ONE_PROCESS_WRITETEXT
  159.           fprintf (stderr,
  160. !              "The same program may be running in another process.\n");
  161.   #endif
  162.           memory_error (val, b->address);    /* which bombs us out */
  163.             }
  164. ***************
  165. *** 471,476 ****
  166. --- 487,513 ----
  167.         }
  168.     if (disabled_breaks)
  169.       printf_filtered ("\n");
  170. + 
  171. + #ifdef HAVE_MEM_BREAKPOINT
  172. +   target_init_access_breakpoint();
  173. + 
  174. +   ALL_BREAKPOINTS (b)
  175. +     if (b->type == bp_accesspoint && b->enable != disabled)
  176. +       {
  177. +     int rv;
  178. +     rv = target_insert_access_breakpoint(b->access_break_address,
  179. +                          b->access_break_length,
  180. +                           b->access_break_type, b->number);
  181. +     if (rv)
  182. +       {
  183. +         /* Can't set the breakpoint.  */
  184. +         fprintf(stderr, "Cannot set memory breakpoint %d.  Disableing it.\n", b->number);
  185. +         fprintf(stderr, "It is best to set memory breakpoints on small properly\n");
  186. +         fprintf(stderr, "aligned objects\n");
  187. +         b->enable = disabled;
  188. +       }    
  189. +       }
  190. + #endif /* HAVE_MEM_BREAKPOINT */
  191.     return val;
  192.   }
  193.   
  194. ***************
  195. *** 500,505 ****
  196. --- 537,545 ----
  197.           local_hex_string(b->shadow_contents[1]));
  198.   #endif /* BREAKPOINT_DEBUG */
  199.         }
  200. + #ifdef HAVE_MEM_BREAKPOINT
  201. +   target_init_access_breakpoint();
  202. + #endif /* HAVE_MEM_BREAKPOINT */
  203.   
  204.     return 0;
  205.   }
  206. ***************
  207. *** 707,712 ****
  208. --- 747,755 ----
  209.     if (bs == NULL
  210.         || bs->breakpoint_at == NULL
  211.         || (bs->breakpoint_at->type != bp_breakpoint
  212. + #ifdef HAVE_MEM_BREAKPOINT
  213. +       && bs->breakpoint_at->type != bp_accesspoint
  214. + #endif /* HAVE_MEM_BREAKPOINT */
  215.         && bs->breakpoint_at->type != bp_watchpoint))
  216.       return 0;
  217.     
  218. ***************
  219. *** 742,748 ****
  220.         bs->old_val = NULL;
  221.         return 1;
  222.       }
  223. ! 
  224.     /* Maybe another breakpoint in the chain caused us to stop.
  225.        (Currently all watchpoints go on the bpstat whether hit or
  226.        not.  That probably could (should) be changed, provided care is taken
  227. --- 785,808 ----
  228.         bs->old_val = NULL;
  229.         return 1;
  230.       }
  231. ! #ifdef HAVE_MEM_BREAKPOINT
  232. !   if (bs->breakpoint_at->type == bp_accesspoint)
  233. !     {
  234. !       printf_filtered ("\nMemory access breakpoint %d, ", bs->breakpoint_at->number);
  235. !       printf_filtered ("%-10s",
  236. !                local_hex_string(bs->breakpoint_at->access_break_address));
  237. !       printf_filtered ("  ");
  238. !       if(bs->breakpoint_at->access_break_type == access_break_write)
  239. !     printf_filtered ("w  ");
  240. !       else
  241. !     printf_filtered ("r/w");
  242. !       printf_filtered ("  ");
  243. !       printf_filtered ("%d   ", bs->breakpoint_at->access_break_length);
  244. !       print_expression (bs->breakpoint_at->access_break_exp, stdout);
  245. !       printf_filtered ("\n");
  246. !       return 0;
  247. !     }
  248. ! #endif /* HAVE_MEM_BREAKPOINT */
  249.     /* Maybe another breakpoint in the chain caused us to stop.
  250.        (Currently all watchpoints go on the bpstat whether hit or
  251.        not.  That probably could (should) be changed, provided care is taken
  252. ***************
  253. *** 817,822 ****
  254. --- 877,885 ----
  255.     /* True if we've hit a breakpoint (as opposed to a watchpoint).  */
  256.     int real_breakpoint = 0;
  257.   #endif
  258. + #ifdef HAVE_MEM_BREAKPOINT
  259. +   int access_breakpoint = target_get_access_breakpoint_status();
  260. + #endif
  261.     /* Root of the chain of bpstat's */
  262.     struct bpstat root_bs[1];
  263.     /* Pointer to the last thing in the chain currently.  */
  264. ***************
  265. *** 833,841 ****
  266.         if (b->enable == disabled)
  267.       continue;
  268.   
  269. !       if (b->type != bp_watchpoint && b->address != bp_addr)
  270.       continue;
  271.   
  272.         /* Come here if it's a watchpoint, or if the break address matches */
  273.   
  274.         bs = bpstat_alloc (b, bs);    /* Alloc a bpstat to explain stop */
  275. --- 896,912 ----
  276.         if (b->enable == disabled)
  277.       continue;
  278.   
  279. ! #ifdef HAVE_MEM_BREAKPOINT
  280. !       if (b->type != bp_watchpoint && b->address != bp_addr &&
  281. !       b->type != bp_accesspoint)
  282.       continue;
  283.   
  284. +       if(b->type == bp_accesspoint && b->number != access_breakpoint)
  285. +     continue;
  286. + #else
  287. +       if (b->type != bp_watchpoint && b->address != bp_addr)
  288. +     continue;
  289. + #endif /* HAVE_MEM_BREAKPOINT */
  290.         /* Come here if it's a watchpoint, or if the break address matches */
  291.   
  292.         bs = bpstat_alloc (b, bs);    /* Alloc a bpstat to explain stop */
  293. ***************
  294. *** 896,903 ****
  295. --- 967,979 ----
  296.           }
  297.       }
  298.   #if DECR_PC_AFTER_BREAK != 0 || defined (SHIFT_INST_REGS)
  299. + #ifdef HAVE_MEM_BREAKPOINT
  300. +       else if (b->type != bp_accesspoint)
  301. +     real_breakpoint = 1;
  302. + #else
  303.         else
  304.       real_breakpoint = 1;
  305. + #endif /* HAVE_MEM_BREAKPOINT  */
  306.   #endif
  307.   
  308.         if (b->frame && b->frame != frame_address)
  309. ***************
  310. *** 990,998 ****
  311.     return 0;
  312.   }
  313.   
  314. ! /* Print information on breakpoint number BNUM, or -1 if all.
  315. !    If WATCHPOINTS is zero, process only breakpoints; if WATCHPOINTS
  316. !    is nonzero, process only watchpoints.  */
  317.   
  318.   static void
  319.   breakpoint_1 (bnum, allflag)
  320. --- 1066,1072 ----
  321.     return 0;
  322.   }
  323.   
  324. ! /* Print information on breakpoint number BNUM, or -1 if all. */
  325.   
  326.   static void
  327.   breakpoint_1 (bnum, allflag)
  328. ***************
  329. *** 1005,1011 ****
  330.     CORE_ADDR last_addr = (CORE_ADDR)-1;
  331.     int found_a_breakpoint = 0;
  332.     static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
  333. !                   "longjmp", "longjmp resume"};
  334.     static char *bpdisps[] = {"del", "dis", "keep"};
  335.     static char bpenables[] = "ny";
  336.   
  337. --- 1079,1090 ----
  338.     CORE_ADDR last_addr = (CORE_ADDR)-1;
  339.     int found_a_breakpoint = 0;
  340.     static char *bptypes[] = {"breakpoint", "until", "finish", "watchpoint",
  341. !                   "longjmp", "longjmp resume"
  342. ! #ifdef HAVE_MEM_BREAKPOINT
  343. !                 ,"accesspoint"
  344. ! #endif /* HAVE_MEM_BREAKPOINT */
  345. !                 };
  346. ! 
  347.     static char *bpdisps[] = {"del", "dis", "keep"};
  348.     static char bpenables[] = "ny";
  349.   
  350. ***************
  351. *** 1022,1028 ****
  352.   /*  We only print out user settable breakpoints unless the allflag is set. */
  353.       if (!allflag
  354.           && b->type != bp_breakpoint
  355. !         && b->type != bp_watchpoint)
  356.         continue;
  357.   
  358.       if (!found_a_breakpoint++)
  359. --- 1101,1111 ----
  360.   /*  We only print out user settable breakpoints unless the allflag is set. */
  361.       if (!allflag
  362.           && b->type != bp_breakpoint
  363. !         && b->type != bp_watchpoint
  364. ! #ifdef HAVE_MEM_BREAKPOINT
  365. !         && b->type != bp_accesspoint
  366. ! #endif /* HAVE_MEM_BREAKPOINT */
  367. !         )
  368.         continue;
  369.   
  370.       if (!found_a_breakpoint++)
  371. ***************
  372. *** 1039,1044 ****
  373. --- 1122,1141 ----
  374.         case bp_watchpoint:
  375.           print_expression (b->exp, stdout);
  376.           break;
  377. + #ifdef HAVE_MEM_BREAKPOINT
  378. +       case bp_accesspoint:
  379. +         if (addressprint)
  380. +           printf_filtered ("%s ",
  381. +                    local_hex_string_custom(b->access_break_address,
  382. +                                "08"));
  383. +         if(b->access_break_type == access_break_write)
  384. +            printf_filtered ("(w   ");
  385. +          else
  386. +            printf_filtered ("(r/w ");
  387. +          printf_filtered ("%d) ", b->access_break_length);
  388. +         print_expression (b->access_break_exp, stdout);
  389. +         break;
  390. + #endif /* HAVE_MEM_BREAKPOINT */
  391.         case bp_breakpoint:
  392.         case bp_until:
  393.         case bp_finish:
  394. ***************
  395. *** 1185,1191 ****
  396.     register struct breakpoint *b;
  397.     register int count = 0;
  398.   
  399. !   if (address == 0)        /* Watchpoints are uninteresting */
  400.       return;
  401.   
  402.     ALL_BREAKPOINTS (b)
  403. --- 1282,1288 ----
  404.     register struct breakpoint *b;
  405.     register int count = 0;
  406.   
  407. !   if (address == 0)    /* Watchpoints and access_breakpoints are uninteresting */
  408.       return;
  409.   
  410.     ALL_BREAKPOINTS (b)
  411. ***************
  412. *** 1371,1376 ****
  413. --- 1468,1479 ----
  414.   {
  415.     switch (b->type)
  416.       {
  417. + #ifdef HAVE_MEM_BREAKPOINT
  418. +     case bp_accesspoint:
  419. +       printf_filtered ("Memory accesspoint %d at %s", b->number,
  420. +                local_hex_string_custom(b->access_break_address, "08"));
  421. +       break;
  422. + #endif /* HAVE_MEM_BREAKPOINT  */
  423.       case bp_watchpoint:
  424.         printf_filtered ("Watchpoint %d: ", b->number);
  425.         print_expression (b->exp, stdout);
  426. ***************
  427. *** 1622,1627 ****
  428. --- 1725,1792 ----
  429.     b->cond_string = NULL;
  430.     mention (b);
  431.   }
  432. + 
  433. + #ifdef HAVE_MEM_BREAKPOINT
  434. + /* ARGSUSED */
  435. + static void
  436. + access_breakpoint_command (arg, from_tty, mode)
  437. +      char *arg;
  438. +      int from_tty;
  439. +      enum access_break_type mode;
  440. + {
  441. +   struct breakpoint *b;
  442. +   struct symtab_and_line sal;
  443. +   struct expression *exp;
  444. +   struct block *exp_valid_block;
  445. +   struct value *access_obj;
  446. + 
  447. +   sal.pc = 0;
  448. +   sal.symtab = NULL;
  449. +   sal.line = 0;
  450. +   
  451. +   /* Parse arguments.  */
  452. +   innermost_block = NULL;
  453. +   exp = parse_expression (arg);
  454. +   exp_valid_block = innermost_block;
  455. +   access_obj = evaluate_expression (exp);
  456. + 
  457. +   if(lval_memory != VALUE_LVAL(access_obj))
  458. +     error("requested access breakpoint not in memory.  e.g. register or constant.");
  459. + 
  460. +   /* Now set up the breakpoint.  */
  461. +   b = set_raw_breakpoint (sal);
  462. +   set_breakpoint_count (breakpoint_count + 1);
  463. +   b->number = breakpoint_count;
  464. +   b->type = bp_accesspoint;
  465. +   b->disposition = donttouch;
  466. +   b->exp = 0;
  467. +   b->exp_valid_block = NULL;
  468. +   b->val = NULL;
  469. +   b->cond = 0;
  470. +   b->cond_string = NULL;
  471. +   b->access_break_exp = exp;
  472. +   b->access_break_address = VALUE_ADDRESS(access_obj) + VALUE_OFFSET(access_obj);
  473. +   b->access_break_length = TYPE_LENGTH(VALUE_TYPE(access_obj));
  474. +   b->access_break_type = mode;
  475. +   mention (b);
  476. + }
  477. + static void
  478. + write_access_breakpoint_command (arg, from_tty)
  479. +      char *arg;
  480. +      int from_tty;
  481. + {
  482. +   access_breakpoint_command (arg, from_tty, access_break_write);
  483. + }
  484. + static void
  485. + rw_access_breakpoint_command (arg, from_tty)
  486. +      char *arg;
  487. +      int from_tty;
  488. + {
  489. +   access_breakpoint_command (arg, from_tty, access_break_rw);
  490. + }
  491. + 
  492. + #endif /* HAVE_MEM_BREAKPOINT */
  493. + 
  494.   
  495.   /*
  496.    * Helper routine for the until_command routine in infcmd.c.  Here
  497. ***************
  498. *** 2063,2068 ****
  499. --- 2228,2236 ----
  500.         ALL_BREAKPOINTS (b)
  501.       while (b->next
  502.              && b->next->type != bp_watchpoint
  503. + #ifdef HAVE_MEM_BREAKPOINT
  504. +            && b->next->type != bp_accesspoint
  505. + #endif /* HAVE_MEM_BREAKPOINT */
  506.              && (sal.pc ? b->next->address == sal.pc
  507.              : (b->next->symtab == sal.symtab
  508.                 && b->next->line_number == sal.line)))
  509. ***************
  510. *** 2232,2237 ****
  511. --- 2400,2408 ----
  512.         break;
  513.       default:
  514.         printf_filtered ("Deleting unknown breakpoint type %d\n", b->type);
  515. + #ifdef HAVE_MEM_BREAKPOINT
  516. +     case bp_accesspoint:
  517. + #endif /*HAVE_MEM_BREAKPOINT */
  518.       case bp_until:
  519.       case bp_finish:
  520.       case bp_longjmp:
  521. ***************
  522. *** 2615,2620 ****
  523. --- 2786,2802 ----
  524.   This command may be abbreviated \"delete\".",
  525.          &deletelist);
  526.   
  527. + #ifdef HAVE_MEM_BREAKPOINT
  528. +   add_com ("wbreak", class_breakpoint, write_access_breakpoint_command,
  529. +        "Set a memory write breakpoint at a location.\n\
  530. + A memory write breakpoint stops execution of your program whenever it\n\
  531. + tries to write data at that location.");
  532. + 
  533. +   add_com ("abreak", class_breakpoint, rw_access_breakpoint_command,
  534. +        "Set a memory acsess breakpoint at a location.\n\
  535. + A memory acsess breakpoint stops execution of your program whenever it\n\
  536. + tries to read or write data at that location.");
  537. + #endif /* HAVE_MEM_BREAKPOINT */
  538.     add_com ("clear", class_breakpoint, clear_command,
  539.          "Clear breakpoint at specified line or function.\n\
  540.   Argument may be line number, function name, or \"*\" and an address.\n\
  541. ***************
  542. *** 2643,2648 ****
  543. --- 2825,2850 ----
  544.     add_com_alias ("bre", "break", class_run, 1);
  545.     add_com_alias ("brea", "break", class_run, 1);
  546.   
  547. + 
  548. + #ifdef HAVE_MEM_BREAKPOINT
  549. + 
  550. + #else /* !HAVE_MEM_BREAKPOINT */
  551. +   add_info ("breakpoints", breakpoints_info,
  552. +         "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
  553. + The \"Type\" column indicates one of:\n\
  554. + \tbreakpoint     - normal breakpoint\n\
  555. + \taccesspoint    - memory access breakpoint\n\
  556. + \twatchpoint     - watchpoint\n\
  557. + The \"Disp\" column contains one of \"keep\", \"del\", or \"dis\" to indicate\n\
  558. + the disposition of the breakpoint after it gets hit.  \"dis\" means that the\n\
  559. + breakpoint will be disabled.  The \"Address\" and \"What\" columns indicate the\n\
  560. + address and file/line number respectively.\n\n\
  561. + Convenience variable \"$_\" and default examine address for \"x\"\n\
  562. + are set to the address of the last breakpoint listed.\n\n\
  563. + Convenience variable \"$bpnum\" contains the number of the last\n\
  564. + breakpoint set.");
  565. + 
  566. + #endif /* !HAVE_MEM_BREAKPOINT */
  567.     add_info ("breakpoints", breakpoints_info,
  568.           "Status of user-settable breakpoints, or breakpoint number NUMBER.\n\
  569.   The \"Type\" column indicates one of:\n\
  570. *** core.c    Mon Jul  6 12:10:41 1992
  571. --- ../../gdb-4.6.new/gdb/core.c    Fri Jul 24 15:32:52 1992
  572. ***************
  573. *** 444,449 ****
  574. --- 444,452 ----
  575.       core_stratum, 0, /* next */
  576.       0, 1, 1, 1, 0,    /* all mem, mem, stack, regs, exec */
  577.       0, 0,            /* section pointers */
  578. + #ifdef HAVE_MEM_BREAKPOINT
  579. +     0, 0, 0, 0,         /* init, insert, get, clear */                    
  580. + #endif
  581.       OPS_MAGIC,        /* Always the last thing */
  582.   };
  583.   
  584. *** exec.c    Tue May 12 20:11:42 1992
  585. --- ../../gdb-4.6.new/gdb/exec.c    Fri Jul 24 15:32:53 1992
  586. ***************
  587. *** 421,426 ****
  588. --- 421,429 ----
  589.       file_stratum, 0, /* next */
  590.       0, 1, 0, 0, 0,    /* all mem, mem, stack, regs, exec */
  591.       0, 0,            /* section pointers */
  592. + #ifdef HAVE_MEM_BREAKPOINT
  593. +     0, 0, 0, 0,         /* init, insert, get, clear */                    
  594. + #endif
  595.       OPS_MAGIC,        /* Always the last thing */
  596.   };
  597.   
  598. *** i386-xdep.c    Wed Jun 24 12:32:49 1992
  599. --- ../../gdb-4.6.new/gdb/i386-xdep.c    Fri Jul 24 17:05:15 1992
  600. ***************
  601. *** 31,36 ****
  602. --- 31,41 ----
  603.   #include <sys/dir.h>
  604.   #include <signal.h>
  605.   #include <sys/user.h>
  606. + #ifdef HAVE_MEM_BREAKPOINT
  607. + #include "breakpoint.h"
  608. + #include <sys/debugreg.h>
  609. + #endif /* HAVE_MEM_BREAKPOINT */
  610. + 
  611.   #include <sys/ioctl.h>
  612.   #include <fcntl.h>
  613.   
  614. ***************
  615. *** 44,49 ****
  616. --- 49,194 ----
  617.   
  618.   extern struct ext_format ext_format_i387;
  619.   
  620. + 
  621. + #ifdef HAVE_MEM_BREAKPOINT
  622. + struct user u;
  623. + #define u_offset(a, b) ((int)((char *)(&(a.b))-(char *)(&a)))
  624. + 
  625. + static int free_debug_register;
  626. + static int debug_control_mirror;
  627. + /* record here which breakpoint associates with which register */
  628. + static int breakpoint_lookup[DR_LASTADDR + 1];
  629. + 
  630. + void clear_access_breakpoint_status()
  631. + {
  632. +   call_ptrace(6, inferior_pid, u_offset(u, u_debugreg[DR_STATUS]), 0);
  633. + }
  634. + 
  635. + int get_access_breakpoint_status()
  636. + {
  637. +   int i;
  638. +   int status;
  639. + 
  640. +   status = call_ptrace(3, inferior_pid, u_offset(u, u_debugreg[DR_STATUS]), 0);
  641. + 
  642. +   for(i = 0; i <= DR_LASTADDR; i++)
  643. +     {
  644. +       if(status & (1 << i))
  645. +     return(breakpoint_lookup[i]);
  646. +     }
  647. +   return 0;
  648. + }
  649. + 
  650. + void init_access_breakpoint()
  651. + {
  652. +   int i;
  653. +   /* Clear the status register so only new status info is shown.
  654. +      Turn off debugging by clearing control register */
  655. +   call_ptrace(6, inferior_pid, u_offset(u, u_debugreg[DR_STATUS]), 0);
  656. +   call_ptrace(6, inferior_pid, u_offset(u, u_debugreg[DR_CONTROL]), 0);
  657. +   debug_control_mirror = 0;
  658. +   free_debug_register = DR_FIRSTADDR;
  659. +   for(i = 0; i <= DR_LASTADDR; i++)
  660. +     breakpoint_lookup[i] = 0;
  661. + }
  662. + 
  663. + static int size_try_array[16] = {
  664. +   1, 1, 1, 1,            /* trying size one */
  665. +   2, 1, 2, 1,            /* trying size two */
  666. +   2, 1, 2, 1,            /* trying size three */
  667. +   4, 1, 2, 1            /* trying size four */
  668. + };
  669. + 
  670. + static int insert_nonaligned_access_breakpoint(addr, length, mode, breakpoint) 
  671. + CORE_ADDR addr;
  672. + int length;
  673. + enum access_break_type mode;
  674. + int breakpoint;
  675. + {
  676. +   int align;
  677. +   int size;
  678. +   int rv;
  679. + 
  680. +   rv = 0;
  681. +   while(length > 0)
  682. +     {
  683. +       align = addr % 4;
  684. +       size = (length > 4) ? 3 : length - 1;    /*four is the maximum length for 386*/
  685. +       size = size_try_array[size * 4 + align];
  686. + 
  687. +       if(rv = insert_access_breakpoint(addr, size, mode, breakpoint))
  688. +     return rv;
  689. +       addr += size;
  690. +       length -= size;
  691. +     }
  692. +   return rv;
  693. + }
  694. + 
  695. + 
  696. + 
  697. + int insert_access_breakpoint(addr, length, mode, breakpoint)
  698. + CORE_ADDR addr;
  699. + int length;
  700. + enum access_break_type mode;
  701. + int breakpoint;
  702. + {
  703. +   int rv;
  704. +   int read_write_bits, len_bits;
  705. +   
  706. +   if(access_break_write == mode)
  707. +     read_write_bits = DR_RW_WRITE;
  708. +   else if(access_break_rw == mode)
  709. +     read_write_bits = DR_RW_READ;
  710. +   else
  711. +     return 1;            /* bad mode! */
  712. + 
  713. +   if(free_debug_register > DR_LASTADDR)
  714. +     return 1;            /* no more debug registers! */
  715. + 
  716. +   if(1 == length)
  717. +     {
  718. +       len_bits = DR_LEN_1;
  719. +     }
  720. +   else if(2 == length)
  721. +     {
  722. +       if(addr % 2)
  723. +     return(insert_nonaligned_access_breakpoint(addr, length, mode,
  724. +                            breakpoint));
  725. +       len_bits = DR_LEN_2;
  726. +     }
  727. + 
  728. +   else if(4 == length)
  729. +     {
  730. +       if(addr % 4)
  731. +     return(insert_nonaligned_access_breakpoint(addr, length, mode,
  732. +                            breakpoint));
  733. +       len_bits = DR_LEN_4;
  734. +     }
  735. +   else
  736. +     {
  737. +       return(insert_nonaligned_access_breakpoint(addr, length, mode,
  738. +                          breakpoint));
  739. +     }
  740. +   
  741. +   debug_control_mirror |= ((read_write_bits | len_bits) << 
  742. +     (DR_CONTROL_SHIFT + DR_CONTROL_SIZE * free_debug_register));
  743. +   debug_control_mirror |= (1 << (DR_LOCAL_ENABLE_SHIFT +
  744. +                  DR_ENABLE_SIZE * free_debug_register));
  745. +   debug_control_mirror |= DR_LOCAL_SLOWDOWN;
  746. +   debug_control_mirror &= ~DR_CONTROL_RESERVED;
  747. +   
  748. +   call_ptrace(6, inferior_pid,
  749. +      u_offset(u, u_debugreg[DR_CONTROL]), debug_control_mirror);
  750. +   call_ptrace(6, inferior_pid, u_offset(u, u_debugreg[free_debug_register]), addr);
  751. +   /* record where we came from */
  752. +   breakpoint_lookup[free_debug_register] = breakpoint;
  753. +   free_debug_register++;
  754. +   return 0;
  755. + }
  756. + #endif /* HAVE_MEM_BREAKPOINT */
  757. + 
  758. + 
  759. + 
  760.   /* this table must line up with REGISTER_NAMES in m-i386.h */
  761.   /* symbols like 'EAX' come from <sys/reg.h> */
  762.   static int regmap[] = 
  763. ***************
  764. *** 194,200 ****
  765.         unsigned int mask;
  766.         
  767.         rounded_addr = uaddr & -sizeof (int);
  768. !       data = ptrace (3, inferior_pid, (PTRACE_ARG3_TYPE) rounded_addr, 0);
  769.         mask = 0xff << ((uaddr - rounded_addr) * 8);
  770.         
  771.         fpvalid = ((data & mask) != 0);
  772. --- 339,345 ----
  773.         unsigned int mask;
  774.         
  775.         rounded_addr = uaddr & -sizeof (int);
  776. !       data = call_ptrace (3, inferior_pid, (PTRACE_ARG3_TYPE) rounded_addr, 0);
  777.         mask = 0xff << ((uaddr - rounded_addr) * 8);
  778.         
  779.         fpvalid = ((data & mask) != 0);
  780. ***************
  781. *** 229,235 ****
  782.         ip = (int *)buf;
  783.         for (i = 0; i < rounded_size; i++) 
  784.       {
  785. !       *ip++ = ptrace (3, inferior_pid, (PTRACE_ARG3_TYPE) rounded_addr, 0);
  786.         rounded_addr += sizeof (int);
  787.       }
  788.       } 
  789. --- 374,380 ----
  790.         ip = (int *)buf;
  791.         for (i = 0; i < rounded_size; i++) 
  792.       {
  793. !       *ip++ = call_ptrace (3, inferior_pid, (PTRACE_ARG3_TYPE) rounded_addr, 0);
  794.         rounded_addr += sizeof (int);
  795.       }
  796.       } 
  797. *** infrun.c    Mon Jul  6 12:10:54 1992
  798. --- ../../gdb-4.6.new/gdb/infrun.c    Fri Jul 24 15:32:54 1992
  799. ***************
  800. *** 327,332 ****
  801. --- 327,336 ----
  802.     DO_DEFERRED_STORES;
  803.   #endif
  804.   
  805. + #ifdef HAVE_MEM_BREAKPOINT
  806. +   target_clear_access_breakpoint_status();
  807. + #endif    /* HAVE_MEM_BREAKPOINT */
  808. + 
  809.     target_resume (step, sig);
  810.     discard_cleanups (old_cleanups);
  811.   }
  812. ***************
  813. *** 1079,1084 ****
  814. --- 1083,1091 ----
  815.             default:
  816.           fprintf(stderr, "Unknown breakpoint type %d\n",
  817.               stop_bpstat->breakpoint_at->type);
  818. + #ifdef HAVE_MEM_BREAKPOINT
  819. +           case bp_accesspoint:
  820. + #endif /* HAVE_MEM_BREAKPOINT */
  821.             case bp_watchpoint:
  822.             case bp_breakpoint:
  823.             case bp_until:
  824. *** inftarg.c    Sun Mar 29 17:21:27 1992
  825. --- ../../gdb-4.6.new/gdb/inftarg.c    Fri Jul 24 15:32:55 1992
  826. ***************
  827. *** 42,47 ****
  828. --- 42,56 ----
  829.   static void
  830.   child_detach PARAMS ((char *, int));
  831.   
  832. + #ifdef HAVE_MEM_BREAKPOINT
  833. + extern void init_memory_breakpoint();
  834. + extern int insert_memory_breakpoint();
  835. + extern int get_memory_breakpoint_status();
  836. + extern void clear_memory_breakpoint_status();
  837. + #endif /* HAVE_MEM_BREAKPOINT */
  838. + 
  839. + 
  840. + 
  841.   /* Forward declaration */
  842.   extern struct target_ops child_ops;
  843.   
  844. ***************
  845. *** 208,213 ****
  846. --- 217,228 ----
  847.     1,                /* to_has_execution */
  848.     0,                /* sections */
  849.     0,                /* sections_end */
  850. + #ifdef HAVE_MEM_BREAKPOINT
  851. +   init_access_breakpoint,         /* init, insert, get, clear */
  852. +   insert_access_breakpoint,
  853. +   get_access_breakpoint_status,
  854. +   clear_access_breakpoint_status,
  855. + #endif
  856.     OPS_MAGIC            /* to_magic */
  857.   };
  858.   
  859. *** remote.c    Mon Jul  6 12:11:04 1992
  860. --- ../../gdb-4.6.new/gdb/remote.c    Fri Jul 24 15:32:55 1992
  861. ***************
  862. *** 1048,1053 ****
  863. --- 1048,1059 ----
  864.     1,                /* to_has_execution */
  865.     NULL,                /* sections */
  866.     NULL,                /* sections_end */
  867. + #ifdef HAVE_MEM_BREAKPOINT
  868. +   NULL,                         /* accesspoint init */
  869. +   NULL,                         /* accesspoint insert */
  870. +   NULL,                         /* accesspoint get */
  871. +   NULL,                         /* accesspoint clear */
  872. + #endif
  873.     OPS_MAGIC            /* to_magic */
  874.   };
  875.   
  876. *** target.c    Mon Jul  6 12:11:14 1992
  877. --- ../../gdb-4.6.new/gdb/target.c    Fri Jul 24 15:32:56 1992
  878. ***************
  879. *** 88,93 ****
  880. --- 88,96 ----
  881.       dummy_stratum, 0,    /* stratum, next */
  882.       0, 0, 0, 0, 0,    /* all mem, mem, stack, regs, exec */
  883.       0, 0,        /* section pointers */
  884. + #ifdef HAVE_MEM_BREAKPOINT
  885. +     0, 0, 0, 0,         /* init, insert, get, clear */                    
  886. + #endif
  887.       OPS_MAGIC,
  888.   };
  889.   
  890. ***************
  891. *** 331,337 ****
  892.     de_fault (to_has_stack,        0);
  893.     de_fault (to_has_registers,        0);
  894.     de_fault (to_has_execution,        0);
  895. ! 
  896.   #undef de_fault
  897.   }
  898.   
  899. --- 334,345 ----
  900.     de_fault (to_has_stack,        0);
  901.     de_fault (to_has_registers,        0);
  902.     de_fault (to_has_execution,        0);
  903. ! #ifdef HAVE_MEM_BREAKPOINT
  904. !   de_fault (to_init_access_breakpoint,    init_access_breakpoint);
  905. !   de_fault (to_insert_access_breakpoint,    insert_access_breakpoint);
  906. !   de_fault (to_get_access_breakpoint_status,    get_access_breakpoint_status);
  907. !   de_fault (to_clear_access_breakpoint_status,    clear_access_breakpoint_status);
  908. ! #endif /* HAVE_MEM_BREAKPOINT */
  909.   #undef de_fault
  910.   }
  911.   
  912. *** breakpoint.h    Wed Apr  1 13:46:00 1992
  913. --- ../../gdb-4.6.new/gdb/breakpoint.h    Fri Jul 24 15:32:52 1992
  914. ***************
  915. *** 23,28 ****
  916. --- 23,29 ----
  917.   #include "frame.h"
  918.   #include "value.h"
  919.   
  920. + 
  921.   /* This is the maximum number of bytes a breakpoint instruction can take.
  922.      Feel free to increase it.  It's just used in a few places to size
  923.      arrays that should be independent of the target architecture.  */
  924. ***************
  925. *** 130,135 ****
  926. --- 131,139 ----
  927.     bp_watchpoint,        /* Watchpoint */
  928.     bp_longjmp,            /* secret breakpoint to find longjmp() */
  929.     bp_longjmp_resume        /* secret breakpoint to escape longjmp() */
  930. + #ifdef HAVE_MEM_BREAKPOINT
  931. +   ,bp_accesspoint        /* Memory access breakpoint */
  932. + #endif /* HAVE_MEM_BREAKPOINT */
  933.   };
  934.   
  935.   /* States of enablement of breakpoint. */
  936. ***************
  937. *** 144,149 ****
  938. --- 148,157 ----
  939.     donttouch            /* Leave it alone */
  940.   };
  941.   
  942. + #ifdef HAVE_MEM_BREAKPOINT
  943. + enum access_break_type {access_break_write, access_break_rw};
  944. + #endif /* HAVE_MEM_BREAKPOINT */
  945. + 
  946.   /* Note that the ->silent field is not currently used by any commands
  947.      (though the code is in there if it was to be, and set_raw_breakpoint
  948.      does set it to 0).  I implemented it because I thought it would be
  949. ***************
  950. *** 210,215 ****
  951. --- 218,234 ----
  952.     struct block *exp_valid_block;
  953.     /* Value of the watchpoint the last time we checked it.  */
  954.     value val;
  955. + 
  956. + #ifdef HAVE_MEM_BREAKPOINT
  957. +    /* Address to memory break at.  */
  958. +    CORE_ADDR access_break_address;
  959. +    /* length of block to look at */
  960. +    int access_break_length;
  961. +    /* expression for address to look at */
  962. +    struct expression *access_break_exp;
  963. +    /* set to mem_break_write, or mem_break_rw if this is a memory breakpoint.*/
  964. +    enum access_break_type access_break_type;
  965. + #endif /* HAVE_MEM_BREAKPOINT */
  966.   };
  967.   
  968.   /* Prototypes for breakpoint-related functions.  */
  969. *** target.h    Fri Feb 21 19:46:03 1992
  970. --- ../../gdb-4.6.new/gdb/target.h    Fri Jul 24 15:32:56 1992
  971. ***************
  972. *** 39,45 ****
  973.      never get to the process target).  So when you push a file target,
  974.      it goes into the file stratum, which is always below the process
  975.      stratum.  */
  976. ! 
  977.   #include "bfd.h"
  978.   
  979.   enum strata {
  980. --- 39,45 ----
  981.      never get to the process target).  So when you push a file target,
  982.      it goes into the file stratum, which is always below the process
  983.      stratum.  */
  984. ! #include "breakpoint.h"
  985.   #include "bfd.h"
  986.   
  987.   enum strata {
  988. ***************
  989. *** 94,99 ****
  990. --- 94,106 ----
  991.                  *to_sections;
  992.     struct section_table
  993.              *to_sections_end;
  994. + #ifdef HAVE_MEM_BREAKPOINT
  995. +   void    (* to_init_access_breakpoint) PARAMS ((void));
  996. +   int     (*to_insert_access_breakpoint) PARAMS ((CORE_ADDR, int,
  997. +                      enum access_break_type, int));
  998. +   int     (* to_get_access_breakpoint_status) PARAMS ((void));
  999. +   void    (* to_clear_access_breakpoint_status) PARAMS ((void));
  1000. + #endif /* HAVE_MEM_BREAKPOINT */
  1001.     int        to_magic;
  1002.     /* Need sub-structure for target machine related rather than comm related? */
  1003.   };
  1004. ***************
  1005. *** 222,227 ****
  1006. --- 229,266 ----
  1007.   
  1008.   #define    target_files_info()    \
  1009.       (*current_target->to_files_info) (current_target)
  1010. + 
  1011. + #ifdef HAVE_MEM_BREAKPOINT
  1012. + extern void
  1013. + init_access_breakpoint PARAMS ((void));
  1014. + extern int
  1015. + insert_access_breakpoint PARAMS ((CORE_ADDR, int,
  1016. +                   enum access_break_type, int));
  1017. + extern int
  1018. + get_access_breakpoint_status PARAMS ((void));
  1019. + extern void
  1020. + clear_access_breakpoint_status PARAMS ((void));
  1021. + 
  1022. + 
  1023. + /* Initialize (clear), and set memory access breakpoints.  This is probably
  1024. +    done with hardware debug registers in the cpu.  Result is 0 for success,
  1025. +    or errno value for failure.  If there is a failure there probably are not
  1026. +    any more debug registers left.  */
  1027. + 
  1028. + #define target_init_access_breakpoint() (*current_target->to_init_access_breakpoint)()
  1029. + 
  1030. + #define target_insert_access_breakpoint(addr, len, type, bp_num) \
  1031. +   (*current_target->to_insert_access_breakpoint)(addr, len, type, bp_num)
  1032. + 
  1033. + /* Return the breakpoint number that caused the memory access breakpoint.
  1034. +    Returns 0 if no memory acess breakpoint */
  1035. + #define target_get_access_breakpoint_status() \
  1036. +   (*current_target->to_get_access_breakpoint_status)()
  1037. + 
  1038. + /* Clear the memory breakpoint status.  Called before execution is resumed*/
  1039. + #define target_clear_access_breakpoint_status() \
  1040. +   (*current_target->to_clear_access_breakpoint_status)()
  1041. + #endif /* HAVE_MEM_BREAKPOINT */
  1042.   
  1043.   /* Insert a breakpoint at address ADDR in the target machine.
  1044.      SAVE is a pointer to memory allocated for saving the
  1045. ----------------------------------------------------------------
  1046. Dave Daney    daney@mermaid.micro.umn.edu
  1047.  
  1048.  
  1049.