atlin.c 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508
  1. /* $Id$ */
  2. #define DEBUGGEE
  3. #include "message.h"
  4. #define MAXBP 128
  5. #define MAXTRACE 16
  6. static int nbp; /* # of breakpoints */
  7. static char *bp[MAXBP];
  8. static int ntrace;
  9. static struct trace {
  10. char *begin_trace, *end_trace;
  11. } trace_buf[MAXTRACE];
  12. static struct message_hdr ok_message;
  13. #define OFF 0
  14. #define SS 1 /* single stepping */
  15. #define SSF 2 /* single stepping, counting functions
  16. as single statements */
  17. static char *
  18. BUFTOA(p)
  19. register char *p;
  20. {
  21. register long l = 0;
  22. register int i;
  23. for (i = PS; i>0; i--) {
  24. l = (l << 8) | (*p++ & 0377);
  25. }
  26. return (char *) l;
  27. }
  28. static long
  29. BUFTOL(p)
  30. register char *p;
  31. {
  32. register long l = 0;
  33. register int i;
  34. for (i = LS; i>0; i--) {
  35. l = (l << 8) | (*p++ & 0377);
  36. }
  37. return l;
  38. }
  39. static
  40. ATOBUF(p, cp)
  41. register char *p;
  42. char *cp;
  43. {
  44. register int i;
  45. register long l = (long) cp;
  46. p += PS;
  47. for (i = PS; i > 0; i--) {
  48. *--p = l;
  49. l >>= 8;
  50. }
  51. }
  52. static
  53. LTOBUF(p, l)
  54. register char *p;
  55. register long l;
  56. {
  57. register int i;
  58. p += LS;
  59. for (i = LS; i > 0; i--) {
  60. *--p = l;
  61. l >>= 8;
  62. }
  63. }
  64. static int single_stepping = OFF;
  65. static int db_ss = 0;
  66. static int step_count = 0;
  67. static char *savedlb;
  68. static int break_flag = 0;
  69. static int reading = 0;
  70. static char *retaddr;
  71. static char *LB;
  72. static char *currbrk;
  73. extern char *__Get_LB();
  74. extern char *__Get_Hol0();
  75. extern char *__Get_PC();
  76. extern char *__Cvt_LB_AB();
  77. extern char *__Get_HP();
  78. extern char *_sbrk();
  79. extern int etext;
  80. extern __Set_PC();
  81. static send_ok();
  82. #define check_ptr(c) (((c) >= (char *)&etext && (c) <= currbrk) || (c) >= LB)
  83. #define IN_FD 3
  84. #define OUT_FD 6
  85. static int
  86. ureceive(p, c)
  87. char *p;
  88. long c;
  89. {
  90. int i;
  91. int retval = 1;
  92. reading = 1;
  93. while (c >= 0x1000) {
  94. i = _read(IN_FD, p, 0x1000);
  95. if (i == 0) return 0;
  96. if (i < 0) {
  97. retval = 0;
  98. c -= 0x1000;
  99. }
  100. else {
  101. p += i;
  102. c -= i;
  103. }
  104. }
  105. while (c > 0) {
  106. i = _read(IN_FD, p, (int)c);
  107. if (i == 0) return 0;
  108. if (i < 0) {
  109. retval = 0;
  110. break;
  111. }
  112. else {
  113. p += i;
  114. c -= i;
  115. }
  116. }
  117. reading = 0;
  118. return retval;
  119. }
  120. static int
  121. usend(p, c)
  122. char *p;
  123. long c;
  124. {
  125. int i;
  126. while (c >= 0x1000) {
  127. i = _write(OUT_FD, p, 0x1000);
  128. if (i < 0) {
  129. return 0;
  130. }
  131. p += i;
  132. c -= i;
  133. }
  134. while (c > 0) {
  135. i = _write(OUT_FD, p, (int)c);
  136. if (i < 0) {
  137. return 0;
  138. }
  139. p += i;
  140. c -= i;
  141. }
  142. return 1;
  143. }
  144. static int
  145. ugetm(message)
  146. struct message_hdr *message;
  147. {
  148. if (! ureceive((char *) message, (long) sizeof(struct message_hdr))) {
  149. return 0;
  150. }
  151. return 1;
  152. }
  153. static int
  154. uputm(message)
  155. struct message_hdr *message;
  156. {
  157. if (! usend((char *) message, (long) sizeof(struct message_hdr))) {
  158. return 0;
  159. }
  160. return 1;
  161. }
  162. static int
  163. sendreply(m, p, sz)
  164. struct message_hdr *m;
  165. char *p;
  166. long sz;
  167. {
  168. if (! uputm(m) || ! (sz && p ? usend(p, sz) : 1)) {
  169. return 0;
  170. }
  171. return 1;
  172. }
  173. static int
  174. do_request()
  175. {
  176. /* obtain a request from the debugger and perform it */
  177. int fail = 0;
  178. register int i;
  179. register char *c;
  180. char *c1;
  181. long sz;
  182. struct message_hdr message;
  183. start:
  184. if (! ugetm(&message)) {
  185. /* failed to get a message. Something is wrong. Let process continue */
  186. return 1;
  187. }
  188. if (message.m_type & M_DB_SS) db_ss = 1;
  189. message.m_type &= 0177;
  190. switch(message.m_type) {
  191. case M_OK:
  192. /* sometimes sent to child to see if it lives */
  193. goto start;
  194. case M_SETBP:
  195. /* set a breakpoint */
  196. if (nbp == MAXBP) {
  197. fail = 1;
  198. break;
  199. }
  200. bp[nbp++] = BUFTOA(message.m_buf+1);
  201. break;
  202. case M_SETTRACE:
  203. if (ntrace == MAXTRACE) {
  204. fail = 1;
  205. break;
  206. }
  207. trace_buf[ntrace].begin_trace = BUFTOA(message.m_buf+1);
  208. trace_buf[ntrace++].end_trace = BUFTOA(message.m_buf+(PS+1));
  209. break;
  210. case M_CLRBP:
  211. i = 0;
  212. c = BUFTOA(message.m_buf+1);
  213. while (i < nbp && bp[i] != c) {
  214. i++;
  215. }
  216. if (i < nbp) {
  217. while (i < nbp) {
  218. bp[i] = bp[i+1];
  219. i++;
  220. }
  221. nbp--;
  222. }
  223. else {
  224. fail = 1;
  225. }
  226. break;
  227. case M_CLRTRACE:
  228. i = 0;
  229. c = BUFTOA(message.m_buf+1);
  230. c1 = BUFTOA(message.m_buf+(PS+1));
  231. while (i < ntrace &&
  232. trace_buf[i].begin_trace != c &&
  233. trace_buf[i].end_trace != c1){
  234. i++;
  235. }
  236. if (i < ntrace) {
  237. while (i < ntrace) {
  238. trace_buf[i] = trace_buf[i+1];
  239. i++;
  240. }
  241. ntrace--;
  242. }
  243. else {
  244. fail = 1;
  245. }
  246. break;
  247. case M_SETSS:
  248. single_stepping = SS;
  249. step_count = BUFTOL(message.m_buf+1);
  250. return 1;
  251. case M_CLRSS:
  252. single_stepping = OFF;
  253. break;
  254. case M_SETSSF:
  255. savedlb = __Get_LB(2);
  256. step_count = BUFTOL(message.m_buf+1);
  257. single_stepping = SSF;
  258. return 1;
  259. case M_GETBYTES:
  260. message.m_type = M_DATA;
  261. sz = BUFTOL(message.m_buf+1);
  262. c = BUFTOA(message.m_buf+(LS+1));
  263. currbrk = _sbrk(0);
  264. if (! check_ptr(c) || ! check_ptr(c+sz-1)) {
  265. fail = 1;
  266. break;
  267. }
  268. return sendreply(&message, c, sz)
  269. ? 0
  270. : -1;
  271. case M_GETSTR:
  272. sz = BUFTOL(message.m_buf+1);
  273. c1 = c = BUFTOA(message.m_buf+(LS+1));
  274. currbrk = _sbrk(0);
  275. if (check_ptr(c)) {
  276. while (*c) {
  277. if (c - c1 + 1 >= sz) break;
  278. c++;
  279. if (! check_ptr(c)) {
  280. fail = 1;
  281. break;
  282. }
  283. }
  284. }
  285. else fail = 1;
  286. if (fail) break;
  287. message.m_type = M_DATA;
  288. sz = c - c1 + 1;
  289. LTOBUF(message.m_buf+1, sz);
  290. return sendreply(&message, c1, sz)
  291. ? 0
  292. : -1;
  293. case M_SETBYTES:
  294. if (! ureceive(BUFTOA(message.m_buf+(LS+1)), BUFTOL(message.m_buf+1))) {
  295. fail = 1;
  296. }
  297. break;
  298. case M_GETEMREGS:
  299. i = BUFTOL(message.m_buf+1);
  300. c = __Get_LB(i+2); /* local base */
  301. c1 = __Get_LB(i+1); /* needed to find PC and SP */
  302. ATOBUF(message.m_buf+LB_OFF, c);
  303. ATOBUF(message.m_buf+AB_OFF, __Cvt_LB_AB(c));
  304. ATOBUF(message.m_buf+PC_OFF, __Get_PC(c1));
  305. ATOBUF(message.m_buf+HP_OFF, __Get_HP());
  306. ATOBUF(message.m_buf+SP_OFF, __Cvt_LB_AB(c1));
  307. return sendreply(&message, (char *) 0, 0L) ? 0 : -1;
  308. case M_SETEMREGS:
  309. /* actually, only the program counter is settable */
  310. i = BUFTOL(message.m_buf+1);
  311. c = __Get_LB(i+1);
  312. __Set_PC(c, BUFTOA(message.m_buf+PC_OFF));
  313. break;
  314. case M_CONT:
  315. return 1;
  316. case M_DUMP:
  317. currbrk = _sbrk(0);
  318. c = __Get_Hol0();
  319. c1 = currbrk;
  320. message.m_type = M_DGLOB;
  321. sz = c1 - c;
  322. LTOBUF(message.m_buf+1, sz);
  323. ATOBUF(message.m_buf + HP_OFF, __Get_HP());
  324. ATOBUF(message.m_buf + PC_OFF, __Get_PC(__Get_LB(1)));
  325. ATOBUF(message.m_buf + LB_OFF, c1);
  326. sendreply(&message, c, sz);
  327. if (! ___topsave()) {
  328. /* we get here after a ___topload() ! */
  329. step_count = 0;
  330. nbp = 0;
  331. single_stepping = 0;
  332. savedlb = 0;
  333. break_flag = 0;
  334. db_ss = 0;
  335. break;
  336. }
  337. return 0;
  338. case M_DGLOB:
  339. _brk(BUFTOA(message.m_buf + LB_OFF));
  340. __Set_HP(BUFTOA(message.m_buf+HP_OFF));
  341. if (! ureceive(__Get_Hol0(), BUFTOL(message.m_buf+1))) {}
  342. ___topload(BUFTOA(message.m_buf + SP_OFF));
  343. /*NOTREACHED*/
  344. }
  345. send_ok(fail ? M_FAIL : M_OK);
  346. return fail ? -1 : 0;
  347. }
  348. ___sendtop(addr, SP, sz)
  349. char *addr, *SP;
  350. unsigned sz;
  351. {
  352. struct message_hdr m;
  353. m.m_type = M_DSTACK;
  354. LTOBUF(m.m_buf+1, (long) sz);
  355. ATOBUF(m.m_buf+SP_OFF, SP);
  356. sendreply(&m, addr, (long)sz);
  357. }
  358. ___restoretop(SP)
  359. char *SP;
  360. {
  361. struct message_hdr m;
  362. if (! ugetm(&m)) {}
  363. if (! ureceive(SP, BUFTOL(m.m_buf+1))) {}
  364. }
  365. static
  366. sigcatch()
  367. {
  368. signal(7, sigcatch);
  369. if (reading) send_ok(M_INTR);
  370. else break_flag = 1;
  371. db_ss = 0;
  372. }
  373. static int
  374. check_bp()
  375. {
  376. register int i;
  377. for (i = 0; i < nbp; i++) {
  378. if (bp[i] == retaddr) {
  379. return 1;
  380. }
  381. }
  382. return 0;
  383. }
  384. static int
  385. check_trace()
  386. {
  387. register int i;
  388. for (i = 0; i < ntrace; i++) {
  389. if (trace_buf[i].begin_trace <= retaddr &&
  390. trace_buf[i].end_trace >= retaddr) {
  391. return 1;
  392. }
  393. }
  394. return 0;
  395. }
  396. static
  397. send_ok(type)
  398. {
  399. register int i;
  400. ok_message.m_type = type;
  401. LTOBUF(ok_message.m_buf+1, (long) retaddr);
  402. uputm(&ok_message);
  403. }
  404. void
  405. __uX_LiB()
  406. /* This function must be called after every LIN and LNI */
  407. {
  408. int status = M_CONT;
  409. LB = __Get_LB(0);
  410. if ( retaddr) {
  411. /* not the first time ... */
  412. retaddr = __Get_PC(LB);
  413. /* first, adjust step_count when single stepping
  414. */
  415. if (single_stepping == SS) step_count--;
  416. else if (single_stepping == SSF) {
  417. char *lb = __Get_LB(1);
  418. if (!((char *) &lb < lb && lb >= savedlb ||
  419. (char *) &lb > lb && lb <= savedlb)) {
  420. }
  421. else {
  422. savedlb = lb;
  423. step_count--;
  424. }
  425. }
  426. if (single_stepping != OFF && step_count <= 0) {
  427. status = M_END_SS;
  428. single_stepping = OFF;
  429. }
  430. else if (break_flag) status = M_INTR;
  431. }
  432. else {
  433. signal(7, sigcatch);
  434. retaddr = __Get_PC(LB);
  435. status = M_OK;
  436. }
  437. if (status == M_CONT) {
  438. if ((nbp != 0 && check_bp() != 0) ||
  439. (ntrace != 0 && check_trace() != 0)) {
  440. status = M_OK;
  441. }
  442. else if (break_flag) status = M_INTR;
  443. else {
  444. if (db_ss) {
  445. db_ss = 0;
  446. send_ok(M_DB_SS);
  447. while (do_request() <= 0) /* nothing */;
  448. }
  449. if (break_flag) status = M_INTR;
  450. else return;
  451. }
  452. }
  453. break_flag = 0;
  454. send_ok(status);
  455. db_ss = 0;
  456. while (do_request() <= 0) /* nothing */;
  457. }