![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trpfpe_.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / usr.lib / libF77|
Return to trpfpe_.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / usr.lib / libF77 |
1.1 ! root 1: /* #define OLD_BSD if you're running < 4.2 bsd */ ! 2: /* ! 3: * Copyright (c) 1980 Regents of the University of California. ! 4: * All rights reserved. The Berkeley software License Agreement ! 5: * specifies the terms and conditions for redistribution. ! 6: * ! 7: * @(#)trpfpe_.c 5.4 11/4/86 ! 8: * ! 9: * ! 10: * Fortran floating-point error handler ! 11: * ! 12: * Synopsis: ! 13: * call trpfpe (n, retval) ! 14: * causes floating point faults to be trapped, with the ! 15: * first 'n' errors getting a message printed. ! 16: * 'retval' is put in place of the bad result. ! 17: * k = fpecnt() ! 18: * causes 'k' to get the number of errors since the ! 19: * last call to trpfpe(). ! 20: * ! 21: * common /fpeflt/ fpflag ! 22: * logical fpflag ! 23: * fpflag will become .true. on faults ! 24: * ! 25: * David Wasley, UCBerkeley, June 1983. ! 26: */ ! 27: ! 28: ! 29: #include <stdio.h> ! 30: #include <signal.h> ! 31: #include "../libI77/fiodefs.h" ! 32: ! 33: #define SIG_VAL int (*)() ! 34: ! 35: #ifdef vax ! 36: #include "opcodes.h" ! 37: #include "operand.h" ! 38: ! 39: struct arglist { /* what AP points to */ ! 40: long al_numarg; /* only true in CALLS format */ ! 41: long al_arg[256]; ! 42: }; ! 43: ! 44: struct cframe { /* VAX call frame */ ! 45: long cf_handler; ! 46: unsigned short cf_psw; ! 47: unsigned short cf_mask; ! 48: struct arglist *cf_ap; ! 49: struct cframe *cf_fp; ! 50: char *cf_pc; ! 51: }; ! 52: ! 53: /* ! 54: * bits in the PSW ! 55: */ ! 56: #define PSW_V 0x2 ! 57: #define PSW_FU 0x40 ! 58: #define PSW_IV 0x20 ! 59: ! 60: /* ! 61: * where the registers are stored as we see them in the handler ! 62: */ ! 63: struct reg0_6 { ! 64: long reg[7]; ! 65: }; ! 66: ! 67: struct reg7_11 { ! 68: long reg[5]; ! 69: }; ! 70: ! 71: #define iR0 reg0_6->reg[0] ! 72: #define iR1 reg0_6->reg[1] ! 73: #define iR2 reg0_6->reg[2] ! 74: #define iR3 reg0_6->reg[3] ! 75: #define iR4 reg0_6->reg[4] ! 76: #define iR5 reg0_6->reg[5] ! 77: #define iR6 reg0_6->reg[6] ! 78: #define iR7 reg7_11->reg[0] ! 79: #define iR8 reg7_11->reg[1] ! 80: #define iR9 reg7_11->reg[2] ! 81: #define iR10 reg7_11->reg[3] ! 82: #define iR11 reg7_11->reg[4] ! 83: ! 84: union objects { /* for load/store */ ! 85: char ua_byte; ! 86: short ua_word; ! 87: long ua_long; ! 88: float ua_float; ! 89: double ua_double; ! 90: union objects *ua_anything; ! 91: }; ! 92: ! 93: typedef union objects anything; ! 94: enum object_type { BYTE, WORD, LONG, FLOAT, QUAD, DOUBLE, UNKNOWN }; ! 95: ! 96: ! 97: /* ! 98: * assembly language assist ! 99: * There are some things you just can't do in C ! 100: */ ! 101: asm(".text"); ! 102: ! 103: struct cframe *myfp(); ! 104: asm("_myfp: .word 0x0"); ! 105: asm("movl 12(fp),r0"); ! 106: asm("ret"); ! 107: ! 108: struct arglist *myap(); ! 109: asm("_myap: .word 0x0"); ! 110: asm("movl 8(fp),r0"); ! 111: asm("ret"); ! 112: ! 113: char *mysp(); ! 114: asm("_mysp: .word 0x0"); ! 115: asm("extzv $30,$2,4(fp),r0"); ! 116: asm("addl2 ap,r0"); /* SP in caller is AP+4 here + SPA bits! */ ! 117: asm("addl2 $4,r0"); ! 118: asm("ret"); ! 119: ! 120: char *mypc(); ! 121: asm("_mypc: .word 0x0"); ! 122: asm("movl 16(fp),r0"); ! 123: asm("ret"); ! 124: ! 125: asm(".data"); ! 126: ! 127: ! 128: /* ! 129: * Where interrupted objects are ! 130: */ ! 131: static struct cframe **ifp; /* addr of saved FP */ ! 132: static struct arglist **iap; /* addr of saved AP */ ! 133: static char *isp; /* value of interrupted SP */ ! 134: static char **ipc; /* addr of saved PC */ ! 135: static struct reg0_6 *reg0_6;/* registers 0-6 are saved on the exception */ ! 136: static struct reg7_11 *reg7_11;/* we save 7-11 by our entry mask */ ! 137: static anything *result_addr; /* where the dummy result goes */ ! 138: static enum object_type result_type; /* what kind of object it is */ ! 139: ! 140: /* ! 141: * some globals ! 142: */ ! 143: static union { ! 144: long rv_long[2]; ! 145: float rv_float; ! 146: double rv_double; ! 147: } retval; /* the user specified dummy result */ ! 148: static int max_messages = 1; /* the user can tell us */ ! 149: static int fpe_count = 0; /* how bad is it ? */ ! 150: long fpeflt_ = 0; /* fortran "common /fpeflt/ flag" */ ! 151: static int (*sigfpe_dfl)() = SIG_DFL; /* if we can't fix it ... */ ! 152: ! 153: /* ! 154: * The fortran unit control table ! 155: */ ! 156: extern unit units[]; ! 157: ! 158: /* ! 159: * Fortran message table is in main ! 160: */ ! 161: struct msgtbl { ! 162: char *mesg; ! 163: int dummy; ! 164: }; ! 165: extern struct msgtbl act_fpe[]; ! 166: ! 167: ! 168: /* ! 169: * Get the address of the (saved) next operand & update saved PC. ! 170: * The major purpose of this is to determine where to store the result. ! 171: * There is one case we can't deal with: -(SP) or (SP)+ ! 172: * since we can't change the size of the stack. ! 173: * Let's just hope compilers don't generate that for results. ! 174: */ ! 175: ! 176: anything * ! 177: get_operand (oper_size) ! 178: int oper_size; /* size of operand we expect */ ! 179: { ! 180: register int regnum; ! 181: register int operand_code; ! 182: int index; ! 183: anything *oper_addr; ! 184: anything *reg_addr; ! 185: ! 186: regnum = (**ipc & 0xf); ! 187: if (regnum == PC) ! 188: operand_code = (*(*ipc)++ & 0xff); ! 189: else ! 190: operand_code = (*(*ipc)++ & 0xf0); ! 191: if (regnum <= R6) ! 192: reg_addr = (anything *)®0_6->reg[regnum]; ! 193: else if (regnum <= R11) ! 194: reg_addr = (anything *)®7_11->reg[regnum]; ! 195: else if (regnum == AP) ! 196: reg_addr = (anything *)iap; ! 197: else if (regnum == FP) ! 198: reg_addr = (anything *)ifp; ! 199: else if (regnum == SP) ! 200: reg_addr = (anything *)&isp; /* We saved this ourselves */ ! 201: else if (regnum == PC) ! 202: reg_addr = (anything *)ipc; ! 203: ! 204: ! 205: switch (operand_code) ! 206: { ! 207: case IMMEDIATE: ! 208: oper_addr = (anything *)(*ipc); ! 209: *ipc += oper_size; ! 210: return(oper_addr); ! 211: ! 212: case ABSOLUTE: ! 213: oper_addr = (anything *)(**ipc); ! 214: *ipc += sizeof (anything *); ! 215: return(oper_addr); ! 216: ! 217: case LITERAL0: ! 218: case LITERAL1: ! 219: case LITERAL2: ! 220: case LITERAL3: ! 221: /* we don't care about the address of these */ ! 222: return((anything *)0); ! 223: ! 224: case INDEXED: ! 225: index = reg_addr->ua_long * oper_size; ! 226: oper_addr = (anything *)(get_operand(sizeof (long))->ua_long + index); ! 227: return(oper_addr); ! 228: ! 229: case REGISTER: ! 230: return(reg_addr); ! 231: ! 232: case REGDEFERED: ! 233: return(reg_addr->ua_anything); ! 234: ! 235: case AUTODEC: ! 236: if (regnum == SP) ! 237: { ! 238: fprintf(stderr, "trp: can't fix -(SP) operand\n"); ! 239: exit(1); ! 240: } ! 241: reg_addr->ua_long -= oper_size; ! 242: oper_addr = reg_addr->ua_anything; ! 243: return(oper_addr); ! 244: ! 245: case AUTOINC: ! 246: if (regnum == SP) ! 247: { ! 248: fprintf(stderr, "trp: can't fix (SP)+ operand\n"); ! 249: exit(1); ! 250: } ! 251: oper_addr = reg_addr->ua_anything; ! 252: reg_addr->ua_long += oper_size; ! 253: return(oper_addr); ! 254: ! 255: case AUTOINCDEF: ! 256: if (regnum == SP) ! 257: { ! 258: fprintf(stderr, "trp: can't fix @(SP)+ operand\n"); ! 259: exit(1); ! 260: } ! 261: oper_addr = (reg_addr->ua_anything)->ua_anything; ! 262: reg_addr->ua_long += sizeof (anything *); ! 263: return(oper_addr); ! 264: ! 265: case BYTEDISP: ! 266: case BYTEREL: ! 267: index = ((anything *)(*ipc))->ua_byte; ! 268: *ipc += sizeof (char); /* do it now in case reg==PC */ ! 269: oper_addr = (anything *)(index + reg_addr->ua_long); ! 270: return(oper_addr); ! 271: ! 272: case BYTEDISPDEF: ! 273: case BYTERELDEF: ! 274: index = ((anything *)(*ipc))->ua_byte; ! 275: *ipc += sizeof (char); /* do it now in case reg==PC */ ! 276: oper_addr = (anything *)(index + reg_addr->ua_long); ! 277: oper_addr = oper_addr->ua_anything; ! 278: return(oper_addr); ! 279: ! 280: case WORDDISP: ! 281: case WORDREL: ! 282: index = ((anything *)(*ipc))->ua_word; ! 283: *ipc += sizeof (short); /* do it now in case reg==PC */ ! 284: oper_addr = (anything *)(index + reg_addr->ua_long); ! 285: return(oper_addr); ! 286: ! 287: case WORDDISPDEF: ! 288: case WORDRELDEF: ! 289: index = ((anything *)(*ipc))->ua_word; ! 290: *ipc += sizeof (short); /* do it now in case reg==PC */ ! 291: oper_addr = (anything *)(index + reg_addr->ua_long); ! 292: oper_addr = oper_addr->ua_anything; ! 293: return(oper_addr); ! 294: ! 295: case LONGDISP: ! 296: case LONGREL: ! 297: index = ((anything *)(*ipc))->ua_long; ! 298: *ipc += sizeof (long); /* do it now in case reg==PC */ ! 299: oper_addr = (anything *)(index + reg_addr->ua_long); ! 300: return(oper_addr); ! 301: ! 302: case LONGDISPDEF: ! 303: case LONGRELDEF: ! 304: index = ((anything *)(*ipc))->ua_long; ! 305: *ipc += sizeof (long); /* do it now in case reg==PC */ ! 306: oper_addr = (anything *)(index + reg_addr->ua_long); ! 307: oper_addr = oper_addr->ua_anything; ! 308: return(oper_addr); ! 309: ! 310: /* NOTREACHED */ ! 311: } ! 312: } ! 313: ! 314: /* ! 315: * Trap & repair floating exceptions so that a program may proceed. ! 316: * There is no notion of "correctness" here; just the ability to continue. ! 317: * ! 318: * The on_fpe() routine first checks the type code to see if the ! 319: * exception is repairable. If so, it checks the opcode to see if ! 320: * it is one that it knows. If this is true, it then simulates the ! 321: * VAX cpu in retrieving operands in order to increment iPC correctly. ! 322: * It notes where the result of the operation would have been stored ! 323: * and substitutes a previously supplied value. ! 324: */ ! 325: ! 326: #ifdef OLD_BSD ! 327: on_fpe(signo, code, myaddr, pc, ps) ! 328: int signo, code, ps; ! 329: char *myaddr, *pc; ! 330: #else ! 331: on_fpe(signo, code, sc, grbg) ! 332: int signo, code; ! 333: struct sigcontext *sc; ! 334: #endif ! 335: { ! 336: /* ! 337: * There must be at least 5 register variables here ! 338: * so our entry mask will save R11-R7. ! 339: */ ! 340: register long *stk; ! 341: register long *sp; ! 342: register struct arglist *ap; ! 343: register struct cframe *fp; ! 344: register FILE *ef; ! 345: ! 346: ef = units[STDERR].ufd; /* fortran error stream */ ! 347: ! 348: switch (code) ! 349: { ! 350: case FPE_INTOVF_TRAP: /* integer overflow */ ! 351: case FPE_INTDIV_TRAP: /* integer divide by zero */ ! 352: case FPE_FLTOVF_TRAP: /* floating overflow */ ! 353: case FPE_FLTDIV_TRAP: /* floating/decimal divide by zero */ ! 354: case FPE_FLTUND_TRAP: /* floating underflow */ ! 355: case FPE_DECOVF_TRAP: /* decimal overflow */ ! 356: case FPE_SUBRNG_TRAP: /* subscript out of range */ ! 357: default: ! 358: cant_fix: ! 359: if (sigfpe_dfl > (SIG_VAL)7) /* user specified */ ! 360: #ifdef OLD_BSD ! 361: return((*sigfpe_dfl)(signo, code, myaddr, pc, ps)); ! 362: #else ! 363: return((*sigfpe_dfl)(signo, code, sc, grbg)); ! 364: #endif ! 365: else ! 366: #ifdef OLD_BSD ! 367: sigdie(signo, code, myaddr, pc, ps); ! 368: #else ! 369: sigdie(signo, code, sc, grbg); ! 370: #endif ! 371: /* NOTREACHED */ ! 372: ! 373: case FPE_FLTOVF_FAULT: /* floating overflow fault */ ! 374: case FPE_FLTDIV_FAULT: /* divide by zero floating fault */ ! 375: case FPE_FLTUND_FAULT: /* floating underflow fault */ ! 376: if (++fpe_count <= max_messages) { ! 377: fprintf(ef, "trpfpe: %s", ! 378: act_fpe[code-1].mesg); ! 379: if (fpe_count == max_messages) ! 380: fprintf(ef, ": No more messages will be printed.\n"); ! 381: else ! 382: fputc('\n', ef); ! 383: } ! 384: fpeflt_ = -1; ! 385: break; ! 386: } ! 387: ! 388: ap = myap(); /* my arglist pointer */ ! 389: fp = myfp(); /* my frame pointer */ ! 390: ifp = &(fp->cf_fp)->cf_fp; /* user's stored in next frame back */ ! 391: iap = &(fp->cf_fp)->cf_ap; ! 392: /* ! 393: * these are likely to be system dependent ! 394: */ ! 395: reg0_6 = (struct reg0_6 *)((char *)fp->cf_fp + sizeof (struct cframe)); ! 396: reg7_11 = (struct reg7_11 *)((char *)fp->cf_fp - sizeof (struct reg7_11)); ! 397: ! 398: #ifdef OLD_BSD ! 399: ipc = &pc; ! 400: isp = (char *)&ap->al_arg[ap->al_numarg + 2]; /* assumes 2 dummys */ ! 401: ps &= ~(PSW_V|PSW_FU); ! 402: #else ! 403: ipc = (char **)&sc->sc_pc; ! 404: isp = (char *)sc + sizeof (struct sigcontext); ! 405: sc->sc_ps &= ~(PSW_V|PSW_FU); ! 406: #endif ! 407: ! 408: ! 409: switch (*(*ipc)++) ! 410: { ! 411: case ADDD3: ! 412: case DIVD3: ! 413: case MULD3: ! 414: case SUBD3: ! 415: (void) get_operand(sizeof (double)); ! 416: /* intentional fall-thru */ ! 417: ! 418: case ADDD2: ! 419: case DIVD2: ! 420: case MULD2: ! 421: case SUBD2: ! 422: case MNEGD: ! 423: case MOVD: ! 424: (void) get_operand(sizeof (double)); ! 425: result_addr = get_operand(sizeof (double)); ! 426: result_type = DOUBLE; ! 427: break; ! 428: ! 429: case ADDF3: ! 430: case DIVF3: ! 431: case MULF3: ! 432: case SUBF3: ! 433: (void) get_operand(sizeof (float)); ! 434: /* intentional fall-thru */ ! 435: ! 436: case ADDF2: ! 437: case DIVF2: ! 438: case MULF2: ! 439: case SUBF2: ! 440: case MNEGF: ! 441: case MOVF: ! 442: (void) get_operand(sizeof (float)); ! 443: result_addr = get_operand(sizeof (float)); ! 444: result_type = FLOAT; ! 445: break; ! 446: ! 447: case CVTDF: ! 448: (void) get_operand(sizeof (double)); ! 449: result_addr = get_operand(sizeof (float)); ! 450: result_type = FLOAT; ! 451: break; ! 452: ! 453: case CVTFD: ! 454: (void) get_operand(sizeof (float)); ! 455: result_addr = get_operand(sizeof (double)); ! 456: result_type = DOUBLE; ! 457: break; ! 458: ! 459: case EMODF: ! 460: case EMODD: ! 461: fprintf(ef, "trpfpe: can't fix emod yet\n"); ! 462: goto cant_fix; ! 463: ! 464: case POLYF: ! 465: case POLYD: ! 466: fprintf(ef, "trpfpe: can't fix poly yet\n"); ! 467: goto cant_fix; ! 468: ! 469: case ACBD: ! 470: case ACBF: ! 471: case CMPD: ! 472: case CMPF: ! 473: case TSTD: ! 474: case TSTF: ! 475: case CVTDB: ! 476: case CVTDL: ! 477: case CVTDW: ! 478: case CVTFB: ! 479: case CVTFL: ! 480: case CVTFW: ! 481: case CVTRDL: ! 482: case CVTRFL: ! 483: /* These can generate only reserved operand faults */ ! 484: /* They are shown here for completeness */ ! 485: ! 486: default: ! 487: fprintf(stderr, "trp: opcode 0x%02x unknown\n", ! 488: *(--(*ipc)) & 0xff); ! 489: goto cant_fix; ! 490: /* NOTREACHED */ ! 491: } ! 492: ! 493: if (result_type == FLOAT) ! 494: result_addr->ua_float = retval.rv_float; ! 495: else ! 496: { ! 497: if (result_addr == (anything *)&iR6) ! 498: { /* ! 499: * special case - the R6/R7 pair is stored apart ! 500: */ ! 501: result_addr->ua_long = retval.rv_long[0]; ! 502: ((anything *)&iR7)->ua_long = retval.rv_long[1]; ! 503: } ! 504: else ! 505: result_addr->ua_double = retval.rv_double; ! 506: } ! 507: signal(SIGFPE, on_fpe); ! 508: } ! 509: ! 510: trpfpe_ (count, rval) ! 511: long *count; /* how many to announce */ ! 512: double *rval; /* dummy return value */ ! 513: { ! 514: max_messages = *count; ! 515: retval.rv_double = *rval; ! 516: sigfpe_dfl = signal(SIGFPE, on_fpe); ! 517: fpe_count = 0; ! 518: } ! 519: ! 520: long ! 521: fpecnt_ () ! 522: { ! 523: return (fpe_count); ! 524: } ! 525: #endif vax ! 526: ! 527: #ifdef tahoe ! 528: /* ! 529: * This handler just prints a message. It cannot fix anything ! 530: * on Power6 because of its fpp architecture. In any case, there ! 531: * are no arithmetic faults (only traps) around, so that no instruction ! 532: * is interrupted befor it completes, and PC points to the next floating ! 533: * point instruction (not necessarily next executable instr after the one ! 534: * that got the exception). ! 535: */ ! 536: ! 537: struct arglist { /* what AP points to */ ! 538: long al_arg[256]; ! 539: }; ! 540: ! 541: struct reg0_1 { ! 542: long reg[2]; ! 543: }; ! 544: struct reg2_12 { ! 545: long reg[11]; ! 546: }; ! 547: #include <sys/types.h> ! 548: #include <frame.h> ! 549: #include "sigframe.h" ! 550: ! 551: /* ! 552: * bits in the PSL ! 553: */ ! 554: #include <machine/psl.h> ! 555: ! 556: /* ! 557: * where the registers are stored as we see them in the handler ! 558: */ ! 559: ! 560: ! 561: #define iR0 reg0_1->reg[1] ! 562: #define iR1 reg0_1->reg[0] ! 563: ! 564: #define iR2 reg2_12->reg[0] ! 565: #define iR3 reg2_12->reg[1] ! 566: #define iR4 reg2_12->reg[2] ! 567: #define iR5 reg2_12->reg[3] ! 568: #define iR6 reg2_12->reg[4] ! 569: #define iR7 reg2_12->reg[5] ! 570: #define iR8 reg2_12->reg[6] ! 571: #define iR9 reg2_12->reg[7] ! 572: #define iR10 reg2_12->reg[8] ! 573: #define iR11 reg2_12->reg[9] ! 574: #define iR12 reg2_12->reg[10] ! 575: ! 576: union objects { /* for load/store */ ! 577: char ua_byte; ! 578: short ua_word; ! 579: long ua_long; ! 580: float ua_float; ! 581: double ua_double; ! 582: union objects *ua_anything; ! 583: }; ! 584: ! 585: typedef union objects anything; ! 586: enum object_type { BYTE, WORD, LONG, FLOAT, QUAD, DOUBLE, UNKNOWN }; ! 587: ! 588: ! 589: /* ! 590: * assembly language assist ! 591: * There are some things you just can't do in C ! 592: */ ! 593: asm(".text"); ! 594: ! 595: long *myfp(); ! 596: asm("_myfp: .word 0"); ! 597: asm("movl (fp),r0"); ! 598: asm("ret"); ! 599: ! 600: struct frame *framep(p) ! 601: long *p; ! 602: { ! 603: return((struct frame *)(p-2)); ! 604: } ! 605: ! 606: struct arglist *argp(p) ! 607: long *p; ! 608: { ! 609: return((struct arglist *)(p+1)); ! 610: } ! 611: ! 612: char *mysp(); ! 613: asm("_mysp: .word 0"); ! 614: asm("addl3 $4,fp,r0"); ! 615: asm("ret"); ! 616: ! 617: char *mypc(); ! 618: asm("_mypc: .word 0"); ! 619: asm("movl -8(fp),r0"); ! 620: asm("ret"); ! 621: ! 622: asm(".data"); ! 623: ! 624: ! 625: /* ! 626: * Where interrupted objects are ! 627: */ ! 628: static struct frame *ifp; /* addr of saved FP */ ! 629: static struct arglist *iap; /* addr of saved AP */ ! 630: static char *isp; /* value of interrupted SP */ ! 631: static char **ipc; /* addr of saved PC */ ! 632: static struct reg0_1 *reg0_1;/* registers 0-1 are saved on the exception */ ! 633: static struct reg2_12 *reg2_12;/* we save 2-12 by our entry mask */ ! 634: static anything *result_addr; /* where the dummy result goes */ ! 635: static enum object_type result_type; /* what kind of object it is */ ! 636: ! 637: /* ! 638: * some globals ! 639: */ ! 640: static union { ! 641: long rv_long[2]; ! 642: float rv_float; ! 643: double rv_double; ! 644: } retval; /* the user specified dummy result */ ! 645: static int max_messages = 1; /* the user can tell us */ ! 646: static int fpe_count = 0; /* how bad is it ? */ ! 647: long fpeflt_ = 0; /* fortran "common /fpeflt/ flag" */ ! 648: static int (*sigfpe_dfl)() = SIG_DFL; /* if we can't fix it ... */ ! 649: ! 650: /* ! 651: * The fortran unit control table ! 652: */ ! 653: extern unit units[]; ! 654: ! 655: /* ! 656: * Fortran message table is in main ! 657: */ ! 658: struct msgtbl { ! 659: char *mesg; ! 660: int dummy; ! 661: }; ! 662: extern struct msgtbl act_fpe[]; ! 663: ! 664: ! 665: /* VALID ONLY ON VAX !!! ! 666: * ! 667: * Get the address of the (saved) next operand & update saved PC. ! 668: * The major purpose of this is to determine where to store the result. ! 669: * There is one case we can't deal with: -(SP) or (SP)+ ! 670: * since we can't change the size of the stack. ! 671: * Let's just hope compilers don't generate that for results. ! 672: */ ! 673: ! 674: ! 675: /* ! 676: * Trap & repair floating exceptions so that a program may proceed. ! 677: * There is no notion of "correctness" here; just the ability to continue. ! 678: * ! 679: * The on_fpe() routine first checks the type code to see if the ! 680: * exception is repairable. If so, it checks the opcode to see if ! 681: * it is one that it knows. If this is true, it then simulates the ! 682: * VAX cpu in retrieving operands in order to increment iPC correctly. ! 683: * It notes where the result of the operation would have been stored ! 684: * and substitutes a previously supplied value. ! 685: * DOES NOT REPAIR ON TAHOE !!! ! 686: */ ! 687: ! 688: on_fpe(signo, code, sc) ! 689: int signo, code; ! 690: struct sigcontext *sc; ! 691: { ! 692: /* ! 693: * There must be at least 11 register variables here ! 694: * so our entry mask will save R12-R2. ! 695: */ ! 696: register long *stk; ! 697: register long *sp, *rfp; ! 698: register struct arglist *ap; ! 699: register struct frame *fp; ! 700: register FILE *ef; ! 701: register struct sigframe *sfp; ! 702: register long dmy1, dmy2, dmy3, dmy4; ! 703: ! 704: dmy1 = dmy2 = dmy3 = dmy4 = 0; ! 705: ! 706: ef = units[STDERR].ufd; /* fortran error stream */ ! 707: ! 708: switch (code) ! 709: { ! 710: case FPE_INTOVF_TRAP: /* integer overflow */ ! 711: case FPE_INTDIV_TRAP: /* integer divide by zero */ ! 712: case FPE_FLTOVF_TRAP: /* floating overflow */ ! 713: case FPE_FLTDIV_TRAP: /* floating divide by zero */ ! 714: case FPE_FLTUND_TRAP: /* floating underflow */ ! 715: default: ! 716: cant_fix: ! 717: if (sigfpe_dfl > (SIG_VAL)7) /* user specified */ ! 718: return((*sigfpe_dfl)(signo, code, sc)); ! 719: else ! 720: if (++fpe_count <= max_messages) { ! 721: fprintf(ef, "trpfpe: %s", ! 722: act_fpe[code-1].mesg); ! 723: if (fpe_count == max_messages) ! 724: fprintf(ef, ": No more messages will be printed.\n"); ! 725: else ! 726: fputc('\n', ef); ! 727: } ! 728: fpeflt_ = -1; ! 729: break; ! 730: } ! 731: ! 732: /* ! 733: * Find all the registers just in case something better can be done. ! 734: */ ! 735: ! 736: rfp = myfp(); /* contents of fp register */ ! 737: ap = argp(rfp); /* my arglist pointer */ ! 738: fp = framep(rfp); /* my frame pointer */ ! 739: ifp = framep(*rfp); /* user's stored in next frame back */ ! 740: iap = argp(*rfp); ! 741: ! 742: sfp = (struct sigframe *)ap; /* sigframe contains at its bottom the ! 743: signal handler arguments */ ! 744: ! 745: reg0_1 = (struct reg0_1 *)&sfp->r1; ! 746: reg2_12 = (struct reg2_12 *)((char *)fp - sizeof (struct reg2_12)); ! 747: ! 748: ipc = (char **)&sc->sc_pc; ! 749: isp = (char *)sc + sizeof (struct sigcontext); ! 750: sc->sc_ps &= ~(PSL_V|PSL_FU); ! 751: ! 752: fprintf(ef, "Current PC = %X \n", sc->sc_pc); ! 753: ! 754: signal(SIGFPE, on_fpe); ! 755: sigdie(signo, code, sc); ! 756: } ! 757: ! 758: trpfpe_ (count, rval) ! 759: long *count; /* how many to announce */ ! 760: double *rval; /* dummy return value */ ! 761: { ! 762: max_messages = *count; ! 763: retval.rv_double = *rval; ! 764: sigfpe_dfl = signal(SIGFPE, on_fpe); ! 765: fpe_count = 0; ! 766: } ! 767: ! 768: long ! 769: fpecnt_ () ! 770: { ! 771: return (fpe_count); ! 772: } ! 773: ! 774: #endif tahoe
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.