![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to runtime.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / dbx|
Return to runtime.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / dbx |
1.1 ! root 1: /* ! 2: * Copyright (c) 1983 Regents of the University of California. ! 3: * All rights reserved. The Berkeley software License Agreement ! 4: * specifies the terms and conditions for redistribution. ! 5: */ ! 6: ! 7: #ifndef lint ! 8: static char sccsid[] = "@(#)runtime.c 5.2 (Berkeley) 1/10/86"; ! 9: #endif not lint ! 10: ! 11: static char rcsid[] = "$Header: runtime.c,v 1.5 84/12/26 10:41:52 linton Exp $"; ! 12: ! 13: /* ! 14: * Runtime organization dependent routines, mostly dealing with ! 15: * activation records. ! 16: */ ! 17: ! 18: #include "defs.h" ! 19: #include "runtime.h" ! 20: #include "process.h" ! 21: #include "machine.h" ! 22: #include "events.h" ! 23: #include "mappings.h" ! 24: #include "symbols.h" ! 25: #include "tree.h" ! 26: #include "eval.h" ! 27: #include "operators.h" ! 28: #include "object.h" ! 29: #include <sys/param.h> ! 30: ! 31: #ifndef public ! 32: typedef struct Frame *Frame; ! 33: ! 34: #include "machine.h" ! 35: #endif ! 36: ! 37: #define NSAVEREG 12 ! 38: ! 39: struct Frame { ! 40: integer condition_handler; ! 41: integer mask; ! 42: Address save_ap; /* argument pointer */ ! 43: Address save_fp; /* frame pointer */ ! 44: Address save_pc; /* program counter */ ! 45: Word save_reg[NSAVEREG]; /* not necessarily there */ ! 46: }; ! 47: ! 48: private Frame curframe = nil; ! 49: private struct Frame curframerec; ! 50: private Boolean walkingstack = false; ! 51: ! 52: #define frameeq(f1, f2) ((f1)->save_fp == (f2)->save_fp) ! 53: ! 54: #define isstackaddr(addr) \ ! 55: (((addr) < 0x80000000) and ((addr) > 0x80000000 - 0x200 * UPAGES)) ! 56: ! 57: typedef struct { ! 58: Node callnode; ! 59: Node cmdnode; ! 60: boolean isfunc; ! 61: } CallEnv; ! 62: ! 63: private CallEnv endproc; ! 64: ! 65: /* ! 66: * Set a frame to the current activation record. ! 67: */ ! 68: ! 69: private getcurframe(frp) ! 70: Frame frp; ! 71: { ! 72: register int i; ! 73: ! 74: checkref(frp); ! 75: frp->mask = reg(NREG); ! 76: frp->save_ap = reg(ARGP); ! 77: frp->save_fp = reg(FRP); ! 78: frp->save_pc = reg(PROGCTR); ! 79: for (i = 0; i < NSAVEREG; i++) { ! 80: frp->save_reg[i] = reg(i); ! 81: } ! 82: } ! 83: ! 84: /* ! 85: * Get the saved registers from one frame to another ! 86: * given mask specifying which registers were actually saved. ! 87: */ ! 88: ! 89: #define bis(b, n) ((b & (1 << (n))) != 0) ! 90: ! 91: private getsaveregs (newfrp, frp, mask) ! 92: Frame newfrp, frp; ! 93: integer mask; ! 94: { ! 95: integer i, j; ! 96: ! 97: j = 0; ! 98: for (i = 0; i < NSAVEREG; i++) { ! 99: if (bis(mask, i)) { ! 100: newfrp->save_reg[i] = frp->save_reg[j]; ! 101: ++j; ! 102: } ! 103: } ! 104: } ! 105: ! 106: /* ! 107: * Return a pointer to the next activation record up the stack. ! 108: * Return nil if there is none. ! 109: * Writes over space pointed to by given argument. ! 110: */ ! 111: ! 112: private Frame nextframe(frp) ! 113: Frame frp; ! 114: { ! 115: Frame newfrp; ! 116: struct Frame frame; ! 117: integer mask; ! 118: Address prev_frame, callpc; ! 119: static integer ntramp = 0; ! 120: ! 121: newfrp = frp; ! 122: prev_frame = frp->save_fp; ! 123: ! 124: /* ! 125: * The check for interrupt generated frames is taken from adb with only ! 126: * partial understanding. If you're in "sub" and on a sigxxx "sigsub" ! 127: * gets control, then the stack does NOT look like <main, sub, sigsub>. ! 128: * ! 129: * As best I can make out it looks like: ! 130: * ! 131: * <main, (machine check exception block + sub), sysframe, sigsub>. ! 132: * ! 133: * When the signal occurs an exception block and a frame for the routine ! 134: * in which it occured are pushed on the user stack. Then another frame ! 135: * is pushed corresponding to a call from the kernel to sigsub. ! 136: * ! 137: * The addr in sub at which the exception occured is not in sub.save_pc ! 138: * but in the machine check exception block. It is at the magic address ! 139: * fp + 84. ! 140: * ! 141: * The current approach ignores the sys_frame (what adb reports as sigtramp) ! 142: * and takes the pc for sub from the exception block. This allows the ! 143: * "where" command to report <main, sub, sigsub>, which seems reasonable. ! 144: */ ! 145: ! 146: nextf: ! 147: dread(&frame, prev_frame, sizeof(struct Frame)); ! 148: if (ntramp == 1) { ! 149: dread(&callpc, prev_frame + 84, sizeof(callpc)); ! 150: } else { ! 151: callpc = frame.save_pc; ! 152: } ! 153: if (frame.save_fp == nil or frame.save_pc == (Address) -1) { ! 154: newfrp = nil; ! 155: } else if (isstackaddr(callpc)) { ! 156: ntramp++; ! 157: prev_frame = frame.save_fp; ! 158: goto nextf; ! 159: } else { ! 160: frame.save_pc = callpc; ! 161: ntramp = 0; ! 162: mask = ((frame.mask >> 16) & 0x0fff); ! 163: getsaveregs(newfrp, &frame, mask); ! 164: newfrp->condition_handler = frame.condition_handler; ! 165: newfrp->mask = mask; ! 166: newfrp->save_ap = frame.save_ap; ! 167: newfrp->save_fp = frame.save_fp; ! 168: newfrp->save_pc = frame.save_pc; ! 169: } ! 170: return newfrp; ! 171: } ! 172: ! 173: /* ! 174: * Get the current frame information in the given Frame and store the ! 175: * associated function in the given value-result parameter. ! 176: */ ! 177: ! 178: private getcurfunc (frp, fp) ! 179: Frame frp; ! 180: Symbol *fp; ! 181: { ! 182: getcurframe(frp); ! 183: *fp = whatblock(frp->save_pc); ! 184: } ! 185: ! 186: /* ! 187: * Return the frame associated with the next function up the call stack, or ! 188: * nil if there is none. The function is returned in a value-result parameter. ! 189: * For "inline" functions the statically outer function and same frame ! 190: * are returned. ! 191: */ ! 192: ! 193: public Frame nextfunc (frp, fp) ! 194: Frame frp; ! 195: Symbol *fp; ! 196: { ! 197: Symbol t; ! 198: Frame nfrp; ! 199: ! 200: t = *fp; ! 201: checkref(t); ! 202: if (isinline(t)) { ! 203: t = container(t); ! 204: nfrp = frp; ! 205: } else { ! 206: nfrp = nextframe(frp); ! 207: if (nfrp == nil) { ! 208: t = nil; ! 209: } else { ! 210: t = whatblock(nfrp->save_pc); ! 211: } ! 212: } ! 213: *fp = t; ! 214: return nfrp; ! 215: } ! 216: ! 217: /* ! 218: * Return the frame associated with the given function. ! 219: * If the function is nil, return the most recently activated frame. ! 220: * ! 221: * Static allocation for the frame. ! 222: */ ! 223: ! 224: public Frame findframe(f) ! 225: Symbol f; ! 226: { ! 227: Frame frp; ! 228: static struct Frame frame; ! 229: Symbol p; ! 230: Boolean done; ! 231: ! 232: frp = &frame; ! 233: getcurframe(frp); ! 234: if (f != nil) { ! 235: if (f == curfunc and curframe != nil) { ! 236: *frp = *curframe; ! 237: } else { ! 238: done = false; ! 239: p = whatblock(frp->save_pc); ! 240: do { ! 241: if (p == f) { ! 242: done = true; ! 243: } else if (p == program) { ! 244: done = true; ! 245: frp = nil; ! 246: } else { ! 247: frp = nextfunc(frp, &p); ! 248: if (frp == nil) { ! 249: done = true; ! 250: } ! 251: } ! 252: } while (not done); ! 253: } ! 254: } ! 255: return frp; ! 256: } ! 257: ! 258: /* ! 259: * Set the registers according to the given frame pointer. ! 260: */ ! 261: ! 262: public getnewregs (addr) ! 263: Address addr; ! 264: { ! 265: struct Frame frame; ! 266: integer i, j, mask; ! 267: ! 268: dread(&frame, addr, sizeof(frame)); ! 269: setreg(ARGP, frame.save_ap); ! 270: setreg(FRP, frame.save_fp); ! 271: setreg(PROGCTR, frame.save_pc); ! 272: mask = ((frame.mask >> 16) & 0x0fff); ! 273: j = 0; ! 274: for (i = 0; i < NSAVEREG; i++) { ! 275: if (bis(mask, i)) { ! 276: setreg(i, frame.save_reg[j]); ! 277: ++j; ! 278: } ! 279: } ! 280: pc = frame.save_pc; ! 281: setcurfunc(whatblock(pc)); ! 282: } ! 283: ! 284: /* ! 285: * Find the return address of the current procedure/function. ! 286: */ ! 287: ! 288: public Address return_addr() ! 289: { ! 290: Frame frp; ! 291: Address addr; ! 292: struct Frame frame; ! 293: ! 294: frp = &frame; ! 295: getcurframe(frp); ! 296: frp = nextframe(frp); ! 297: if (frp == nil) { ! 298: addr = 0; ! 299: } else { ! 300: addr = frp->save_pc; ! 301: } ! 302: return addr; ! 303: } ! 304: ! 305: /* ! 306: * Push the value associated with the current function. ! 307: */ ! 308: ! 309: public pushretval(len, isindirect) ! 310: integer len; ! 311: boolean isindirect; ! 312: { ! 313: Word r0; ! 314: ! 315: r0 = reg(0); ! 316: if (isindirect) { ! 317: rpush((Address) r0, len); ! 318: } else { ! 319: switch (len) { ! 320: case sizeof(char): ! 321: push(char, r0); ! 322: break; ! 323: ! 324: case sizeof(short): ! 325: push(short, r0); ! 326: break; ! 327: ! 328: default: ! 329: if (len == sizeof(Word)) { ! 330: push(Word, r0); ! 331: } else if (len == 2*sizeof(Word)) { ! 332: push(Word, r0); ! 333: push(Word, reg(1)); ! 334: } else { ! 335: error("[internal error: bad size %d in pushretval]", len); ! 336: } ! 337: break; ! 338: } ! 339: } ! 340: } ! 341: ! 342: /* ! 343: * Return the base address for locals in the given frame. ! 344: */ ! 345: ! 346: public Address locals_base(frp) ! 347: Frame frp; ! 348: { ! 349: return (frp == nil) ? reg(FRP) : frp->save_fp; ! 350: } ! 351: ! 352: /* ! 353: * Return the base address for arguments in the given frame. ! 354: */ ! 355: ! 356: public Address args_base(frp) ! 357: Frame frp; ! 358: { ! 359: return (frp == nil) ? reg(ARGP) : frp->save_ap; ! 360: } ! 361: ! 362: /* ! 363: * Return saved register n from the given frame. ! 364: */ ! 365: ! 366: public Word savereg(n, frp) ! 367: integer n; ! 368: Frame frp; ! 369: { ! 370: Word w; ! 371: ! 372: if (frp == nil) { ! 373: w = reg(n); ! 374: } else { ! 375: switch (n) { ! 376: case ARGP: ! 377: w = frp->save_ap; ! 378: break; ! 379: ! 380: case FRP: ! 381: w = frp->save_fp; ! 382: break; ! 383: ! 384: case STKP: ! 385: w = reg(STKP); ! 386: break; ! 387: ! 388: case PROGCTR: ! 389: w = frp->save_pc; ! 390: break; ! 391: ! 392: default: ! 393: assert(n >= 0 and n < NSAVEREG); ! 394: w = frp->save_reg[n]; ! 395: break; ! 396: } ! 397: } ! 398: return w; ! 399: } ! 400: ! 401: /* ! 402: * Return the nth argument to the current procedure. ! 403: */ ! 404: ! 405: public Word argn(n, frp) ! 406: integer n; ! 407: Frame frp; ! 408: { ! 409: Word w; ! 410: ! 411: dread(&w, args_base(frp) + (n * sizeof(Word)), sizeof(w)); ! 412: return w; ! 413: } ! 414: ! 415: /* ! 416: * Print a list of currently active blocks starting with most recent. ! 417: */ ! 418: ! 419: public wherecmd() ! 420: { ! 421: walkstack(false); ! 422: } ! 423: ! 424: /* ! 425: * Print the variables in the given frame or the current one if nil. ! 426: */ ! 427: ! 428: public dump (func) ! 429: Symbol func; ! 430: { ! 431: Symbol f; ! 432: Frame frp; ! 433: ! 434: if (func == nil) { ! 435: f = curfunc; ! 436: if (curframe != nil) { ! 437: frp = curframe; ! 438: } else { ! 439: frp = findframe(f); ! 440: } ! 441: } else { ! 442: f = func; ! 443: frp = findframe(f); ! 444: } ! 445: showaggrs = true; ! 446: printcallinfo(f, frp); ! 447: dumpvars(f, frp); ! 448: } ! 449: ! 450: /* ! 451: * Dump all values. ! 452: */ ! 453: ! 454: public dumpall () ! 455: { ! 456: walkstack(true); ! 457: } ! 458: ! 459: /* ! 460: * Walk the stack of active procedures printing information ! 461: * about each active procedure. ! 462: */ ! 463: ! 464: private walkstack(dumpvariables) ! 465: Boolean dumpvariables; ! 466: { ! 467: Frame frp; ! 468: boolean save; ! 469: Symbol f; ! 470: struct Frame frame; ! 471: ! 472: if (notstarted(process) or isfinished(process)) { ! 473: error("program is not active"); ! 474: } else { ! 475: save = walkingstack; ! 476: walkingstack = true; ! 477: showaggrs = dumpvariables; ! 478: frp = &frame; ! 479: getcurfunc(frp, &f); ! 480: for (;;) { ! 481: printcallinfo(f, frp); ! 482: if (dumpvariables) { ! 483: dumpvars(f, frp); ! 484: putchar('\n'); ! 485: } ! 486: frp = nextfunc(frp, &f); ! 487: if (frp == nil or f == program) { ! 488: break; ! 489: } ! 490: } ! 491: if (dumpvariables) { ! 492: printf("in \"%s\":\n", symname(program)); ! 493: dumpvars(program, nil); ! 494: putchar('\n'); ! 495: } ! 496: walkingstack = save; ! 497: } ! 498: } ! 499: ! 500: /* ! 501: * Print out the information about a call, i.e., ! 502: * routine name, parameter values, and source location. ! 503: */ ! 504: ! 505: private printcallinfo (f, frp) ! 506: Symbol f; ! 507: Frame frp; ! 508: { ! 509: Lineno line; ! 510: Address savepc; ! 511: ! 512: savepc = frp->save_pc; ! 513: if (frp->save_fp != reg(FRP)) { ! 514: savepc -= 1; ! 515: } ! 516: printname(stdout, f); ! 517: if (not isinline(f)) { ! 518: printparams(f, frp); ! 519: } ! 520: line = srcline(savepc); ! 521: if (line != 0) { ! 522: printf(", line %d", line); ! 523: printf(" in \"%s\"\n", srcfilename(savepc)); ! 524: } else { ! 525: printf(" at 0x%x\n", savepc); ! 526: } ! 527: } ! 528: ! 529: /* ! 530: * Set the current function to the given symbol. ! 531: * We must adjust "curframe" so that subsequent operations are ! 532: * not confused; for simplicity we simply clear it. ! 533: */ ! 534: ! 535: public setcurfunc (f) ! 536: Symbol f; ! 537: { ! 538: curfunc = f; ! 539: curframe = nil; ! 540: } ! 541: ! 542: /* ! 543: * Return the frame for the current function. ! 544: * The space for the frame is allocated statically. ! 545: */ ! 546: ! 547: public Frame curfuncframe () ! 548: { ! 549: static struct Frame frame; ! 550: Frame frp; ! 551: ! 552: if (curframe == nil) { ! 553: frp = findframe(curfunc); ! 554: curframe = &curframerec; ! 555: *curframe = *frp; ! 556: } else { ! 557: frp = &frame; ! 558: *frp = *curframe; ! 559: } ! 560: return frp; ! 561: } ! 562: ! 563: /* ! 564: * Set curfunc to be N up/down the stack from its current value. ! 565: */ ! 566: ! 567: public up (n) ! 568: integer n; ! 569: { ! 570: integer i; ! 571: Symbol f; ! 572: Frame frp; ! 573: boolean done; ! 574: ! 575: if (not isactive(program)) { ! 576: error("program is not active"); ! 577: } else if (curfunc == nil) { ! 578: error("no current function"); ! 579: } else { ! 580: i = 0; ! 581: f = curfunc; ! 582: frp = curfuncframe(); ! 583: done = false; ! 584: do { ! 585: if (frp == nil) { ! 586: done = true; ! 587: error("not that many levels"); ! 588: } else if (i >= n) { ! 589: done = true; ! 590: curfunc = f; ! 591: curframe = &curframerec; ! 592: *curframe = *frp; ! 593: showaggrs = false; ! 594: printcallinfo(curfunc, curframe); ! 595: } else if (f == program) { ! 596: done = true; ! 597: error("not that many levels"); ! 598: } else { ! 599: frp = nextfunc(frp, &f); ! 600: } ! 601: ++i; ! 602: } while (not done); ! 603: } ! 604: } ! 605: ! 606: public down (n) ! 607: integer n; ! 608: { ! 609: integer i, depth; ! 610: Frame frp, curfrp; ! 611: Symbol f; ! 612: struct Frame frame; ! 613: ! 614: if (not isactive(program)) { ! 615: error("program is not active"); ! 616: } else if (curfunc == nil) { ! 617: error("no current function"); ! 618: } else { ! 619: depth = 0; ! 620: frp = &frame; ! 621: getcurfunc(frp, &f); ! 622: if (curframe == nil) { ! 623: curfrp = findframe(curfunc); ! 624: curframe = &curframerec; ! 625: *curframe = *curfrp; ! 626: } ! 627: while ((f != curfunc or !frameeq(frp, curframe)) and f != nil) { ! 628: frp = nextfunc(frp, &f); ! 629: ++depth; ! 630: } ! 631: if (f == nil or n > depth) { ! 632: error("not that many levels"); ! 633: } else { ! 634: depth -= n; ! 635: frp = &frame; ! 636: getcurfunc(frp, &f); ! 637: for (i = 0; i < depth; i++) { ! 638: frp = nextfunc(frp, &f); ! 639: assert(frp != nil); ! 640: } ! 641: curfunc = f; ! 642: *curframe = *frp; ! 643: showaggrs = false; ! 644: printcallinfo(curfunc, curframe); ! 645: } ! 646: } ! 647: } ! 648: ! 649: /* ! 650: * Find the entry point of a procedure or function. ! 651: */ ! 652: ! 653: public findbeginning (f) ! 654: Symbol f; ! 655: { ! 656: if (isinternal(f)) { ! 657: f->symvalue.funcv.beginaddr += 15; ! 658: } else { ! 659: f->symvalue.funcv.beginaddr += 2; ! 660: } ! 661: } ! 662: ! 663: /* ! 664: * Return the address corresponding to the first line in a function. ! 665: */ ! 666: ! 667: public Address firstline(f) ! 668: Symbol f; ! 669: { ! 670: Address addr; ! 671: ! 672: addr = codeloc(f); ! 673: while (linelookup(addr) == 0 and addr < objsize) { ! 674: ++addr; ! 675: } ! 676: if (addr == objsize) { ! 677: addr = -1; ! 678: } ! 679: return addr; ! 680: } ! 681: ! 682: /* ! 683: * Catcher drops strike three ... ! 684: */ ! 685: ! 686: public runtofirst() ! 687: { ! 688: Address addr; ! 689: ! 690: addr = pc; ! 691: while (linelookup(addr) == 0 and addr < objsize) { ! 692: ++addr; ! 693: } ! 694: if (addr < objsize) { ! 695: stepto(addr); ! 696: } ! 697: } ! 698: ! 699: /* ! 700: * Return the address corresponding to the end of the program. ! 701: * ! 702: * We look for the entry to "exit". ! 703: */ ! 704: ! 705: public Address lastaddr() ! 706: { ! 707: Symbol s; ! 708: ! 709: s = lookup(identname("exit", true)); ! 710: if (s == nil) { ! 711: panic("can't find exit"); ! 712: } ! 713: return codeloc(s); ! 714: } ! 715: ! 716: /* ! 717: * Decide if the given function is currently active. ! 718: * ! 719: * We avoid calls to "findframe" during a stack trace for efficiency. ! 720: * Presumably information evaluated while walking the stack is active. ! 721: */ ! 722: ! 723: public Boolean isactive(f) ! 724: Symbol f; ! 725: { ! 726: Boolean b; ! 727: ! 728: if (isfinished(process)) { ! 729: b = false; ! 730: } else { ! 731: if (walkingstack or f == program or ! 732: (ismodule(f) and isactive(container(f)))) { ! 733: b = true; ! 734: } else { ! 735: b = (Boolean) (findframe(f) != nil); ! 736: } ! 737: } ! 738: return b; ! 739: } ! 740: ! 741: /* ! 742: * Evaluate a call to a procedure. ! 743: */ ! 744: ! 745: public callproc(exprnode, isfunc) ! 746: Node exprnode; ! 747: boolean isfunc; ! 748: { ! 749: Node procnode, arglist; ! 750: Symbol proc; ! 751: integer argc; ! 752: ! 753: procnode = exprnode->value.arg[0]; ! 754: arglist = exprnode->value.arg[1]; ! 755: if (procnode->op != O_SYM) { ! 756: beginerrmsg(); ! 757: fprintf(stderr, "can't call \""); ! 758: prtree(stderr, procnode); ! 759: fprintf(stderr, "\""); ! 760: enderrmsg(); ! 761: } ! 762: assert(procnode->op == O_SYM); ! 763: proc = procnode->value.sym; ! 764: if (not isblock(proc)) { ! 765: error("\"%s\" is not a procedure or function", symname(proc)); ! 766: } ! 767: endproc.isfunc = isfunc; ! 768: endproc.callnode = exprnode; ! 769: endproc.cmdnode = topnode; ! 770: pushenv(); ! 771: pc = codeloc(proc); ! 772: argc = pushargs(proc, arglist); ! 773: beginproc(proc, argc); ! 774: event_once( ! 775: build(O_EQ, build(O_SYM, pcsym), build(O_SYM, retaddrsym)), ! 776: buildcmdlist(build(O_PROCRTN, proc)) ! 777: ); ! 778: isstopped = false; ! 779: if (not bpact()) { ! 780: isstopped = true; ! 781: cont(0); ! 782: } ! 783: /* ! 784: * bpact() won't return true, it will call printstatus() and go back ! 785: * to command input if a breakpoint is found. ! 786: */ ! 787: /* NOTREACHED */ ! 788: } ! 789: ! 790: /* ! 791: * Push the arguments on the process' stack. We do this by first ! 792: * evaluating them on the "eval" stack, then copying into the process' ! 793: * space. ! 794: */ ! 795: ! 796: private integer pushargs(proc, arglist) ! 797: Symbol proc; ! 798: Node arglist; ! 799: { ! 800: Stack *savesp; ! 801: int argc, args_size; ! 802: ! 803: savesp = sp; ! 804: if (varIsSet("$unsafecall")) { ! 805: argc = unsafe_evalargs(proc, arglist); ! 806: } else { ! 807: argc = evalargs(proc, arglist); ! 808: } ! 809: args_size = sp - savesp; ! 810: setreg(STKP, reg(STKP) - args_size); ! 811: dwrite(savesp, reg(STKP), args_size); ! 812: sp = savesp; ! 813: return argc; ! 814: } ! 815: ! 816: /* ! 817: * Check to see if an expression is correct for a given parameter. ! 818: * If the given parameter is false, don't worry about type inconsistencies. ! 819: * ! 820: * Return whether or not it is ok. ! 821: */ ! 822: ! 823: private boolean chkparam (actual, formal, chk) ! 824: Node actual; ! 825: Symbol formal; ! 826: boolean chk; ! 827: { ! 828: boolean b; ! 829: ! 830: b = true; ! 831: if (chk) { ! 832: if (formal == nil) { ! 833: beginerrmsg(); ! 834: fprintf(stderr, "too many parameters"); ! 835: b = false; ! 836: } else if (not compatible(formal->type, actual->nodetype)) { ! 837: beginerrmsg(); ! 838: fprintf(stderr, "type mismatch for %s", symname(formal)); ! 839: b = false; ! 840: } ! 841: } ! 842: if (b and formal != nil and ! 843: isvarparam(formal) and not isopenarray(formal->type) and ! 844: not ( ! 845: actual->op == O_RVAL or actual->nodetype == t_addr or ! 846: ( ! 847: actual->op == O_TYPERENAME and ! 848: ( ! 849: actual->value.arg[0]->op == O_RVAL or ! 850: actual->value.arg[0]->nodetype == t_addr ! 851: ) ! 852: ) ! 853: ) ! 854: ) { ! 855: beginerrmsg(); ! 856: fprintf(stderr, "expected variable, found \""); ! 857: prtree(stderr, actual); ! 858: fprintf(stderr, "\""); ! 859: b = false; ! 860: } ! 861: return b; ! 862: } ! 863: ! 864: /* ! 865: * Pass an expression to a particular parameter. ! 866: * ! 867: * Normally we pass either the address or value, but in some cases ! 868: * (such as C strings) we want to copy the value onto the stack and ! 869: * pass its address. ! 870: * ! 871: * Another special case raised by strings is the possibility that ! 872: * the actual parameter will be larger than the formal, even with ! 873: * appropriate type-checking. This occurs because we assume during ! 874: * evaluation that strings are null-terminated, whereas some languages, ! 875: * notably Pascal, do not work under that assumption. ! 876: */ ! 877: ! 878: private passparam (actual, formal) ! 879: Node actual; ! 880: Symbol formal; ! 881: { ! 882: boolean b; ! 883: Address addr; ! 884: Stack *savesp; ! 885: integer actsize, formsize; ! 886: ! 887: if (formal != nil and isvarparam(formal) and ! 888: (not isopenarray(formal->type)) ! 889: ) { ! 890: addr = lval(actual->value.arg[0]); ! 891: push(Address, addr); ! 892: } else if (passaddr(formal, actual->nodetype)) { ! 893: savesp = sp; ! 894: eval(actual); ! 895: actsize = sp - savesp; ! 896: setreg(STKP, ! 897: reg(STKP) - ((actsize + sizeof(Word) - 1) & ~(sizeof(Word) - 1)) ! 898: ); ! 899: dwrite(savesp, reg(STKP), actsize); ! 900: sp = savesp; ! 901: push(Address, reg(STKP)); ! 902: if (formal != nil and isopenarray(formal->type)) { ! 903: push(integer, actsize div size(formal->type->type)); ! 904: } ! 905: } else if (formal != nil) { ! 906: formsize = size(formal); ! 907: savesp = sp; ! 908: eval(actual); ! 909: actsize = sp - savesp; ! 910: if (actsize > formsize) { ! 911: sp -= (actsize - formsize); ! 912: } ! 913: } else { ! 914: eval(actual); ! 915: } ! 916: } ! 917: ! 918: /* ! 919: * Evaluate an argument list left-to-right. ! 920: */ ! 921: ! 922: private integer evalargs(proc, arglist) ! 923: Symbol proc; ! 924: Node arglist; ! 925: { ! 926: Node p, actual; ! 927: Symbol formal; ! 928: Stack *savesp; ! 929: integer count; ! 930: boolean chk; ! 931: ! 932: savesp = sp; ! 933: count = 0; ! 934: formal = proc->chain; ! 935: chk = (boolean) (not nosource(proc)); ! 936: for (p = arglist; p != nil; p = p->value.arg[1]) { ! 937: assert(p->op == O_COMMA); ! 938: actual = p->value.arg[0]; ! 939: if (not chkparam(actual, formal, chk)) { ! 940: fprintf(stderr, " in call to %s", symname(proc)); ! 941: sp = savesp; ! 942: enderrmsg(); ! 943: } ! 944: passparam(actual, formal); ! 945: if (formal != nil) { ! 946: formal = formal->chain; ! 947: } ! 948: ++count; ! 949: } ! 950: if (chk) { ! 951: if (formal != nil) { ! 952: sp = savesp; ! 953: error("not enough parameters to %s", symname(proc)); ! 954: } ! 955: } ! 956: return count; ! 957: } ! 958: ! 959: /* ! 960: * Evaluate an argument list without concern for matching the formal ! 961: * parameters of a function in type or quantity. Useful for functions ! 962: * like C's printf(). ! 963: */ ! 964: ! 965: private integer unsafe_evalargs(proc, arglist) ! 966: Symbol proc; ! 967: Node arglist; ! 968: { ! 969: Node p; ! 970: Integer count; ! 971: ! 972: count = 0; ! 973: for (p = arglist; p != nil; p = p->value.arg[1]) { ! 974: assert(p->op == O_COMMA); ! 975: eval(p->value.arg[0]); ! 976: ++count; ! 977: } ! 978: return count; ! 979: } ! 980: ! 981: public procreturn(f) ! 982: Symbol f; ! 983: { ! 984: integer retvalsize; ! 985: Node tmp; ! 986: char *copy; ! 987: ! 988: flushoutput(); ! 989: popenv(); ! 990: if (endproc.isfunc) { ! 991: retvalsize = size(f->type); ! 992: if (retvalsize > sizeof(long)) { ! 993: pushretval(retvalsize, true); ! 994: copy = newarr(char, retvalsize); ! 995: popn(retvalsize, copy); ! 996: tmp = build(O_SCON, copy); ! 997: } else { ! 998: tmp = build(O_LCON, (long) (reg(0))); ! 999: } ! 1000: tmp->nodetype = f->type; ! 1001: tfree(endproc.callnode); ! 1002: *(endproc.callnode) = *(tmp); ! 1003: dispose(tmp); ! 1004: eval(endproc.cmdnode); ! 1005: } else { ! 1006: putchar('\n'); ! 1007: printname(stdout, f); ! 1008: printf(" returns successfully\n", symname(f)); ! 1009: } ! 1010: erecover(); ! 1011: } ! 1012: ! 1013: /* ! 1014: * Push the current environment. ! 1015: */ ! 1016: ! 1017: private pushenv() ! 1018: { ! 1019: push(Address, pc); ! 1020: push(Lineno, curline); ! 1021: push(String, cursource); ! 1022: push(Boolean, isstopped); ! 1023: push(Symbol, curfunc); ! 1024: push(Frame, curframe); ! 1025: push(struct Frame, curframerec); ! 1026: push(CallEnv, endproc); ! 1027: push(Word, reg(PROGCTR)); ! 1028: push(Word, reg(STKP)); ! 1029: } ! 1030: ! 1031: /* ! 1032: * Pop back to the real world. ! 1033: */ ! 1034: ! 1035: public popenv() ! 1036: { ! 1037: String filename; ! 1038: ! 1039: setreg(STKP, pop(Word)); ! 1040: setreg(PROGCTR, pop(Word)); ! 1041: endproc = pop(CallEnv); ! 1042: curframerec = pop(struct Frame); ! 1043: curframe = pop(Frame); ! 1044: curfunc = pop(Symbol); ! 1045: isstopped = pop(Boolean); ! 1046: filename = pop(String); ! 1047: curline = pop(Lineno); ! 1048: pc = pop(Address); ! 1049: setsource(filename); ! 1050: } ! 1051: ! 1052: /* ! 1053: * Flush the debuggee's standard output. ! 1054: * ! 1055: * This is VERY dependent on the use of stdio. ! 1056: */ ! 1057: ! 1058: public flushoutput() ! 1059: { ! 1060: Symbol p, iob; ! 1061: Stack *savesp; ! 1062: ! 1063: p = lookup(identname("fflush", true)); ! 1064: while (p != nil and not isblock(p)) { ! 1065: p = p->next_sym; ! 1066: } ! 1067: if (p != nil) { ! 1068: iob = lookup(identname("_iob", true)); ! 1069: if (iob != nil) { ! 1070: pushenv(); ! 1071: pc = codeloc(p); ! 1072: savesp = sp; ! 1073: push(long, address(iob, nil) + sizeof(struct _iobuf)); ! 1074: setreg(STKP, reg(STKP) - sizeof(long)); ! 1075: dwrite(savesp, reg(STKP), sizeof(long)); ! 1076: sp = savesp; ! 1077: beginproc(p, 1); ! 1078: stepto(return_addr()); ! 1079: popenv(); ! 1080: } ! 1081: } ! 1082: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.