Return to Aexception.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / tahoe

Annotation of cci/sys/tahoe/Aexception.c, revision 1.1.1.1

1.1       root        1: 
                      2: #include "../machine/alignment.h" 
                      3: exception(infop, type, param1, param2)
                      4: process_info *infop;
                      5: int    type, param1, param2;
                      6: {
                      7: /*
                      8:  * Signal an exception. It will be handled by 'locore.s'. Here, I:
                      9:  *     1) Put the exception code where it belongs on the stack.
                     10:  *     2) Restore pc and sp to show that the current opcode
                     11:  *             'was not executed'.
                     12:  *     3) Execute one big non-local-goto. In the process we take care
                     13:  *             to reset the current HW fp such that 'alignment' will
                     14:  *             indeed return to 'locore.s'.
                     15:  *             IMPORTANT NOTE : the process I use will NOT restore
                     16:  *             all registers (like normal returns) so the call to the
                     17:  *             handling routine HAS TO BE the last thing in 'alignment'.
                     18:  *             Otherwise, all its own register variables will be a mess !!
                     19:  *             I also know that 'alignment' itself WILL restore all
                     20:  *             registers for 'locore.s' since its entry mask is all-1.
                     21:  */
                     22:        register long *my_fp;
                     23:        register long *current_fp, *prev_fp;
                     24: 
                     25:        my_fp = (long *)&infop-1 ;
                     26:        infop->ret_exception = type;
                     27:        switch (type) {
                     28:        case ARITHMETIC:
                     29:                infop->ret_code = param1;
                     30:                break;
                     31:        case ILL_ACCESS:
                     32:                infop->ret_addr = param1;
                     33:                infop->ret_code = param2;
                     34:                break;
                     35:        case ALIGNMENT:
                     36:        case ILL_ADDRMOD:
                     37:        case ILL_OPRND:
                     38:                break;
                     39:        default :
                     40:                printf ("Bad exception type %d (alignment code)\n", type);
                     41:                break;
                     42:        }
                     43: /*
                     44:  * Now the big trick. Look up the stack until the frame of
                     45:  * 'alignment' is found. prev_fp will point to it and current_fp
                     46:  * will then point to the frame of whoever 'alignment' called.
                     47:  * This should better work ...
                     48:  */
                     49:        prev_fp = my_fp;
                     50:        while (prev_fp != &fp) {
                     51:                current_fp = prev_fp;
                     52:                prev_fp = (long *) *prev_fp;
                     53:        }
                     54: /*
                     55:  * Found it. Now fool the HW into thinking that 'alignment' called
                     56:  * us directly here, so this routine's 'return' will go back
                     57:  * all the way to 'alignment', stopping any further emulation
                     58:  * for the current offending opcode.
                     59:  *  "fool the HW..." ha ha, am I realy fooling myself ?
                     60:  */
                     61:        *my_fp = *current_fp;
                     62:        *(my_fp - 2) = *(current_fp -2);        /* Alter program counter */
                     63: /*
                     64:  * Without further ado, just go back now !!!!
                     65:  */
                     66: }
                     67: 
                     68: not_needed (infop)
                     69: process_info *infop;
                     70: {
                     71: /*
                     72:  * Shouldn't ever come to this routine.
                     73:  */
                     74: 
                     75:        printf ("Opcode 0x%x should not trap to alignment code.",
                     76:                opCODE);
                     77:        printf (" OS or machine problem!! \n");
                     78: }
                     79: 
                     80: 
                     81: cannot_do (infop)
                     82: process_info *infop;
                     83: {
                     84: /*
                     85:  * Some opcode-caused alignments cannot be emulated. See table.c for
                     86:  * specific reasons. Reflect this back to the process as alignment
                     87:  * exception.
                     88:  */
                     89:        exception (infop, ALIGNMENT);
                     90: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.