Return to trap.s CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / memman

Annotation of cci/d/memman/trap.s, revision 1.1.1.1

1.1       root        1: LL0:
                      2:        .data
                      3:        .text
                      4:        .align  1
                      5:        .globl  _XTrap
                      6: _XTrap:
                      7:        .word   L12
                      8:  # 
                      9:  # XTrap(code)
                     10:  # long code;
                     11:  # {   register long r12, r11, r10, r9;
                     12:        jbr     L14
                     13: L15:
                     14:  #     long tpc, tpsl;
                     15:  # 
                     16:  #     writes("\n** Unexpected exception type : ");
                     17:        .data   1
                     18: L17:
                     19:        .ascii  "\12** Unexpected exception type : \0"
                     20:        .text
                     21:        pushl   $L17
                     22:        callf   $8,_writes
                     23:  #     writeh(code); writec('\n');
                     24:        pushl   4(fp)
                     25:        callf   $8,_writeh
                     26:        pushl   $10
                     27:        callf   $8,_writec
                     28:  #     asm("movl 8(fp),r12");          /* par 0 */
                     29: movl 8(fp),r12
                     30:  #     asm("movl 12(fp),r11");         /* par 1 */
                     31: movl 12(fp),r11
                     32:  #     asm("movl 16(fp),r10");         /* par 2 */
                     33: movl 16(fp),r10
                     34:  #     asm("movl 20(fp),r9");          /* par 3 */
                     35: movl 20(fp),r9
                     36:  # 
                     37:  #     if ((code==0x20) || (code==0x2f) || (code==0x30)) {
                     38:        cmpl    4(fp),$32
                     39:        jeql    L9999
                     40:        cmpl    4(fp),$47
                     41:        jeql    L9999
                     42:        cmpl    4(fp),$48
                     43:        jneq    L20
                     44: L9999:
                     45:  #             writes("** Par0 :  "); writeh(r12); writec('\n');
                     46:        .data   1
                     47: L21:
                     48:        .ascii  "** Par0 :  \0"
                     49:        .text
                     50:        pushl   $L21
                     51:        callf   $8,_writes
                     52:        pushl   r12
                     53:        callf   $8,_writeh
                     54:        pushl   $10
                     55:        callf   $8,_writec
                     56:  #             writes("** Par1 :  "); writeh(r11); writec('\n');
                     57:        .data   1
                     58: L22:
                     59:        .ascii  "** Par1 :  \0"
                     60:        .text
                     61:        pushl   $L22
                     62:        callf   $8,_writes
                     63:        pushl   r11
                     64:        callf   $8,_writeh
                     65:        pushl   $10
                     66:        callf   $8,_writec
                     67:  #             tpc = r10;
                     68:        movl    r10,-56(fp)
                     69:  #             tpsl = r9; 
                     70:        movl    r9,-60(fp)
                     71:  #             }
                     72:  #        else         {
                     73:        jbr     L23
                     74: L20:
                     75:  #             if ((code==0x34) || (code==0x2b))  {
                     76:        cmpl    4(fp),$52
                     77:        jeql    L9998
                     78:        cmpl    4(fp),$43
                     79:        jneq    L24
                     80: L9998:
                     81:  #                     writes("** Par. :  "); writeh(r12); writec('\n');
                     82:        .data   1
                     83: L25:
                     84:        .ascii  "** Par. :  \0"
                     85:        .text
                     86:        pushl   $L25
                     87:        callf   $8,_writes
                     88:        pushl   r12
                     89:        callf   $8,_writeh
                     90:        pushl   $10
                     91:        callf   $8,_writec
                     92:  #                     tpc = r11;
                     93:        movl    r11,-56(fp)
                     94:  #                     tpsl = r10;
                     95:        movl    r10,-60(fp)
                     96:  #                     }
                     97:  #                 else        {
                     98:        jbr     L26
                     99: L24:
                    100:  #                     tpc = r12;
                    101:        movl    r12,-56(fp)
                    102:  #                     tpsl = r11; }
                    103:        movl    r11,-60(fp)
                    104: L26:
                    105:  #             }
                    106: L23:
                    107:  #     writes("** PC   :  "); writeh(tpc); writec('\n');
                    108:        .data   1
                    109: L27:
                    110:        .ascii  "** PC   :  \0"
                    111:        .text
                    112:        pushl   $L27
                    113:        callf   $8,_writes
                    114:        pushl   -56(fp)
                    115:        callf   $8,_writeh
                    116:        pushl   $10
                    117:        callf   $8,_writec
                    118:  #     writes("** PSL  :  "); writeh(tpsl); writec('\n');
                    119:        .data   1
                    120: L28:
                    121:        .ascii  "** PSL  :  \0"
                    122:        .text
                    123:        pushl   $L28
                    124:        callf   $8,_writes
                    125:        pushl   -60(fp)
                    126:        callf   $8,_writeh
                    127:        pushl   $10
                    128:        callf   $8,_writec
                    129:  #     asm("halt");
                    130: halt
                    131:  # }
                    132:        ret
                    133:        .set    L12,0x1e00
                    134: L14:
                    135:        subl3   $60,fp,sp
                    136:        jbr     L15
                    137:        .data

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