1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #pragma ident "%Z%%M% %I% %E% SMI" 28 29 #include <stdio.h> 30 #include <string.h> 31 #include <stdlib.h> 32 #include <stdarg.h> 33 #include <unistd.h> 34 #include <errno.h> 35 #include <ctype.h> 36 37 #include <fcode/private.h> 38 #include <fcode/log.h> 39 40 #ifndef DEBUG_LVL 41 #define DEBUG_LVL 0 42 #endif 43 44 struct bitab { 45 token_t bi_ptr; 46 char *bi_name; 47 int bi_type; 48 }; 49 50 struct bitab *lookup_builtin(token_t); 51 52 static int debug_level = DEBUG_LVL; 53 54 void 55 set_interpreter_debug_level(long lvl) 56 { 57 debug_level = lvl; 58 } 59 60 long 61 get_interpreter_debug_level(void) 62 { 63 return (debug_level); 64 } 65 66 void 67 output_data_stack(fcode_env_t *env, int msglevel) 68 { 69 int i; 70 71 log_message(msglevel, "( "); 72 if (DS > env->ds0) { 73 for (i = 0; i < (DS - env->ds0); i++) 74 log_message(msglevel, "%llx ", 75 (uint64_t)(env->ds0[i + 1])); 76 } else 77 log_message(msglevel, "<empty> "); 78 log_message(msglevel, ") "); 79 } 80 81 void 82 output_return_stack(fcode_env_t *env, int show_wa, int msglevel) 83 { 84 int i; 85 int anyout = 0; 86 87 log_message(msglevel, "R:( "); 88 if (show_wa) { 89 log_message(msglevel, "%s ", 90 acf_backup_search(env, (acf_t)WA)); 91 anyout++; 92 } 93 if (IP) { 94 anyout++; 95 log_message(msglevel, "%s ", acf_backup_search(env, IP)); 96 } 97 for (i = (RS - env->rs0) - 1; i > 0; i--) { 98 anyout++; 99 log_message(msglevel, "%s ", 100 acf_backup_search(env, (acf_t)env->rs0[i+1])); 101 } 102 if (!anyout) 103 log_message(msglevel, "<empty> "); 104 log_message(msglevel, ") "); 105 } 106 107 void 108 dump_comma(fcode_env_t *env, char *type) 109 { 110 xforth_t d; 111 112 if (strcmp(type, "x,") == 0) 113 d = peek_xforth(env); 114 else 115 d = TOS; 116 log_message(MSG_FC_DEBUG, "%s %p, %llx\n", type, HERE, (uint64_t)d); 117 } 118 119 static int ndebug_names; 120 #define MAXDEBUG_NAMES 10 121 static char *debug_names[MAXDEBUG_NAMES]; 122 123 static int ndebug_acfs; 124 #define MAXDEBUG_ACFS 10 125 static acf_t debug_acfs[MAXDEBUG_ACFS]; 126 127 void 128 add_debug_acf(fcode_env_t *env, acf_t acf) 129 { 130 int i; 131 132 for (i = 0; i < ndebug_acfs; i++) 133 if (acf == debug_acfs[i]) 134 return; 135 136 if (!within_dictionary(env, acf)) 137 log_message(MSG_ERROR, "Can't debug builtin\n"); 138 else if (ndebug_acfs >= MAXDEBUG_ACFS) 139 log_message(MSG_ERROR, "Too many debug ACF's\n"); 140 else { 141 debug_acfs[ndebug_acfs++] = acf; 142 *LINK_TO_FLAGS(ACF_TO_LINK(acf)) |= FLAG_DEBUG; 143 } 144 } 145 146 static void 147 paren_debug(fcode_env_t *env) 148 { 149 acf_t acf; 150 151 acf = (acf_t)POP(DS); 152 if (!within_dictionary(env, acf)) { 153 log_message(MSG_INFO, "acf: %llx not in dictionary\n", 154 (uint64_t)acf); 155 return; 156 } 157 if ((acf_t)_ALIGN(acf, token_t) != acf) { 158 log_message(MSG_INFO, "acf: %llx not aligned\n", 159 (uint64_t)acf); 160 return; 161 } 162 if (*acf != (token_t)(&do_colon)) { 163 log_message(MSG_INFO, "acf: %llx not a colon-def\n", 164 (uint64_t)acf); 165 return; 166 } 167 add_debug_acf(env, acf); 168 } 169 170 static void 171 debug(fcode_env_t *env) 172 { 173 fstack_t d; 174 char *word; 175 acf_t acf; 176 177 parse_word(env); 178 dollar_find(env); 179 d = POP(DS); 180 if (d) { 181 acf = (acf_t)POP(DS); 182 add_debug_acf(env, acf); 183 } else if (ndebug_names >= MAXDEBUG_NAMES) { 184 log_message(MSG_ERROR, "Too many forward debug words\n"); 185 two_drop(env); 186 } else { 187 word = pop_a_duped_string(env, NULL); 188 log_message(MSG_INFO, "Forward defined word: %s\n", word); 189 debug_names[ndebug_names++] = word; 190 } 191 } 192 193 /* 194 * Eliminate dups and add vocabulary forth to end if not already on list. 195 */ 196 static void 197 order_to_dict_list(fcode_env_t *env, token_t *order[]) 198 { 199 int i, j, norder = 0; 200 201 if (env->current) 202 order[norder++] = env->current; 203 for (i = env->order_depth; i >= 0; i--) { 204 for (j = 0; j < norder && order[j] != env->order[i]; j++) 205 ; 206 if (j == norder) 207 order[norder++] = env->order[i]; 208 } 209 for (j = 0; j < norder && order[j] != (token_t *)&env->forth_voc_link; 210 j++) 211 ; 212 if (j == norder) 213 order[norder++] = (token_t *)&env->forth_voc_link; 214 order[norder] = NULL; 215 } 216 217 static acf_t 218 search_all_dictionaries(fcode_env_t *env, 219 acf_t (*fn)(fcode_env_t *, acf_t, void *), 220 void *arg) 221 { 222 token_t *order[MAX_ORDER+1]; 223 int i; 224 token_t *dptr; 225 acf_t acf; 226 227 order_to_dict_list(env, order); 228 for (i = 0; (dptr = order[i]) != NULL; i++) { 229 for (dptr = (token_t *)(*dptr); dptr; 230 dptr = (token_t *)(*dptr)) 231 if ((acf = (*fn)(env, LINK_TO_ACF(dptr), arg)) != NULL) 232 return (acf); 233 } 234 return (NULL); 235 } 236 237 char * 238 acf_to_str(acf_t acf) 239 { 240 static char msg[(sizeof (acf) * 2) + 3]; 241 242 sprintf(msg, "(%08p)", acf); 243 return (msg); 244 } 245 246 char * 247 get_name_or_acf(token_t *dptr) 248 { 249 char *name; 250 251 if ((name = get_name(dptr)) != NULL) 252 return (name); 253 return (acf_to_str(LINK_TO_ACF(dptr))); 254 } 255 256 static void 257 output_acf_name(acf_t acf) 258 { 259 char *name; 260 token_t *dptr; 261 static int acf_count = 0; 262 263 if (acf == NULL) { 264 if (acf_count) 265 log_message(MSG_INFO, "\n"); 266 acf_count = 0; 267 return; 268 } 269 dptr = ACF_TO_LINK(acf); 270 if ((name = get_name(dptr)) == NULL) 271 name = "<noname>"; 272 273 log_message(MSG_INFO, "%24s (%08p)", name, acf); 274 if (++acf_count >= 2) { 275 log_message(MSG_INFO, "\n"); 276 acf_count = 0; 277 } else 278 log_message(MSG_INFO, " "); 279 } 280 281 static void 282 dot_debug(fcode_env_t *env) 283 { 284 int i; 285 token_t *dptr; 286 287 if (ndebug_names == 0) 288 log_message(MSG_INFO, "No forward debug words\n"); 289 else { 290 for (i = 0; i < ndebug_names; i++) 291 log_message(MSG_INFO, "%s Forward\n", debug_names[i]); 292 } 293 if (ndebug_acfs == 0) 294 log_message(MSG_INFO, "No debug words\n"); 295 else { 296 for (i = 0; i < ndebug_acfs; i++) 297 log_message(MSG_INFO, "%s\n", 298 get_name_or_acf(ACF_TO_LINK(debug_acfs[i]))); 299 } 300 } 301 302 static void 303 do_undebug(fcode_env_t *env, char *name) 304 { 305 int i; 306 307 for (i = 0; i < ndebug_names; i++) { 308 if (strcmp(debug_names[i], name) == 0) { 309 log_message(MSG_INFO, "Undebugging forward word %s\n", 310 name); 311 FREE(debug_names[i]); 312 for (i++; i < ndebug_names; i++) 313 debug_names[i - 1] = debug_names[i]; 314 ndebug_names--; 315 break; 316 } 317 } 318 } 319 320 static void 321 undebug(fcode_env_t *env) 322 { 323 fstack_t d; 324 acf_t acf; 325 flag_t *flagp; 326 char *name; 327 int i, j; 328 329 parse_word(env); 330 two_dup(env); 331 dollar_find(env); 332 d = POP(DS); 333 if (d) { 334 acf = (acf_t)POP(DS); 335 flagp = LINK_TO_FLAGS(ACF_TO_LINK(acf)); 336 if ((*flagp & FLAG_DEBUG) == 0) 337 log_message(MSG_WARN, "Word not debugged?\n"); 338 else { 339 log_message(MSG_INFO, "Undebugging acf: %p\n", acf); 340 *flagp &= ~FLAG_DEBUG; 341 for (i = 0; i < ndebug_acfs; i++) { 342 if (debug_acfs[i] == acf) { 343 for (j = i + 1; j < ndebug_acfs; j++) 344 debug_acfs[j-1] = debug_acfs[j]; 345 ndebug_acfs--; 346 break; 347 } 348 } 349 } 350 } else 351 two_drop(env); 352 name = pop_a_string(env, NULL); 353 do_undebug(env, name); 354 } 355 356 int 357 name_is_debugged(fcode_env_t *env, char *name) 358 { 359 int i; 360 361 if (ndebug_names <= 0) 362 return (0); 363 for (i = 0; i < ndebug_names; i++) 364 if (strcmp(debug_names[i], name) == 0) 365 return (1); 366 return (0); 367 } 368 369 /* 370 * This is complicated by being given ACF's to temporary compile words which 371 * don't have a header. 372 */ 373 int 374 is_debug_word(fcode_env_t *env, acf_t acf) 375 { 376 flag_t *flagp; 377 int i; 378 379 /* check to see if any words are being debugged */ 380 if (ndebug_acfs == 0) 381 return (0); 382 383 /* only words in dictionary can be debugged */ 384 if (!within_dictionary(env, acf)) 385 return (0); 386 387 /* check that word has "FLAG_DEBUG" on */ 388 flagp = LINK_TO_FLAGS(ACF_TO_LINK(acf)); 389 if ((*flagp & FLAG_DEBUG) == 0) 390 return (0); 391 392 /* look in table of debug acf's */ 393 for (i = 0; i < ndebug_acfs; i++) 394 if (debug_acfs[i] == acf) 395 return (1); 396 return (0); 397 } 398 399 #define MAX_DEBUG_STACK 100 400 token_t debug_low[MAX_DEBUG_STACK], debug_high[MAX_DEBUG_STACK]; 401 int debug_prev_level[MAX_DEBUG_STACK]; 402 int debug_curr_level[MAX_DEBUG_STACK]; 403 int ndebug_stack = 0; 404 405 void 406 debug_set_level(fcode_env_t *env, int level) 407 { 408 debug_curr_level[ndebug_stack - 1] = level; 409 set_interpreter_debug_level(level); 410 } 411 412 token_t 413 find_semi_in_colon_def(fcode_env_t *env, acf_t acf) 414 { 415 for (; within_dictionary(env, acf); acf++) 416 if (*acf == (token_t)(&semi_ptr)) 417 return ((token_t)acf); 418 return (0); 419 } 420 421 void 422 check_for_debug_entry(fcode_env_t *env) 423 { 424 int top; 425 426 if (is_debug_word(env, WA) && ndebug_stack < MAX_DEBUG_STACK) { 427 top = ndebug_stack++; 428 debug_prev_level[top] = get_interpreter_debug_level(); 429 debug_low[top] = (token_t)WA; 430 if (*WA == (token_t)(&do_colon)) { 431 debug_high[top] = 432 find_semi_in_colon_def(env, WA); 433 } else { 434 debug_high[top] = 0; /* marker... */ 435 } 436 debug_set_level(env, DEBUG_STEPPING); 437 output_step_message(env); 438 } 439 } 440 441 void 442 check_for_debug_exit(fcode_env_t *env) 443 { 444 if (ndebug_stack) { 445 int top = ndebug_stack - 1; 446 447 if (debug_high[top] == 0) { 448 set_interpreter_debug_level(debug_prev_level[top]); 449 ndebug_stack--; 450 } else if ((token_t)IP >= debug_low[top] && 451 (token_t)IP <= debug_high[top]) { 452 set_interpreter_debug_level(debug_curr_level[top]); 453 } else { 454 set_interpreter_debug_level(debug_prev_level[top]); 455 } 456 } 457 } 458 459 void 460 check_semi_debug_exit(fcode_env_t *env) 461 { 462 if (ndebug_stack) { 463 int top = ndebug_stack - 1; 464 465 if ((token_t)(IP - 1) == debug_high[top]) { 466 set_interpreter_debug_level(debug_prev_level[top]); 467 ndebug_stack--; 468 } 469 } 470 } 471 472 /* 473 * Really entering do_run, since this may be a recursive entry to do_run, 474 * we need to set the debug level to what it was previously. 475 */ 476 int 477 current_debug_state(fcode_env_t *env) 478 { 479 if (ndebug_stack) { 480 int top = ndebug_stack - 1; 481 set_interpreter_debug_level(debug_prev_level[top]); 482 } 483 return (ndebug_stack); 484 } 485 486 void 487 clear_debug_state(fcode_env_t *env, int oldstate) 488 { 489 if (ndebug_stack && oldstate <= ndebug_stack) { 490 set_interpreter_debug_level(debug_prev_level[oldstate]); 491 ndebug_stack = oldstate; 492 } 493 } 494 495 void 496 unbug(fcode_env_t *env) 497 { 498 int i; 499 token_t *link; 500 flag_t *flag; 501 502 for (i = ndebug_stack - 1; i >= 0; i--) { 503 link = ACF_TO_LINK(debug_low[i]); 504 flag = LINK_TO_FLAGS(link); 505 *flag &= ~FLAG_DEBUG; 506 } 507 clear_debug_state(env, 0); 508 } 509 510 void 511 output_vitals(fcode_env_t *env) 512 { 513 log_message(MSG_FC_DEBUG, "IP=%p, *IP=%p, WA=%p, *WA=%p ", IP, 514 (IP ? *IP : 0), WA, (WA ? *WA : 0)); 515 } 516 517 int 518 do_exec_debug(fcode_env_t *env, void *fn) 519 { 520 int dl = debug_level; 521 int show_wa = 1; 522 523 if ((dl & (DEBUG_EXEC_DUMP_DS | DEBUG_EXEC_DUMP_RS | 524 DEBUG_EXEC_SHOW_VITALS | DEBUG_EXEC_TRACE | DEBUG_TRACING | 525 DEBUG_STEPPING)) == 0) 526 return (0); 527 528 if (dl & DEBUG_STEPPING) { 529 dl |= DEBUG_EXEC_DUMP_DS; 530 } 531 if (dl & (DEBUG_STEPPING | DEBUG_EXEC_TRACE)) { 532 log_message(MSG_FC_DEBUG, "%-15s ", acf_to_name(env, WA)); 533 show_wa = 0; 534 } 535 if (dl & DEBUG_EXEC_DUMP_DS) 536 output_data_stack(env, MSG_FC_DEBUG); 537 if (dl & DEBUG_EXEC_DUMP_RS) 538 output_return_stack(env, show_wa, MSG_FC_DEBUG); 539 if (dl & DEBUG_EXEC_SHOW_VITALS) 540 output_vitals(env); 541 if (dl & DEBUG_TRACING) 542 do_fclib_trace(env, (void *) fn); 543 log_message(MSG_FC_DEBUG, "\n"); 544 if (dl & DEBUG_STEPPING) 545 return (do_fclib_step(env)); 546 return (0); 547 } 548 549 static void 550 smatch(fcode_env_t *env) 551 { 552 int len; 553 char *str, *p; 554 555 if ((str = parse_a_string(env, &len)) == NULL) 556 log_message(MSG_INFO, "smatch: no string\n"); 557 else { 558 for (p = (char *)env->base; p < (char *)HERE; p++) 559 if (memcmp(p, str, len) == 0) 560 log_message(MSG_DEBUG, "%p\n", p); 561 } 562 } 563 564 void 565 check_vitals(fcode_env_t *env) 566 { 567 int i; 568 token_t *dptr; 569 570 dptr = env->current; 571 if (*dptr && !within_dictionary(env, (uchar_t *)*dptr)) 572 log_message(MSG_ERROR, "Current: %p outside dictionary\n", 573 *dptr); 574 for (i = env->order_depth; i >= 0; i--) { 575 dptr = env->order[i]; 576 if (!dptr) 577 continue; 578 if (*dptr && !within_dictionary(env, (uchar_t *)*dptr)) 579 log_message(MSG_ERROR, "Order%d: %p outside" 580 " dictionary\n", i, *dptr); 581 } 582 if (HERE < env->base || HERE >= env->base + dict_size) { 583 log_message(MSG_ERROR, "HERE: %p outside range\n", HERE); 584 } 585 if (DS < env->ds0 || DS >= &env->ds0[stack_size]) { 586 forth_abort(env, "DS: %p outside range\n", DS); 587 } 588 if (RS < env->rs0 || RS >= &env->rs0[stack_size]) { 589 log_message(MSG_ERROR, "RS: %p outside range\n", RS); 590 RS = env->rs0; 591 } 592 if (IP && !within_dictionary(env, IP)) 593 log_message(MSG_ERROR, "IP: %p outside dictionary\n", IP); 594 if (!within_dictionary(env, (void *)env->forth_voc_link)) 595 log_message(MSG_ERROR, "forth_voc_link: %p outside" 596 " dictionary\n", env->forth_voc_link); 597 } 598 599 static void 600 dump_table(fcode_env_t *env) 601 { 602 int i; 603 604 for (i = 0; i < MAX_FCODE; i++) { 605 if (*(env->table[i].apf) != (token_t)(&f_error)) { 606 log_message(MSG_DEBUG, "Token: %4x %32s acf = %8p," 607 " %8p\n", i, env->table[i].name, env->table[i].apf, 608 *(env->table[i].apf)); 609 } 610 } 611 log_message(MSG_DEBUG, "%d FCODES implemented\n", fcode_impl_count); 612 } 613 614 void 615 verify_usage(fcode_env_t *env) 616 { 617 int i, untested = 0; 618 619 for (i = 0; i < MAX_FCODE; i++) { 620 int verify; 621 622 verify = env->table[i].flags & (ANSI_WORD|P1275_WORD); 623 if ((verify) && 624 #ifdef DEBUG 625 (env->table[i].usage == 0) && 626 #endif 627 (env->table[i].apf)) { 628 log_message(MSG_DEBUG, 629 "Untested: %4x %32s acf = %8p, %8p\n", i, 630 env->table[i].name, env->table[i].apf, 631 *(env->table[i].apf)); 632 untested++; 633 } 634 } 635 if (untested) 636 log_message(MSG_DEBUG, "%d untested tokens\n", untested); 637 } 638 639 static void 640 debugf(fcode_env_t *env) 641 { 642 PUSH(DS, (fstack_t)&debug_level); 643 } 644 645 static void 646 control(fcode_env_t *env) 647 { 648 PUSH(DS, (fstack_t)&env->control); 649 } 650 651 struct bittab { 652 int b_bitval; 653 char *b_bitname; 654 } bittab[] = { 655 DEBUG_CONTEXT, "context", 656 DEBUG_BYTELOAD_DS, "byteload-ds", 657 DEBUG_BYTELOAD_RS, "byteload-rs", 658 DEBUG_BYTELOAD_TOKENS, "byteload-tokens", 659 DEBUG_NEW_TOKEN, "new-token", 660 DEBUG_EXEC_TRACE, "exec-trace", 661 DEBUG_EXEC_SHOW_VITALS, "exec-show-vitals", 662 DEBUG_EXEC_DUMP_DS, "exec-dump-ds", 663 DEBUG_EXEC_DUMP_RS, "exec-dump-rs", 664 DEBUG_COMMA, "comma", 665 DEBUG_HEADER, "header", 666 DEBUG_EXIT_WORDS, "exit-words", 667 DEBUG_EXIT_DUMP, "exit-dump", 668 DEBUG_DUMP_TOKENS, "dump-tokens", 669 DEBUG_COLON, "colon", 670 DEBUG_NEXT_VITALS, "next-vitals", 671 DEBUG_VOC_FIND, "voc-find", 672 DEBUG_DUMP_DICT_TOKENS, "dump-dict-tokens", 673 DEBUG_TOKEN_USAGE, "token-usage", 674 DEBUG_DUMP_TOKEN_TABLE, "dump-token-table", 675 DEBUG_SHOW_STACK, "show-stack", 676 DEBUG_SHOW_RS, "show-rs", 677 DEBUG_TRACING, "tracing", 678 DEBUG_TRACE_STACK, "trace-stack", 679 DEBUG_CALL_METHOD, "call-method", 680 DEBUG_ACTIONS, "actions", 681 DEBUG_STEPPING, "stepping", 682 DEBUG_REG_ACCESS, "reg-access", 683 DEBUG_ADDR_ABUSE, "addr-abuse", 684 DEBUG_FIND_FCODE, "find-fcode", 685 DEBUG_UPLOAD, "upload", 686 0 687 }; 688 689 void 690 debug_flags_to_output(fcode_env_t *env, int flags) 691 { 692 int first = 1, i; 693 694 for (i = 0; bittab[i].b_bitval != 0; i++) 695 if (bittab[i].b_bitval & flags) { 696 if (!first) 697 log_message(MSG_INFO, ","); 698 first = 0; 699 log_message(MSG_INFO, bittab[i].b_bitname); 700 } 701 if (first) 702 log_message(MSG_INFO, "<empty>"); 703 log_message(MSG_INFO, "\n"); 704 } 705 706 static void 707 dot_debugf(fcode_env_t *env) 708 { 709 debug_flags_to_output(env, debug_level); 710 } 711 712 static void 713 debugf_qmark(fcode_env_t *env) 714 { 715 debug_flags_to_output(env, 0xffffffff); 716 } 717 718 int 719 debug_flags_to_mask(char *str) 720 { 721 int flags = 0; 722 char *p; 723 int i; 724 725 if (isdigit(*str)) { 726 if (*str == '0') { 727 str++; 728 if (*str == 'x' || *str == 'X') { 729 sscanf(str + 1, "%x", &flags); 730 } else 731 sscanf(str, "%o", &flags); 732 } else 733 sscanf(str, "%d", &flags); 734 return (flags); 735 } 736 if (strcmp(str, "clear") == 0) 737 return (0); 738 if (strcmp(str, "all") == 0) 739 return (0xffffffff & ~DEBUG_STEPPING); 740 if (*str) { 741 do { 742 if (p = strchr(str, ',')) 743 *p++ = '\0'; 744 for (i = 0; bittab[i].b_bitname != 0; i++) 745 if (strcmp(str, bittab[i].b_bitname) == 0) { 746 flags |= bittab[i].b_bitval; 747 break; 748 } 749 if (bittab[i].b_bitname == 0) 750 log_message(MSG_WARN, 751 "Unknown debug flag: '%s'\n", str); 752 str = p; 753 } while (p); 754 } 755 return (flags); 756 } 757 758 static void 759 set_debugf(fcode_env_t *env) 760 { 761 char *str; 762 763 str = parse_a_string(env, NULL); 764 debug_level = debug_flags_to_mask(str); 765 } 766 767 static acf_t 768 show_a_word(fcode_env_t *env, acf_t acf, void *arg) 769 { 770 static int nshow_words = 0; 771 772 if (acf == NULL) { 773 if (nshow_words > 0) { 774 log_message(MSG_DEBUG, "\n"); 775 nshow_words = 0; 776 } 777 return (NULL); 778 } 779 log_message(MSG_DEBUG, "%15s ", get_name_or_acf(ACF_TO_LINK(acf))); 780 nshow_words++; 781 if (nshow_words >= 4) { 782 log_message(MSG_DEBUG, "\n"); 783 nshow_words = 0; 784 } 785 return (NULL); 786 } 787 788 void 789 words(fcode_env_t *env) 790 { 791 (void) search_all_dictionaries(env, show_a_word, NULL); 792 (void) show_a_word(env, NULL, NULL); 793 } 794 795 static acf_t 796 dump_a_word(fcode_env_t *env, acf_t acf, void *arg) 797 { 798 output_acf_name(acf); 799 return (NULL); 800 } 801 802 void 803 dump_words(fcode_env_t *env) 804 { 805 (void) search_all_dictionaries(env, dump_a_word, NULL); 806 output_acf_name(NULL); 807 } 808 809 static void 810 dump_line(uchar_t *ptr) 811 { 812 uchar_t *byte; 813 int i; 814 815 log_message(MSG_INFO, "%p ", ptr); 816 for (i = 0, byte = ptr; i < 16; i++) { 817 if (i == 8) 818 log_message(MSG_INFO, " "); 819 log_message(MSG_INFO, "%02.2x ", *byte++); 820 } 821 log_message(MSG_INFO, " "); 822 for (i = 0, byte = ptr; i < 16; i++, byte++) { 823 log_message(MSG_INFO, "%c", 824 ((*byte < 0x20) || (*byte > 0x7f)) ? '.' : *byte); 825 } 826 log_message(MSG_INFO, "\n"); 827 } 828 829 void 830 dump_dictionary(fcode_env_t *env) 831 { 832 uchar_t *ptr; 833 834 log_message(MSG_INFO, "Dictionary dump: base: %p\n", env->base); 835 for (ptr = (uchar_t *)(((long)(env->base)) & ~0xf); ptr < HERE; 836 ptr += 16) 837 dump_line(ptr); 838 } 839 840 static char * 841 acf_to_fcode_name(fcode_env_t *env, acf_t acf) 842 { 843 int i; 844 845 for (i = 0; i < MAX_FCODE; i++) 846 if (env->table[i].apf == acf) 847 return (env->table[i].name); 848 return (NULL); 849 } 850 851 static acf_t 852 acf_match(fcode_env_t *env, acf_t sacf, void *macf) 853 { 854 if (sacf == (acf_t)macf) 855 return (sacf); 856 return (NULL); 857 } 858 859 /* 860 * Given an ACF, return ptr to name or "unknown" string. 861 */ 862 char * 863 acf_to_name(fcode_env_t *env, acf_t acf) 864 { 865 struct bitab *bip; 866 static char name_buf[256]; 867 uchar_t *p, *np; 868 int i, n; 869 870 if (!within_dictionary(env, acf)) { 871 if ((bip = lookup_builtin((token_t)acf)) != NULL) 872 return (bip->bi_name); 873 return (NULL); 874 } 875 return (get_name_or_acf(ACF_TO_LINK(acf))); 876 } 877 878 int 879 within_dictionary(fcode_env_t *env, void *addr) 880 { 881 return ((uchar_t *)addr >= env->base && 882 (uchar_t *)addr < env->base + dict_size); 883 } 884 885 static int 886 within_word(fcode_env_t *env, acf_t acf, acf_t wacf) 887 { 888 if (acf == wacf || acf + 1 == wacf) 889 return (1); 890 if (*acf == (token_t)(&do_colon)) { 891 do { 892 if (acf == wacf) 893 return (1); 894 } while (*acf++ != (token_t)(&semi_ptr)); 895 } 896 return (0); 897 } 898 899 /* 900 * Given an ACF in the middle of a colon definition, search dictionary towards 901 * beginning for "colon" acf. If we find a "semi" acf first, we're not in 902 * the middle of a colon-def (temporary execute?). 903 */ 904 char * 905 acf_backup_search(fcode_env_t *env, acf_t acf) 906 { 907 acf_t nacf; 908 char *name; 909 910 if ((acf_t)_ALIGN(acf, token_t) == acf && within_dictionary(env, acf)) { 911 for (nacf = acf; nacf >= (acf_t)env->base; nacf--) 912 if (*nacf == (token_t)(&do_colon) || 913 *nacf == (token_t)(&semi_ptr)) 914 break; 915 if (nacf >= (acf_t)env->base && *nacf == (token_t)(&do_colon) && 916 (name = get_name(ACF_TO_LINK(nacf))) != NULL) 917 return (name); 918 } 919 return (acf_to_str(acf)); 920 } 921 922 /* 923 * Print out current process's C stack using /usr/proc/bin/pstack 924 */ 925 void 926 ctrace(fcode_env_t *env) 927 { 928 char buf[256]; 929 FILE *fd; 930 931 log_message(MSG_DEBUG, "Interpreter C Stack:\n"); 932 sprintf(buf, "/usr/proc/bin/pstack %d", getpid()); 933 if ((fd = popen(buf, "r")) == NULL) 934 log_perror(MSG_ERROR, "Can't run: %s", buf); 935 else { 936 while (fgets(buf, sizeof (buf), fd)) 937 log_message(MSG_DEBUG, buf); 938 fclose(fd); 939 } 940 } 941 942 /* 943 * Dump data, return stacks, try to unthread forth calling stack. 944 */ 945 void 946 ftrace(fcode_env_t *env) 947 { 948 log_message(MSG_DEBUG, "Forth Interpreter Stacks:\n"); 949 output_data_stack(env, MSG_DEBUG); 950 output_return_stack(env, 1, MSG_DEBUG); 951 log_message(MSG_DEBUG, "\n"); 952 } 953 954 int in_forth_abort; 955 956 /* 957 * Handle fatal error, if interactive mode, return to ok prompt. 958 */ 959 void 960 forth_abort(fcode_env_t *env, char *fmt, ...) 961 { 962 va_list ap; 963 char msg[256]; 964 965 if (in_forth_abort) { 966 log_message(MSG_FATAL, "ABORT: abort within forth_abort\n"); 967 abort(); 968 } 969 in_forth_abort++; 970 971 va_start(ap, fmt); 972 vsprintf(msg, fmt, ap); 973 log_message(MSG_ERROR, "ABORT: %s\n", msg); 974 975 if (env) { 976 ctrace(env); 977 ftrace(env); 978 } 979 980 return_to_interact(env); 981 /* 982 * If not in interactive mode, return_to_interact just returns. 983 */ 984 exit(1); 985 } 986 987 /* 988 * Handle fatal system call error 989 */ 990 void 991 forth_perror(fcode_env_t *env, char *fmt, ...) 992 { 993 va_list ap; 994 char msg[256]; 995 int save_errno = errno; /* just in case... */ 996 997 va_start(ap, fmt); 998 vsprintf(msg, fmt, ap); 999 1000 forth_abort(env, "%s: %s", msg, strerror(save_errno)); 1001 } 1002 1003 static void 1004 show_stack(fcode_env_t *env) 1005 { 1006 #ifdef DEBUG 1007 debug_level ^= DEBUG_SHOW_STACK; 1008 #else 1009 /*EMPTY*/ 1010 #endif 1011 } 1012 1013 static void 1014 print_bytes_header(int width, int offset) 1015 { 1016 int i; 1017 1018 for (i = 0; i < width; i++) 1019 log_message(MSG_INFO, " "); 1020 log_message(MSG_INFO, " "); 1021 for (i = 0; i < 16; i++) { 1022 if (i == 8) 1023 log_message(MSG_INFO, " "); 1024 if (i == offset) 1025 log_message(MSG_INFO, "\\/ "); 1026 else 1027 log_message(MSG_INFO, "%2x ", i); 1028 } 1029 log_message(MSG_INFO, " "); 1030 for (i = 0; i < 16; i++) { 1031 if (i == offset) 1032 log_message(MSG_INFO, "v"); 1033 else 1034 log_message(MSG_INFO, "%x", i); 1035 } 1036 log_message(MSG_INFO, "\n"); 1037 } 1038 1039 static void 1040 dump(fcode_env_t *env) 1041 { 1042 uchar_t *data; 1043 int len, offset; 1044 char buf[20]; 1045 1046 len = POP(DS); 1047 data = (uchar_t *)POP(DS); 1048 offset = ((long)data) & 0xf; 1049 len += offset; 1050 data = (uchar_t *)((long)data & ~0xf); 1051 sprintf(buf, "%p", data); 1052 print_bytes_header(strlen(buf), offset); 1053 for (len += offset; len > 0; len -= 16, data += 16) 1054 dump_line(data); 1055 } 1056 1057 static acf_t 1058 do_sifting(fcode_env_t *env, acf_t acf, void *pat) 1059 { 1060 char *name; 1061 1062 if ((name = get_name(ACF_TO_LINK(acf))) != NULL && strstr(name, pat)) 1063 output_acf_name(acf); 1064 return (NULL); 1065 } 1066 1067 static void 1068 sifting(fcode_env_t *env) 1069 { 1070 char *pat; 1071 1072 if ((pat = parse_a_string(env, NULL)) != NULL) { 1073 (void) search_all_dictionaries(env, do_sifting, pat); 1074 output_acf_name(NULL); 1075 } 1076 } 1077 1078 void 1079 print_level(int level, int *doprint) 1080 { 1081 int i; 1082 1083 if (*doprint) { 1084 log_message(MSG_DEBUG, "\n "); 1085 for (i = 0; i < level; i++) 1086 log_message(MSG_DEBUG, " "); 1087 *doprint = 0; 1088 } 1089 } 1090 1091 #define BI_QUOTE 1 1092 #define BI_BLIT 2 1093 #define BI_BDO 3 1094 #define BI_QDO 4 1095 #define BI_BR 5 1096 #define BI_QBR 6 1097 #define BI_BOF 7 1098 #define BI_LOOP 8 1099 #define BI_PLOOP 9 1100 #define BI_TO 10 1101 #define BI_SEMI 11 1102 #define BI_COLON 12 1103 #define BI_NOOP 13 1104 #define BI_NOTYET 14 /* unimplented in "see" */ 1105 1106 struct bitab bitab[] = { 1107 (token_t)("e_ptr), "\"", BI_QUOTE, 1108 (token_t)(&blit_ptr), "blit", BI_BLIT, 1109 (token_t)(&do_bdo_ptr), "do", BI_BDO, 1110 (token_t)(&do_bqdo_ptr), "?do", BI_QDO, 1111 (token_t)(&bbranch_ptrs[0]), "br", BI_BR, 1112 (token_t)(&bbranch_ptrs[1]), "qbr", BI_QBR, 1113 (token_t)(&bbranch_ptrs[2]), "bof", BI_BOF, 1114 (token_t)(&do_loop_ptr), "loop", BI_LOOP, 1115 (token_t)(&do_ploop_ptr), "+loop", BI_PLOOP, 1116 (token_t)(&to_ptr), "to", BI_NOOP, 1117 (token_t)(&semi_ptr), ";", BI_SEMI, 1118 (token_t)(&do_colon), ":", BI_COLON, 1119 (token_t)(&tlit_ptr), "[']", BI_NOOP, 1120 (token_t)(&do_leave_ptr), "leave", BI_NOTYET, 1121 (token_t)(&create_ptr), "create", BI_NOTYET, 1122 (token_t)(&does_ptr), "does>", BI_NOTYET, 1123 (token_t)(&value_defines[0][0]), "a.@", BI_NOTYET, 1124 (token_t)(&value_defines[0][1]), "a.!", BI_NOTYET, 1125 (token_t)(&value_defines[0][2]), "a.nop", BI_NOTYET, 1126 (token_t)(&value_defines[1][0]), "a.i@", BI_NOTYET, 1127 (token_t)(&value_defines[1][1]), "a.i!", BI_NOTYET, 1128 (token_t)(&value_defines[1][2]), "a.iad", BI_NOTYET, 1129 (token_t)(&value_defines[2][0]), "a.defer", BI_NOTYET, 1130 (token_t)(&value_defines[2][1]), "a.@", BI_NOTYET, 1131 (token_t)(&value_defines[2][2]), "a.nop", BI_NOTYET, 1132 (token_t)(&value_defines[3][0]), "a.defexec", BI_NOTYET, 1133 (token_t)(&value_defines[3][1]), "a.iset", BI_NOTYET, 1134 (token_t)(&value_defines[3][2]), "a.iad", BI_NOTYET, 1135 (token_t)(&value_defines[4][0]), "a.binit", BI_NOTYET, 1136 (token_t)(&value_defines[4][1]), "a.2drop", BI_NOTYET, 1137 (token_t)(&value_defines[4][2]), "a.nop", BI_NOTYET, 1138 (token_t)(&value_defines[5][0]), "a.ibinit", BI_NOTYET, 1139 (token_t)(&value_defines[5][1]), "a.2drop", BI_NOTYET, 1140 (token_t)(&value_defines[5][2]), "a.iad", BI_NOTYET, 1141 0 1142 }; 1143 1144 struct bitab * 1145 lookup_builtin(token_t builtin) 1146 { 1147 int i; 1148 1149 for (i = 0; bitab[i].bi_ptr; i++) 1150 if (bitab[i].bi_ptr == builtin) 1151 return (&bitab[i]); 1152 return (NULL); 1153 } 1154 1155 static void 1156 paren_see(fcode_env_t *env) 1157 { 1158 acf_t save_acf = (acf_t)POP(DS); 1159 acf_t acf = save_acf; 1160 int i, n, pass; 1161 token_t brtab[30], thentab[30], brstk[30]; 1162 int nbrtab = 0, nthentab = 0, nbrstk = 0; 1163 uchar_t *p; 1164 int level = 0, doprintlevel = 1, nthen; 1165 struct bitab *bip; 1166 token_t last_lit = 0, case_lit = 0, endof_loc = 0, endcase_loc = 0; 1167 1168 if ((bip = lookup_builtin(*acf)) == NULL || 1169 bip->bi_type != BI_COLON) { 1170 if (bip = lookup_builtin((token_t)acf)) 1171 log_message(MSG_INFO, "%s: builtin\n", bip->bi_name); 1172 else 1173 log_message(MSG_INFO, "%s: builtin\n", 1174 acf_to_name(env, acf)); 1175 return; 1176 } 1177 log_message(MSG_INFO, ": %s", acf_to_name(env, acf)); 1178 for (pass = 0; pass < 2; pass++) { 1179 acf = save_acf; 1180 for (acf++; ; acf++) { 1181 if (pass) { 1182 print_level(level, &doprintlevel); 1183 for (nthen = 0; nthentab > 0 && 1184 thentab[nthentab-1] == (token_t)acf; 1185 nthentab--) 1186 nthen++; 1187 if (nthen) { 1188 level -= nthen; 1189 doprintlevel = 1; 1190 print_level(level, &doprintlevel); 1191 for (i = 0; i < nthen; i++) 1192 log_message(MSG_INFO, "then "); 1193 } 1194 print_level(level, &doprintlevel); 1195 for (i = 0; i < nbrtab; i += 2) 1196 if ((token_t)acf == brtab[i]) { 1197 log_message(MSG_INFO, "begin "); 1198 brstk[nbrstk++] = brtab[i+1]; 1199 level++; 1200 doprintlevel = 1; 1201 } 1202 print_level(level, &doprintlevel); 1203 if (case_lit == (token_t)acf) { 1204 log_message(MSG_INFO, "case "); 1205 doprintlevel = 1; 1206 print_level(level, &doprintlevel); 1207 } 1208 if (endof_loc == (token_t)acf) { 1209 log_message(MSG_INFO, "endof "); 1210 doprintlevel = 1; 1211 print_level(level, &doprintlevel); 1212 } 1213 if (endcase_loc == (token_t)acf) { 1214 doprintlevel = 1; 1215 print_level(level, &doprintlevel); 1216 log_message(MSG_INFO, "endcase "); 1217 } 1218 } 1219 if ((bip = lookup_builtin((token_t)*acf)) == 0) { 1220 last_lit = (token_t)acf; 1221 if (pass) 1222 log_message(MSG_INFO, "%s ", 1223 acf_to_name(env, (acf_t)*acf)); 1224 continue; 1225 } 1226 if (bip->bi_type == BI_SEMI) { 1227 if (pass) { 1228 log_message(MSG_INFO, "\n"); 1229 log_message(MSG_INFO, "%s\n", 1230 bip->bi_name); 1231 } 1232 break; 1233 } 1234 switch (bip->bi_type) { 1235 1236 case BI_NOOP: 1237 case BI_NOTYET: 1238 if (pass) 1239 log_message(MSG_INFO, "%s ", 1240 bip->bi_name); 1241 break; 1242 1243 case BI_QUOTE: 1244 if (pass) 1245 log_message(MSG_INFO, "\" "); 1246 acf++; 1247 p = (uchar_t *)acf; 1248 n = *p++; 1249 if (pass) 1250 log_message(MSG_INFO, "%s\" ", p); 1251 p += n + 1; 1252 for (; ((token_t)(p)) & (sizeof (token_t) - 1); 1253 p++) 1254 ; 1255 acf = (acf_t)p; 1256 acf--; 1257 break; 1258 1259 case BI_BLIT: 1260 acf++; 1261 if (pass) 1262 log_message(MSG_INFO, "%x ", *acf); 1263 break; 1264 1265 case BI_BDO: 1266 case BI_QDO: 1267 if (pass) { 1268 log_message(MSG_INFO, "%s ", 1269 bip->bi_name); 1270 doprintlevel = 1; 1271 level++; 1272 } 1273 acf++; 1274 break; 1275 1276 case BI_BR: 1277 acf++; 1278 if (pass) { 1279 if (*acf < (token_t)acf) { 1280 if (nbrstk) { 1281 doprintlevel = 1; 1282 level--; 1283 print_level(level, 1284 &doprintlevel); 1285 log_message(MSG_INFO, 1286 "repeat "); 1287 nbrstk--; 1288 } else 1289 log_message(MSG_INFO, 1290 "[br back?]"); 1291 } else if (nthentab) { 1292 doprintlevel = 1; 1293 print_level(level - 1, 1294 &doprintlevel); 1295 log_message(MSG_INFO, "else "); 1296 doprintlevel = 1; 1297 thentab[nthentab - 1] = *acf; 1298 } 1299 } else { 1300 if (*acf < (token_t)acf) { 1301 brtab[nbrtab++] = *acf; 1302 brtab[nbrtab++] = (token_t)acf; 1303 } 1304 if (endcase_loc == 0 && 1305 case_lit) { 1306 endcase_loc = *acf; 1307 } 1308 } 1309 break; 1310 1311 case BI_QBR: 1312 acf++; 1313 if (pass) { 1314 if (*acf < (token_t)acf) { 1315 if (nbrstk) { 1316 doprintlevel = 1; 1317 level--; 1318 print_level(level, 1319 &doprintlevel); 1320 log_message(MSG_INFO, 1321 "until "); 1322 nbrstk--; 1323 } else 1324 log_message(MSG_INFO, 1325 "[br back?]"); 1326 } else if (nbrstk > 0 && 1327 *acf >= brstk[nbrstk - 1]) { 1328 doprintlevel = 1; 1329 print_level(level - 1, 1330 &doprintlevel); 1331 log_message(MSG_INFO, 1332 "while "); 1333 doprintlevel = 1; 1334 } else { 1335 log_message(MSG_INFO, "if "); 1336 doprintlevel = 1; 1337 level++; 1338 thentab[nthentab++] = *acf; 1339 } 1340 } else if (*acf < (token_t)acf) { 1341 brtab[nbrtab++] = *acf; 1342 brtab[nbrtab++] = (token_t)acf; 1343 } 1344 break; 1345 1346 case BI_BOF: 1347 acf++; 1348 if (pass) { 1349 log_message(MSG_INFO, "of "); 1350 endof_loc = *acf; 1351 } else if (case_lit == 0) { 1352 case_lit = last_lit; 1353 } 1354 break; 1355 1356 case BI_LOOP: 1357 case BI_PLOOP: 1358 if (pass) { 1359 level--; 1360 doprintlevel = 1; 1361 print_level(level, &doprintlevel); 1362 log_message(MSG_INFO, "%s ", 1363 bip->bi_name); 1364 } 1365 acf++; 1366 break; 1367 1368 default: 1369 log_message(MSG_ERROR, "Invalid builtin %s\n", 1370 bip->bi_name); 1371 } 1372 } 1373 } 1374 } 1375 1376 static void 1377 see(fcode_env_t *env) 1378 { 1379 fstack_t d; 1380 1381 parse_word(env); 1382 dollar_find(env); 1383 d = POP(DS); 1384 if (d) 1385 paren_see(env); 1386 else { 1387 log_message(MSG_WARN, "?"); 1388 two_drop(env); 1389 } 1390 } 1391 1392 static acf_t 1393 do_dot_calls(fcode_env_t *env, acf_t acf, void *cacf) 1394 { 1395 token_t *dptr = ACF_TO_LINK(acf); 1396 token_t *wptr = acf; 1397 1398 if (*wptr == (token_t)(&do_colon)) { 1399 do { 1400 if ((acf_t)(*wptr) == (acf_t)cacf) 1401 output_acf_name(acf); 1402 } while (*wptr++ != (token_t)(&semi_ptr)); 1403 } else if ((acf_t)(*wptr) == cacf) 1404 output_acf_name(acf); 1405 else if (wptr == (token_t *)cacf) 1406 output_acf_name(acf); 1407 return (NULL); 1408 } 1409 1410 static void 1411 dot_calls(fcode_env_t *env) 1412 { 1413 acf_t acf = (acf_t)POP(DS); 1414 1415 search_all_dictionaries(env, do_dot_calls, acf); 1416 output_acf_name(NULL); 1417 } 1418 1419 static void 1420 dot_pci_space(fcode_env_t *env) 1421 { 1422 fstack_t d = POP(DS); 1423 1424 switch ((d >> 24) & 0x3) { 1425 case 0: log_message(MSG_INFO, "Config,"); break; 1426 case 1: log_message(MSG_INFO, "IO,"); break; 1427 case 2: log_message(MSG_INFO, "Memory32,"); break; 1428 case 3: log_message(MSG_INFO, "Memory64,"); break; 1429 } 1430 if (d & 0x80000000) 1431 log_message(MSG_INFO, "Not_reloc,"); 1432 if (d & 0x400000000) 1433 log_message(MSG_INFO, "Prefetch,"); 1434 if (d & 0x200000000) 1435 log_message(MSG_INFO, "Alias,"); 1436 log_message(MSG_INFO, "Bus%d,", (d >> 16) & 0xff); 1437 log_message(MSG_INFO, "Dev%d,", (d >> 11) & 0x1f); 1438 log_message(MSG_INFO, "Func%d,", (d >> 8) & 0x7); 1439 log_message(MSG_INFO, "Reg%x", d & 0xff); 1440 log_message(MSG_INFO, "\n"); 1441 } 1442 1443 void 1444 fcode_debug(fcode_env_t *env) 1445 { 1446 PUSH(DS, (fstack_t)(&env->fcode_debug)); 1447 } 1448 1449 static void 1450 base_addr(fcode_env_t *env) 1451 { 1452 PUSH(DS, (fstack_t)env->base); 1453 } 1454 1455 static int mw_valid; 1456 static int mw_size; 1457 static void *mw_addr; 1458 static fstack_t mw_value; 1459 static fstack_t mw_lastvalue; 1460 1461 static fstack_t 1462 mw_fetch(void) 1463 { 1464 switch (mw_size) { 1465 case 1: return (*((uint8_t *)mw_addr)); 1466 case 2: return (*((uint16_t *)mw_addr)); 1467 case 4: return (*((uint32_t *)mw_addr)); 1468 case 8: return (*((uint64_t *)mw_addr)); 1469 } 1470 return (0); 1471 } 1472 1473 void 1474 do_memory_watch(fcode_env_t *env) 1475 { 1476 fstack_t value; 1477 1478 if (!mw_valid) 1479 return; 1480 value = mw_fetch(); 1481 if (value != mw_lastvalue) { 1482 if (mw_valid == 1 || mw_value == value) { 1483 log_message(MSG_INFO, 1484 "memory-watch: %p/%d: %llx -> %llx\n", 1485 mw_addr, mw_size, (uint64_t)mw_lastvalue, 1486 (uint64_t)value); 1487 do_fclib_step(env); 1488 } 1489 mw_lastvalue = value; 1490 } 1491 } 1492 1493 static void 1494 set_memory_watch(fcode_env_t *env, int type, int size, void *addr, 1495 fstack_t value) 1496 { 1497 switch (size) { 1498 case 1: case 2: case 4: case 8: 1499 break; 1500 default: 1501 log_message(MSG_ERROR, "set_memory_watch: invalid size: %d\n", 1502 size); 1503 return; 1504 } 1505 mw_valid = type; 1506 mw_size = size; 1507 mw_addr = addr; 1508 mw_value = value; 1509 mw_lastvalue = mw_fetch(); 1510 } 1511 1512 static void 1513 memory_watch(fcode_env_t *env) 1514 { 1515 int size = POP(DS); 1516 void *addr = (void *)POP(DS); 1517 1518 set_memory_watch(env, 1, size, addr, 0); 1519 } 1520 1521 static void 1522 memory_watch_value(fcode_env_t *env) 1523 { 1524 int size = POP(DS); 1525 void *addr = (void *)POP(DS); 1526 fstack_t value = POP(DS); 1527 1528 set_memory_watch(env, 2, size, addr, value); 1529 } 1530 1531 static void 1532 memory_watch_clear(fcode_env_t *env) 1533 { 1534 mw_valid = 0; 1535 } 1536 1537 static void 1538 vsearch(fcode_env_t *env) 1539 { 1540 fstack_t value; 1541 int size = POP(DS); 1542 fstack_t match_value = POP(DS); 1543 uchar_t *toaddr = (uchar_t *)POP(DS); 1544 uchar_t *fromaddr = (uchar_t *)POP(DS); 1545 1546 log_message(MSG_INFO, "%p to %p by %d looking for %llx\n", fromaddr, 1547 toaddr, size, (uint64_t)match_value); 1548 for (; fromaddr < toaddr; fromaddr += size) { 1549 switch (size) { 1550 case 1: value = *((uint8_t *)fromaddr); break; 1551 case 2: value = *((uint16_t *)fromaddr); break; 1552 case 4: value = *((uint32_t *)fromaddr); break; 1553 case 8: value = *((uint64_t *)fromaddr); break; 1554 default: 1555 log_message(MSG_INFO, "Invalid size: %d\n", size); 1556 return; 1557 } 1558 if (value == match_value) 1559 log_message(MSG_INFO, "%p\n", fromaddr); 1560 } 1561 } 1562 1563 #pragma init(_init) 1564 1565 static void 1566 _init(void) 1567 { 1568 fcode_env_t *env = initial_env; 1569 1570 ASSERT(env); 1571 NOTICE; 1572 1573 FORTH(IMMEDIATE, "words", words); 1574 FORTH(IMMEDIATE, "dump-words", dump_words); 1575 FORTH(IMMEDIATE, "dump-dict", dump_dictionary); 1576 FORTH(IMMEDIATE, "dump-table", dump_table); 1577 FORTH(0, "debugf", debugf); 1578 FORTH(0, ".debugf", dot_debugf); 1579 FORTH(0, "set-debugf", set_debugf); 1580 FORTH(0, "debugf?", debugf_qmark); 1581 FORTH(0, "control", control); 1582 FORTH(0, "dump", dump); 1583 FORTH(IMMEDIATE, "showstack", show_stack); 1584 FORTH(IMMEDIATE, "sifting", sifting); 1585 FORTH(IMMEDIATE, "ctrace", ctrace); 1586 FORTH(IMMEDIATE, "ftrace", ftrace); 1587 FORTH(0, "see", see); 1588 FORTH(0, "(see)", paren_see); 1589 FORTH(0, "base-addr", base_addr); 1590 FORTH(0, "smatch", smatch); 1591 FORTH(0, ".calls", dot_calls); 1592 FORTH(0, ".pci-space", dot_pci_space); 1593 FORTH(0, "(debug)", paren_debug); 1594 FORTH(0, "debug", debug); 1595 FORTH(0, ".debug", dot_debug); 1596 FORTH(0, "undebug", undebug); 1597 FORTH(0, "memory-watch", memory_watch); 1598 FORTH(0, "memory-watch-value", memory_watch_value); 1599 FORTH(0, "memory-watch-clear", memory_watch_clear); 1600 FORTH(0, "vsearch", vsearch); 1601 } 1602