Return to exception.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoealign

Annotation of 43BSDReno/sys/tahoealign/exception.c, revision 1.1

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

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