![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to error_hdl.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / memman|
Return to error_hdl.s CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / memman |
1.1 root 1: LL0:
2: .data
3: .set SBR,0
4: .set SLR,1
5: .set P0BR,2
6: .set P0LR,3
7: .set P1BR,4
8: .set P1LR,5
9: .set P2BR,6
10: .set P2LR,7
11: .set IPL,8
12: .set MAPEN,9
13: .set MME,9
14: .set TBIA,10
15: .set TBIS,11
16: .set DCK,12
17: .set CCK,13
18: .set PCBB,14
19: .set KSP,19
20: .set USP,20
21: .set CPMDCB,21
22: .set PADC,25
23: .set DCR,27
24: .set DC_ON,1
25: .set DC_OFF,2
26: .set TB_ON,256
27: .set TB_OFF,512
28: .align 2
29: .globl _Tname
30: _Tname:
31: .data 2
32: L17:
33: .ascii "\12\0"
34: .data
35: .long L17
36: .text
37: .align 1
38: .globl _chk_pars
39: _chk_pars:
40: .word L19
41: # #include "definitions"
42: #
43: # extern long *p_ptr, exp_par0, exp_par1, exp_par2, exp_par3;
44: # char *Tname = "\n"; /* PTR to test name */
45: #
46: # chk_pars(msg1)
47: # char *msg1;
48: # { char *msg2;
49: jbr L21
50: L22:
51: # long *pcb_base, act_param;
52: #
53: # /* Check fault parameter words */
54: # act_param = *p_ptr++;
55: movl *_p_ptr,-64(fp)
56: addl2 $4,_p_ptr
57: # if (exp_par0 != act_param)
58: cmpl _exp_par0,-64(fp)
59: jeql L23
60: # { msg2="** fault indicator (1st word) is not as expected !!\n";
61: .data 1
62: L24:
63: .ascii "** fault indicator (1st word) is not as expected !!\12\0"
64: .text
65: movl $L24,-56(fp)
66: # pverr_handler(msg1,msg2,exp_par0,act_param); }
67: pushl -64(fp)
68: pushl _exp_par0
69: pushl -56(fp)
70: pushl 4(fp)
71: callf $20,_pverr_handler
72: # act_param = *p_ptr++;
73: L23:
74: movl *_p_ptr,-64(fp)
75: addl2 $4,_p_ptr
76: # if (exp_par1 != act_param)
77: cmpl _exp_par1,-64(fp)
78: jeql L26
79: # { msg2="** virtual addr in 2nd parameter is not as expected\n";
80: .data 1
81: L27:
82: .ascii "** virtual addr in 2nd parameter is not as expected\12\0"
83: .text
84: movl $L27,-56(fp)
85: # pverr_handler(msg1,msg2,exp_par1,act_param); }
86: pushl -64(fp)
87: pushl _exp_par1
88: pushl -56(fp)
89: pushl 4(fp)
90: callf $20,_pverr_handler
91: # act_param = *p_ptr++;
92: L26:
93: movl *_p_ptr,-64(fp)
94: addl2 $4,_p_ptr
95: # if (exp_par2 != act_param)
96: cmpl _exp_par2,-64(fp)
97: jeql L28
98: # { msg2="** PC in 3rd parameter word is not as expected\n";
99: .data 1
100: L29:
101: .ascii "** PC in 3rd parameter word is not as expected\12\0"
102: .text
103: movl $L29,-56(fp)
104: # pverr_handler(msg1,msg2,exp_par2,act_param); }
105: pushl -64(fp)
106: pushl _exp_par2
107: pushl -56(fp)
108: pushl 4(fp)
109: callf $20,_pverr_handler
110: # act_param = (*p_ptr) & 0xffffffc0; /* Mask out PSW flags */
111: L28:
112: andl3 $-64,*_p_ptr,r0
113: movl r0,-64(fp)
114: # if (exp_par3 != act_param)
115: cmpl _exp_par3,-64(fp)
116: jeql L30
117: # { msg2="** PSL in 4th parameter word is not as expected \n";
118: .data 1
119: L31:
120: .ascii "** PSL in 4th parameter word is not as expected \12\0"
121: .text
122: movl $L31,-56(fp)
123: # pverr_handler(msg1,msg2,exp_par3,act_param); }
124: pushl -64(fp)
125: pushl _exp_par3
126: pushl -56(fp)
127: pushl 4(fp)
128: callf $20,_pverr_handler
129: #
130: # }
131: L30:
132: ret
133: .set L19,0x0
134: L21:
135: subl3 $64,fp,sp
136: jbr L22
137: .data
138: .text
139: .align 1
140: .globl _pverr_handler
141: _pverr_handler:
142: .word L32
143: #
144: # pverr_handler(msg1,msg2,exp,act)
145: # char *msg1, *msg2;
146: # long exp, act;
147: # {
148: jbr L34
149: L35:
150: #
151: # writes(Tname);
152: pushl _Tname
153: callf $8,_writes
154: # writes(msg1); writec('\n'); writes(msg2); writec('\n');
155: pushl 4(fp)
156: callf $8,_writes
157: pushl $10
158: callf $8,_writec
159: pushl 8(fp)
160: callf $8,_writes
161: pushl $10
162: callf $8,_writec
163: # writes("** Expected data : "); writeh(exp); writec('\n');
164: .data 1
165: L38:
166: .ascii "** Expected data : \0"
167: .text
168: pushl $L38
169: callf $8,_writes
170: pushl 12(fp)
171: callf $8,_writeh
172: pushl $10
173: callf $8,_writec
174: # writes("** Actual data : "); writeh(act); writec('\n');
175: .data 1
176: L40:
177: .ascii "** Actual data : \0"
178: .text
179: pushl $L40
180: callf $8,_writes
181: pushl 16(fp)
182: callf $8,_writeh
183: pushl $10
184: callf $8,_writec
185: # asm("halt");
186: halt
187: # }
188: ret
189: .set L32,0x0
190: L34:
191: jbr L35
192: .data
193: .text
194: .align 1
195: .globl _print_params
196: _print_params:
197: .word L42
198: #
199: #
200: #
201: # print_params()
202: # {
203: jbr L44
204: L45:
205: # long *param_ptr;
206: #
207: # param_ptr = p_ptr;
208: movl _p_ptr,-56(fp)
209: # writes(" Parameter 1 : "); writeh(*param_ptr++); writec('\n');
210: .data 1
211: L46:
212: .ascii "\11Parameter 1 : \0"
213: .text
214: pushl $L46
215: callf $8,_writes
216: movl -56(fp),r0
217: addl2 $4,-56(fp)
218: pushl (r0)
219: callf $8,_writeh
220: pushl $10
221: callf $8,_writec
222: # writes(" Parameter 2 : "); writeh(*param_ptr++); writec('\n');
223: .data 1
224: L47:
225: .ascii "\11Parameter 2 : \0"
226: .text
227: pushl $L47
228: callf $8,_writes
229: movl -56(fp),r0
230: addl2 $4,-56(fp)
231: pushl (r0)
232: callf $8,_writeh
233: pushl $10
234: callf $8,_writec
235: # writes(" Parameter 3 : "); writeh(*param_ptr++); writec('\n');
236: .data 1
237: L48:
238: .ascii "\11Parameter 3 : \0"
239: .text
240: pushl $L48
241: callf $8,_writes
242: movl -56(fp),r0
243: addl2 $4,-56(fp)
244: pushl (r0)
245: callf $8,_writeh
246: pushl $10
247: callf $8,_writec
248: # writes(" Parameter 4 : "); writeh(*param_ptr); writec('\n');
249: .data 1
250: L49:
251: .ascii "\11Parameter 4 : \0"
252: .text
253: pushl $L49
254: callf $8,_writes
255: pushl *-56(fp)
256: callf $8,_writeh
257: pushl $10
258: callf $8,_writec
259: # asm("halt");
260: halt
261: # }
262: ret
263: .set L42,0x0
264: L44:
265: subl3 $56,fp,sp
266: jbr L45
267: .data
268: #
269: #
270: #
271: #
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.