![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emulate.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / sys / ml|
Return to emulate.s CVS log | Up to [Research Unix] / researchv10no / sys / ml |
1.1 root 1: /* @(#)emulate.s 3.3 86/10/16 mt Xinu */
2:
3: /*
4: * String instruction emulation - MicroVAX only. These routines are called
5: * from locore.s when an "emulate" fault occurs on the MicroVAX. They are
6: * called with the stack set up as follows:
7: *
8: * (sp): Return address of trap handler
9: * 4(sp): Instruction Opcode (also holds PSL result from emulator)
10: * 8(sp): Instruction PC
11: * 12(sp): Operand 1
12: * 16(sp): Operand 2
13: * 20(sp): Operand 3
14: * 24(sp): Operand 4
15: * 28(sp): Operand 5
16: * 32(sp): Operand 6
17: * 36(sp): old Register 11
18: * 40(sp): old Register 10
19: * 44(sp): Return PC
20: * 48(sp): Return PSL
21: * 52(sp): TOS before instruction
22: *
23: * R11 and r10 are available for use. If any routine needs to use r9-r1
24: * they need to save them first (unless those registers are SUPPOSED to be
25: * messed with by the "instruction"). These routines leave their results
26: * in registers 0-5 explicitly, as needed, and use the macros defined below
27: * to link up with calling routine.
28: */
29:
30: #define return rsb
31: #define savepsl movpsl 4(sp)
32: #define setpsl(reg) movl reg,4(sp)
33: #define overflowpsl movl $2,4(sp)
34: #define arg1 12(sp)
35: #define arg2 16(sp)
36: #define arg3 20(sp)
37: #define arg4 24(sp)
38: #define arg5 28(sp)
39: #define arg6 32(sp)
40: #define argub(num,reg) movzbl 8+4*num(sp),reg
41: #define arguw(num,reg) movzwl 8+4*num(sp),reg
42: #define argul(num,reg) movl 8+4*num(sp),reg
43: #define argb(num,reg) cvtbl 8+4*num(sp),reg
44: #define argw(num,reg) cvtwl 8+4*num(sp),reg
45: #define argl(num,reg) movl 8+4*num(sp),reg
46: #define toarg(reg,num) movl reg,8+4*num(sp)
47:
48:
49: .text
50: .align 1
51: .globl __emulbeg
52: __emulbeg:
53: _EMcrc:
54: argl(1,r11) # (1) table address == r11
55: argl(2,r0) # (2) initial crc == r0
56: argl(4,r3) # (4) source address == r3
57: arguw(3,r2) # (3) source length == r2
58: jeql Lcrc_out
59: Lcrc_loop:
60: xorb2 (r3)+,r0
61: extzv $0,$4,r0,r10
62: extzv $4,$28,r0,r1
63: xorl3 r1,(r11)[r10],r0
64: extzv $0,$4,r0,r10
65: extzv $4,$28,r0,r1
66: xorl3 r1,(r11)[r10],r0
67: sobgtr r2,Lcrc_loop
68: tstl r0
69: Lcrc_out:
70: savepsl
71: clrl r1
72: return
73:
74:
75: .align 1
76: _EMmovtc:
77: arguw(1,r0) # (1) source length == r0
78: argl(2,r1) # (2) source address == r1
79: argub(3,r11) # (3) fill character == r11
80: argl(4,r3) # (4) table address == r3
81: argl(6,r5) # (6) destination address == r5
82: arguw(5,r4) # (5) destination length == r4
83: jeql Lmovtc_out
84: Lmovtc_loop:
85: tstl r0
86: jeql Lmovtc_2loop
87: movzbl (r1)+,r2
88: movb (r3)[r2],(r5)+
89: decl r0
90: sobgtr r4,Lmovtc_loop
91: jbr Lmovtc_out
92: Lmovtc_2loop:
93: movb r11,(r5)+
94: sobgtr r4,Lmovtc_2loop
95: Lmovtc_out:
96: cmpl r4,r0
97: savepsl
98: clrl r2
99: return
100:
101:
102: .align 1
103: _EMmovtuc:
104: arguw(1,r0) # (1) source length == r0
105: argl(2,r1) # (2) source address == r1
106: argub(3,r11) # (3) escape character == r11
107: argl(4,r3) # (4) table address == r3
108: argl(6,r5) # (6) destination address == r5
109: arguw(5,r4) # (5) destination length == r4
110: jeql Lmovtuc_out
111: Lmovtuc_loop:
112: tstl r0
113: jeql Lmovtuc_out
114: movzbl (r1),r2
115: movzbl (r3)[r2],r2
116: cmpl r2,r11
117: jeql Lmovtuc_out
118: movzbl (r1)+,r2
119: movb (r3)[r2],(r5)+
120: decl r0
121: sobgtr r4,Lmovtuc_loop
122: Lmovtuc_out:
123: cmpl r4,r0
124: savepsl
125: clrl r2
126: return
127:
128:
129: .align 1
130: _EMmatchc:
131: argl(2,r10) # (2) substring address == r10
132: arguw(3,r2) # (3) source length == r2
133: argl(4,r3) # (4) source address == r3
134: arguw(1,r11) # (1) substring length == r11
135: jeql Lmatchc_out # temp source address == r1
136: addl2 r10,r11 # temp substring address == r0
137: tstl r2
138: jeql Lmatchc_out
139: Lmatchc_loop:
140: cmpb (r10),(r3)
141: jneq Lmatchc_fail
142: movl r3,r1
143: movl r10,r0
144: Lmatchc_2loop:
145: cmpl r0,r11
146: jeql Lmatchc_succ
147: cmpb (r0)+,(r1)+
148: jeql Lmatchc_2loop
149: Lmatchc_fail:
150: incl r3
151: sobgtr r2,Lmatchc_loop
152: movl r10,r1
153: subl3 r10,r11,r0
154: jbr Lmatchc_out
155: Lmatchc_succ:
156: movl r1,r3
157: movl r11,r1
158: clrl r0
159: Lmatchc_out:
160: savepsl
161: return
162:
163:
164: .align 1
165: _EMspanc:
166: argl(2,r1) # (2) string address == r1
167: argub(4,r2) # (4) character-mask == r2
168: argl(3,r3) # (3) table address == r3
169: arguw(1,r0) # (1) string length == r0
170: jeql Lspanc_out
171: Lspanc_loop:
172: movzbl (r1),r11
173: mcomb (r3)[r11],r11
174: bicb3 r11,r2,r11
175: jeql Lspanc_out
176: incl r1
177: sobgtr r0,Lspanc_loop
178: Lspanc_out:
179: savepsl
180: clrl r2
181: return
182:
183:
184: .align 1
185: _EMscanc:
186: argl(2,r1) # (2) string address == r1
187: argub(4,r2) # (4) character-mask == r2
188: argl(3,r3) # (3) table address == r3
189: arguw(1,r0) # (1) string length == r0
190: jeql Lscanc_out
191: Lscanc_loop:
192: movzbl (r1),r11
193: mcomb (r3)[r11],r11
194: bicb3 r11,r2,r11
195: jneq Lscanc_out
196: incl r1
197: sobgtr r0,Lscanc_loop
198: Lscanc_out:
199: savepsl
200: clrl r2
201: return
202:
203:
204: .align 1
205: _EMskpc:
206: argub(1,r11) # (1) character == r11
207: argl(3,r1) # (3) string address == r1
208: arguw(2,r0) # (2) string length == r0
209: jeql Lskpc_out # forget zero length strings
210: Lskpc_loop:
211: cmpb (r1),r11
212: jneq Lskpc_out
213: incl r1
214: sobgtr r0,Lskpc_loop
215: Lskpc_out:
216: tstl r0 # be sure of condition codes
217: savepsl
218: return
219:
220:
221: .align 1
222: _EMlocc:
223: argub(1,r11) # (1) character == r11
224: argl(3,r1) # (3) string address == r1
225: arguw(2,r0) # (2) string length == r0
226: jeql Lskpc_out # forget zero length strings
227: Llocc_loop:
228: cmpb (r1),r11
229: jeql Llocc_out
230: incl r1
231: sobgtr r0,Llocc_loop
232: Llocc_out:
233: tstl r0 # be sure of condition codes
234: savepsl
235: return
236:
237:
238: .align 1
239: _EMcmpc3:
240: argl(2,r1) # (2) string1 address == r1
241: argl(3,r3) # (3) string2 address == r3
242: arguw(1,r0) # (1) strings' length == r0
243: jeql Lcmpc3_out
244: Lcmpc3_loop:
245: cmpb (r1),(r3)
246: jneq Lcmpc3_out
247: incl r1
248: incl r3
249: sobgtr r0,Lcmpc3_loop
250: Lcmpc3_out:
251: savepsl
252: movl r0,r2
253: return
254:
255:
256: .align 1
257: _EMcmpc5:
258: argl(2,r1) # (2) string1 address == r1
259: argub(3,r11) # (1) fill character == r11
260: arguw(4,r2) # (1) string2 length == r2
261: argl(5,r3) # (3) string2 address == r3
262: arguw(1,r0) # (1) string1 length == r0
263: jeql Lcmpc5_str2
264: Lcmpc5_loop:
265: tstl r2
266: jeql Lcmpc5_str1loop
267: cmpb (r1),(r3)
268: jneq Lcmpc5_out
269: incl r1
270: incl r3
271: decl r2
272: sobgtr r0,Lcmpc5_loop
273: Lcmpc5_str2:
274: tstl r2
275: jeql Lcmpc5_out
276: Lcmpc5_str2loop:
277: cmpb r11,(r3)
278: jneq Lcmpc5_out
279: incl r3
280: sobgtr r2,Lcmpc5_str2loop
281: jbr Lcmpc5_out
282: Lcmpc5_str1loop:
283: cmpb (r1),r11
284: jneq Lcmpc5_out
285: incl r1
286: sobgtr r0,Lcmpc5_str1loop
287: Lcmpc5_out:
288: savepsl
289: return
290:
291:
292: /*
293: * Packed Decimal string operations
294: */
295:
296: #define POSITIVE $12
297: #define NEGATIVE $13
298: #define NEGATIVEalt $11
299:
300:
301: .align 1
302: _EMaddp4:
303: toarg(r9,6) # save register r9 in arg6 spot
304: arguw(1,r11) # (1) source length == r11
305: argl(2,r10) # (2) source address == r10
306: arguw(3,r9) # (3) destination length == r9
307: argl(4,r3) # (4) destination address == r3
308: # arg4 will be needed later
309: # arg5 holds destination address of LSNibble temporarily
310: ashl $-1,r11,r11
311: addl2 r11,r10 # source address of LSNibble
312: incl r11 # source length is in bytes
313: ashl $-1,r9,r9
314: addl2 r9,r3 # r3 = destination address of LSNibble
315: incl r9 # destination length is in bytes
316: toarg(r3,5) # stored in arg5 spot
317: extzv $0,$4,(r3),r2 # set standard +/- indicators in destination
318: cmpl r2,NEGATIVE
319: jeql L112
320: cmpl r2,NEGATIVEalt
321: jeql L111
322: insv POSITIVE,$0,$4,(r3)
323: jbr L112
324: L111:
325: insv NEGATIVE,$0,$4,(r3)
326: L112:
327: extzv $0,$4,(r10),r2 # r2 = standard +/- of source
328: cmpl r2,NEGATIVE
329: jeql L114
330: cmpl r2,NEGATIVEalt
331: jeql L113
332: movl POSITIVE,r2
333: jbr L114
334: L113:
335: movl NEGATIVE,r2
336: L114:
337: cmpl r11,r9 # if source is longer than destination
338: jleq L115
339: movl r9,r11 # set source length == destination length
340: L115:
341: extzv $4,$4,(r3),r9 # r9 = LSDigit of destination
342: extzv $4,$4,(r10),r1 # r1 = LSDigit of source
343: extzv $0,$4,(r3),r0
344: cmpl r0,r2 # if signs of operands are not equal
345: jeql Laddp4_same # do a subtraction
346: clrl r2 # r2 is non-zero if result is non-zero
347: subl2 r1,r9 # r9 = "addition" of operands' high nibble
348: jbr L119 # jump into addition loop
349: Laddp4_diff_loop:
350: decl r3
351: extzv $0,$4,(r3),r0
352: addl2 r0,r1 # r1 = carry + next (low) nibble of source
353: decl r10
354: extzv $0,$4,(r10),r0
355: subl2 r0,r1 # r1 -= next (low) nibble of destination
356: jgeq L121 # if negative result
357: mnegl $1,r9 # r9 == carry = -1
358: addl2 $10,r1 # r1 == result += 10
359: jbr L122 # else
360: L121:
361: clrl r9 # r9 == carry = 0
362: L122:
363: insv r1,$0,$4,(r3) # store result low nibble
364: bisl2 r1,r2
365: extzv $4,$4,(r3),r0
366: addl2 r0,r9 # r9 = carry + next (high) nibble of source
367: extzv $4,$4,(r10),r0
368: subl2 r0,r9 # r9 -= next (high) nibble of destination
369: L119:
370: jgeq L117 # if negative result
371: mnegl $1,r1 # r1 == carry = -1
372: addl2 $10,r9 # r9 == result += 10
373: jbr L118 # else
374: L117:
375: clrl r1 # r1 == carry = 0
376: L118:
377: insv r9,$4,$4,(r3) # store result high nibble
378: bisl2 r9,r2 # r2 is non-zero if result is non-zero
379: decl r11 # while (--source length)
380: jneq Laddp4_diff_loop
381: argl(4,r10) # r10 = address of destination MSNibble
382: jbr Laddp4_diff_carry
383: Laddp4_diff_carlop:
384: decl r3
385: extzv $0,$4,(r3),r0
386: addl2 r0,r1 # r1 == carry += next (low) nibble
387: jgeq L127 # if less than zero
388: movl r1,r9 # r9 == carry (must be -1)
389: movl $9,r1 # r1 == result = 9
390: jbr L128
391: L127: # else
392: clrl r9 # r9 == carry = 0
393: L128:
394: insv r1,$0,$4,(r3) # store result
395: bisl2 r1,r2
396: extzv $4,$4,(r3),r0
397: addl2 r0,r9 # r9 == carry += next (high) nibble
398: jgeq L129 # if less than zero
399: movl r9,r1 # r1 == carry (must be -1)
400: movl $9,r9 # r9 == result = 9
401: jbr L130
402: L129:
403: clrl r1
404: L130:
405: insv r9,$4,$4,(r3) # store result
406: bisl2 r9,r2
407: Laddp4_diff_carry:
408: cmpl r3,r10
409: jneq Laddp4_diff_carlop
410: tstl r1 # if carry out of MSN then fix up result
411: jeql Laddp4_add_done
412: argl(5,r3) # r3 == address of LSN of destination
413: extzv $0,$4,(r3),r0
414: cmpl r0,NEGATIVE # switch sign of result
415: jneq L132
416: insv POSITIVE,$0,$4,(r3)
417: jbr L133
418: L132:
419: insv NEGATIVE,$0,$4,(r3)
420: L133:
421: extzv $4,$4,(r3),r0 # normalize result (carry out of MSN into LSN)
422: subl3 r0,$10,r9 # r9 = 10 - destination LSNibble
423: jbr L134
424: L137:
425: movl $9,r1
426: Laddp4_diff_norm:
427: insv r9,$4,$4,(r3)
428: cmpl r3,r10 # while (not at MSNibble)
429: jeql Laddp4_add_done
430: decl r3
431: extzv $0,$4,(r3),r0 # low nibble = (9 + carry) - low nibble
432: subl2 r0,r1
433: cmpl r1,$9
434: jleq L135
435: clrl r1
436: movl $10,r9
437: jbr L136
438: L135:
439: movl $9,r9
440: L136:
441: insv r1,$0,$4,(r3)
442: extzv $4,$4,(r3),r0 # high nibble = (9 + carry) - high nibble
443: subl2 r0,r9
444: L134:
445: cmpl r9,$9
446: jleq L137
447: clrl r9
448: movl $10,r1
449: jbr Laddp4_diff_norm
450:
451: Laddp4_same: # operands are of the same sign
452: clrl r2
453: addl2 r1,r9
454: jbr L139
455: Laddp4_same_loop:
456: decl r3
457: extzv $0,$4,(r3),r0
458: addl2 r0,r1 # r1 == carry += next (low) nibble of dest
459: decl r10
460: extzv $0,$4,(r10),r0
461: addl2 r0,r1 # r1 += next (low) nibble of source
462: cmpl r1,$9 # if result > 9
463: jleq L141
464: movl $1,r9 # r9 == carry = 1
465: subl2 $10,r1 # r1 == result -= 10
466: jbr L142
467: L141: # else
468: clrl r9 # r9 == carry = 0
469: L142:
470: insv r1,$0,$4,(r3) # store result
471: bisl2 r1,r2
472: extzv $4,$4,(r10),r0
473: addl2 r0,r9 # ditto for high nibble
474: extzv $4,$4,(r3),r0
475: addl2 r0,r9
476: L139:
477: cmpl r9,$9
478: jleq L143
479: movl $1,r1
480: subl2 $10,r9
481: jbr L144
482: L143:
483: clrl r1
484: L144:
485: insv r9,$4,$4,(r3)
486: bisl2 r9,r2
487: sobgtr r11,Laddp4_same_loop # while (--source length)
488: argl(4,r10) # r10 = destination address of MSNibble
489: jbr Laddp4_same_carry
490: Laddp4_same_cloop:
491: decl r3
492: extzv $0,$4,(r3),r0 # propagate carry up to MSNibble of destination
493: addl2 r0,r1
494: cmpl r1,$10
495: jneq L147
496: movl $1,r9
497: clrl r1
498: jbr L148
499: L147:
500: clrl r9
501: L148:
502: insv r1,$0,$4,(r3)
503: bisl2 r1,r2
504: extzv $4,$4,(r3),r0
505: addl2 r0,r9
506: cmpl r9,$10
507: jneq L149
508: movl $1,r1
509: clrl r9
510: jbr L150
511: L149:
512: clrl r1
513: L150:
514: insv r9,$4,$4,(r3)
515: bisl2 r9,r2
516: Laddp4_same_carry:
517: cmpl r3,r10
518: jneq Laddp4_same_cloop
519:
520: Laddp4_add_done:
521: argl(5,r3) # r3 = destination address of LSNibble
522: tstl r2 # if zero result
523: jneq L151
524: savepsl # remember that for condition codes
525: insv POSITIVE,$0,$4,(r3) # make sure sign of result is positive
526: jbr Laddp4_out
527: L151: # else
528: extzv $0,$4,(r3),r0
529: cmpl r0,NEGATIVE # if result is negative
530: jneq Laddp4_out
531: mnegl r2,r2 # remember THAT in Cond Codes
532: savepsl
533: Laddp4_out:
534: argl(4,r3)
535: argl(2,r1)
536: clrl r0
537: clrl r2
538: argl(6,r9) # restore r9 from stack
539: return
540:
541:
542: .align 1
543: _EMmovp:
544: arguw(1,r11) # (1) string length == r11
545: argl(2,r10) # (1) source address == r10
546: argl(3,r3) # (1) destination address == r3
547: # we will need arg2 and arg3 later
548: clrl r2 # r2 == non-zero if source is non-zero
549: ashl $-1,r11,r11 # length is number of bytes, not nibbles
550: jeql Lmovp_zlen
551: Lmovp_copy:
552: bisb2 (r10),r2 # keep track of non-zero source
553: movb (r10)+,(r3)+ # move two nibbles
554: sobgtr r11,Lmovp_copy # loop for length of source
555: Lmovp_zlen:
556: extzv $4,$4,(r10),r0 # look at least significant nibble
557: bisl2 r0,r2
558: extzv $0,$4,(r10),r0 # check sign nibble
559: cmpl r0,NEGATIVEalt
560: jeql Lmovp_neg
561: cmpl r0,NEGATIVE
562: jneq Lmovp_pos
563: Lmovp_neg: # source was negative
564: mnegl r2,r2
565: Lmovp_pos:
566: tstl r2 # set condition codes
567: savepsl
568: jeql Lmovp_zero
569: movb (r10),(r3) # move last byte if non-zero result
570: jbr Lmovp_out
571: Lmovp_zero:
572: movb POSITIVE,(r3) # otherwise, make result zero and positive
573: Lmovp_out:
574: clrl r0
575: argl(2,r1)
576: clrl r2
577: argl(3,r3)
578: return
579:
580:
581: /*
582: * Definitions for Editpc instruction
583: *
584: * Here are the commands and their corresponding hex values:
585: *
586: * EPend 0x00
587: * EPend_float 0x01
588: * EPclear_signif 0x02
589: * EPset_signif 0x03
590: * EPstore_sign 0x04
591: * EPload_fill 0x40
592: * EPload_sign 0x41
593: * EPload_plus 0x42
594: * EPload_minus 0x43
595: * EPinsert 0x44
596: * EPblank_zero 0x45
597: * EPreplace_sign 0x46
598: * EPadjust_input 0x47
599: * EPfill 0x80
600: * EPmove 0x90
601: * EPfloat 0xa0
602: *
603: *
604: * r4 is carved up as follows:
605: *
606: * -------------------------------------------
607: * | N Z V C |
608: * -------------------------------------------
609: *
610: * fill character is stuffed into arg5 space
611: * sign character is stuffed into arg6 space
612: */
613:
614: #define SIGNIFBIT $0
615: #define setsignif bisl2 $1,r4
616: #define clsignif bicl2 $1,r4
617: #define OVERFLOWBIT $1
618: #define setoverflow bisl2 $2,r4
619: #define cloverflow bicl2 $2,r4
620: #define ZEROBIT $2
621: #define setzero bisl2 $4,r4
622: #define clzero bicl2 $4,r4
623: #define NEGATIVEBIT $3
624: #define setnegative bisl2 $8,r4
625: #define clnegative bicl2 $8,r4
626: #define putfill movb arg5,(r5)+
627: #define setfill(reg) movb reg,arg5
628: #define putsign movb arg6,(r5)+
629: #define setsign(reg) movb reg,arg6
630:
631:
632: .align 1
633: _EMeditpc:
634: arguw(1,r11) # (1) source length == r11
635: argl(2,r10) # (2) source address == r10
636: argl(3,r3) # (3) pattern address == r3
637: argl(4,r5) # (4) destination address == r5
638: # we will need arg1 and arg2 later
639: # arg5 and arg6 are used for fill and sign - r0 is free
640: setfill($32) # fill character is ' '
641: setsign($32) # sign character is ' '
642: clrl r4 # clear flags
643: ashl $-1,r11,r11 # source length / 2
644: addl3 r11,r10,r2
645: extzv $4,$4,(r2),r1 # r1 == least significant nibble of source
646: L169:
647: cmpl r2,r10
648: jeql L170
649: tstb -(r2) # loop over source packed decimal number
650: jeql L169
651: incl r1 # r1 is non-zero if source is non-zero
652: L170:
653: addl3 r11,r10,r2
654: tstl r1
655: jeql L172 # source is zero - set flags
656: extzv $0,$4,(r2),r11
657: cmpl r11,NEGATIVEalt
658: jeql L9998 # source is negative - set sign and flags
659: cmpl r11,NEGATIVE
660: jneq L175
661: L9998:
662: setnegative
663: setsign($45) # sign character is '-'
664: jbr L175
665: L172:
666: setzero
667: L175:
668: arguw(1,r2) # (1) source length == r2
669: Ledit_case:
670: movzbl (r3)+,r11 # get next edit command (pattern)
671: cmpl r11,$128
672: jlss L180
673: extzv $0,$4,r11,r1 # command has a "count" arg - into r1
674: ashl $-4,r11,r11 # and shift over
675: L180:
676: jbc $6,r11,L181 # "shift" those commands > 64 to 16 and up
677: subl2 $48,r11
678: L181:
679: caseb r11,$0,$0x18 # "do" the command
680: # r11 is available for use, r1 has "count" in it
681: Lcaseb_label:
682: .word Le_end - Lcaseb_label # 00
683: .word Le_end_float - Lcaseb_label # 01
684: .word Le_clear_signif - Lcaseb_label # 02
685: .word Le_set_signif - Lcaseb_label # 03
686: .word Le_store_sign - Lcaseb_label # 04
687: .word Le_end - Lcaseb_label # 05
688: .word Le_end - Lcaseb_label # 06
689: .word Le_end - Lcaseb_label # 07
690: .word Le_fill - Lcaseb_label # 80
691: .word Le_move - Lcaseb_label # 90
692: .word Le_float - Lcaseb_label # a0
693: .word Le_end - Lcaseb_label # b0
694: .word Le_end - Lcaseb_label # c0
695: .word Le_end - Lcaseb_label # d0
696: .word Le_end - Lcaseb_label # e0
697: .word Le_end - Lcaseb_label # f0
698: .word Le_load_fill - Lcaseb_label # 40
699: .word Le_load_sign - Lcaseb_label # 41
700: .word Le_load_plus - Lcaseb_label # 42
701: .word Le_load_minus - Lcaseb_label # 43
702: .word Le_insert - Lcaseb_label # 44
703: .word Le_blank_zero - Lcaseb_label # 45
704: .word Le_replace_sign - Lcaseb_label # 46
705: .word Le_adjust_input - Lcaseb_label # 47
706: Le_end:
707: arguw(1,r0)
708: argl(2,r1)
709: clrl r2
710: decl r3
711: setpsl(r4)
712: clrl r4
713: return
714:
715: Le_end_float:
716: jbs SIGNIFBIT,r4,Ledit_case # if significance not set
717: putsign # drop in the sign
718: # fall into...
719: Le_set_signif:
720: setsignif
721: jbr Ledit_case
722:
723: Le_clear_signif:
724: clsignif
725: jbr Ledit_case
726:
727: Le_store_sign:
728: putsign
729: jbr Ledit_case
730:
731: Le_load_fill:
732: setfill((r3)+)
733: jbr Ledit_case
734:
735: Le_load_plus:
736: jbs NEGATIVEBIT,r4,Lpattern_inc # if non-negative
737: # fall into...
738: Le_load_sign:
739: setsign((r3)+)
740: jbr Ledit_case
741:
742: Le_load_minus:
743: jbs NEGATIVEBIT,r4,Le_load_sign # if negative load the sign
744: incl r3 # else increment pattern
745: jbr Ledit_case
746:
747: Le_insert:
748: jbc SIGNIFBIT,r4,L196 # if significance set, put next byte
749: movb (r3)+,(r5)+
750: jbr Ledit_case
751: L196: # else put in fill character
752: putfill
753: # and throw away character in pattern
754: Le_replace_sign: # we don't do anything with
755: Lpattern_inc: # replace sign `cause we don't
756: incl r3 # get negative zero
757: jbr Ledit_case
758:
759: Le_blank_zero:
760: jbc ZEROBIT,r4,Lpattern_inc # if zero
761: movzbl (r3)+,r11 # next byte is a count
762: jeql Ledit_case
763: subl2 r11,r5 # to back up over output and replace
764: L200:
765: putfill # with fill character
766: sobgtr r11,L200
767: jbr Ledit_case
768:
769: Le_adjust_input:
770: movzbl (r3)+,r0 # get count of nibbles from pattern
771: subl3 r2,r0,r11
772: jgeq Ledit_case # if length of source is > this number
773: L204: # discard digits in source
774: jlbc r2,L206 # use low bit of length to choose nibble
775: bitb $0xf0,(r10) # high nibble
776: jeql L208
777: setsignif # set significance and overflow if
778: setoverflow # wasted digit is non-zero
779: jbr L208
780: L206:
781: bitb $0xf,(r10) # low nibble
782: jeql L209
783: setsignif
784: setoverflow
785: L209:
786: incl r10 # increment to next byte
787: L208:
788: decl r2 # decrement source length
789: incl r11 # continue `till we're out of excess
790: jlss L204
791: jbr Ledit_case
792:
793: Le_fill:
794: tstl r1 # put (count in r1) fill characters
795: jeql Ledit_case
796: Le_fill_loop:
797: putfill
798: sobgtr r1,Le_fill_loop
799: jbr Ledit_case
800:
801: Le_move:
802: tstl r1 # move (count in r1) characters
803: jeql Ledit_case # from source to destination
804: L214:
805: jlbc r2,L215 # read a nibble
806: extzv $4,$4,(r10),r11
807: jbr L216
808: L215:
809: extzv $0,$4,(r10),r11
810: incl r10
811: L216:
812: decl r2 # source length CAN go negative here...
813: tstl r11
814: jeql L218 # if non-zero
815: setsignif # set significance
816: L218:
817: jbc SIGNIFBIT,r4,L219 # if significance set
818: addb3 $48,r11,(r5)+ # put '0' + digit into destination
819: jbr L220
820: L219: # else put fill character
821: putfill
822: L220:
823: sobgtr r1,L214
824: jbr Ledit_case
825:
826: Le_float: # move with floating sign character
827: tstl r1
828: jeql Ledit_case
829: L221:
830: jlbc r2,L222
831: extzv $4,$4,(r10),r11
832: jbr L223
833: L222:
834: extzv $0,$4,(r10),r11
835: incl r10
836: L223:
837: decl r2 # source length CAN go negative here...
838: tstl r11
839: jeql L225
840: jbs SIGNIFBIT,r4,L226
841: putsign
842: L226:
843: setsignif
844: L225:
845: jbc SIGNIFBIT,r4,L227
846: addb3 $48,r11,(r5)+
847: jbr L228
848: L227:
849: putfill
850: L228:
851: sobgtr r1,L221
852: jbr Ledit_case
853:
854:
855: .align 1
856: _EMashp:
857: argb(1,r11) # (1) scale (number to shift) == r11
858: arguw(2,r10) # (2) source length == r10
859: argl(3,r1) # (3) source address == r1
860: argub(4,r2) # (4) rounding factor == r2
861: arguw(5,r3) # (5) destination length == r3
862: toarg(r6,3) # arg3 holds register 6 from caller
863: argl(6,r6) # (6) destination address == r6
864: # we need arg6 for later
865: # arg1 is used for temporary storage
866: # arg2 holds "even or odd" destination length
867: # arg4 is used as general storage
868: # arg5 is used as general storage
869: ashl $-1,r3,r0 # destination length is number of bytes
870: addl2 r0,r6 # destination address == least sig nibble
871: toarg(r6,1) # save in arg1 spot for later
872: ashl $-1,r10,r0
873: addl2 r0,r1 # source address == least sig nibble
874: extzv $0,$4,(r1),r0 # determine sign of source
875: cmpl r0,NEGATIVEalt
876: jeql Lashp_neg
877: cmpl r0,NEGATIVE
878: jeql Lashp_neg
879: movb POSITIVE,(r6)
880: jbr L245
881: Lashp_neg:
882: movb NEGATIVE,(r6)
883: L245:
884: clrl arg2 # arg2 is 1 if dstlen is even, 0 if odd
885: blbs r3,L246
886: incl arg2
887: bisl2 $1,r3 # r3<0> counts digits going into destination
888: L246: # and is flip-flop for which nibble to
889: tstl r11 # write in destination (1 = high, 0 = low)
890: jgeq Lashp_left # (it must start out odd)
891: addl2 r11,r10 # scale is negative (right shift)
892: jgeq Lashp_right
893: clrl r10 # test for shifting whole number out
894: jbr Lashp_setround
895: Lashp_right:
896: divl3 $2,r11,r0
897: addl2 r0,r1 # source address == MSNibble to be shifted off
898: jlbc r11,L249
899: extzv $4,$4,(r1),r0
900: addl2 r0,r2 # round = last nibble to be shifted off + round
901: jbr Lashp_setround
902: L249:
903: extzv $0,$4,(r1),r0
904: addl2 r0,r2 # round = last nibble to be shifted off + round
905: Lashp_setround: # r11<0> now is flip-flop for which nibble to
906: incl r11 # read from source (1 == high, 0 == low)
907: cmpl r2,$9 # set rounding factor to one if nibble shifted
908: jleq Lashp_noround # off + round argument was 10 or greater
909: movl $1,r2
910: jbr Lashp_shift
911: Lashp_zloop:
912: jlbs r3,L257 # don't need to clear high nibble twice
913: clrb -(r6) # clear low (and high) nib of next byte in dest
914: L257:
915: sobgtr r3,L258 # move to next nibble in destination, but
916: incl r3 # don't go beyond the end.
917: L258:
918: decl r11
919: Lashp_left: # while scale is positive
920: jneq Lashp_zloop
921: incl r11 # r11<0> is flip-plop ... (incl sets it to one)
922: Lashp_noround:
923: clrl r2 # no more rounding
924: Lashp_shift:
925: clrl arg4 # arg4 will be used for result condition codes
926: tstl r10
927: jeql Lashp_round
928: Lashp_shloop:
929: jlbc r11,L260
930: extzv $4,$4,(r1),r0
931: jbr L261
932: L260:
933: decl r1
934: extzv $0,$4,(r1),r0
935: L261:
936: incl r11 # flip the source nibble flip/flop
937: addl2 r0,r2 # round += next nibble
938: cmpl r2,$10 # if round == 10
939: jneq L262
940: clrl arg5 # then result = 0 and round = 1
941: movl $1,r2
942: jbr L263
943: L262: # else
944: movl r2,arg5 # store result and round = 0
945: clrl r2
946: L263:
947: bisl2 arg5,arg4 # remember if result was nonzero in arg4
948: decl r3 # move to next nibble early to check
949: cmpl r3,arg2 # if we've moved passed destination limits
950: jgeq Lashp_noovfl # test the result for possible overflow
951: movl arg2,r3 # ignore zero nibbles
952: tstl arg5 # if the nibble was non-zero, overflow
953: jeql L265
954: jbr Lashp_overfl
955: Lashp_noovfl: # else
956: jlbs r3,L264
957: insv arg5,$4,$4,(r6) # put the result into destination (high or low)
958: jbr L265
959: L264:
960: movb arg5,-(r6)
961: L265:
962: sobgtr r10,Lashp_shloop # loop for length of source
963:
964: Lashp_round:
965: tstl r2 # take care of round out of high nibble
966: jeql Lashp_zeroround
967: decl r3
968: cmpl r3,arg2 # if we've moved passed destination limits
969: jlss Lashp_overfl # then overflow
970: jlbs r3,L266
971: insv arg5,$4,$4,(r6) # put the round into destination (high or low)
972: jbr Lashp_zeroround
973: L266:
974: movb arg5,-(r6)
975:
976: Lashp_zeroround:
977: argl(1,r10) # r10 = address of destination LSNibble
978: argl(6,r3) # r3 = address of destination MSNibble
979: movl arg4,r11 # r11 = non-zero if destination == non-zero
980: savepsl
981: jbr L267
982: Lashp_zerofill:
983: clrb -(r6) # fill up MSNs of destination with zeros
984: L267:
985: cmpl r3,r6
986: jneq Lashp_zerofill
987: extzv $0,$4,(r10),r0 # test for negative result
988: cmpl r0,NEGATIVE
989: jneq Lashp_out
990: mnegl r11,r11
991: savepsl
992: jneq Lashp_out # turn -0 into 0
993: insv POSITIVE,$0,$4,(r10)
994: Lashp_out:
995: clrl r0
996: argl(3,r6) # restore r6 from stack
997: return
998: Lashp_overfl: # do overflow
999: clrl r2
1000: overflowpsl
1001: jbr Lashp_out
1002:
1003:
1004: .align 1
1005: _EMcvtlp:
1006: arguw(2,r10) # (2) destination length == r10
1007: argl(3,r3) # (3) destination address == r3
1008: ashl $-1,r10,r10
1009: addl2 r10,r3 # destination address points to Least Sig byte
1010: incl r10 # length is # of bytes, not nibbles
1011: argl(1,r11) # (1) source == r11
1012: savepsl
1013: jgeq Lcvtlp_pos
1014: movb NEGATIVE,(r3) # source is negative
1015: divl3 $10,r11,r0
1016: mull3 $10,r0,r1
1017: subl3 r11,r1,r2 # r2 = source mod 10
1018: mnegl r0,r11 # source = -(source / 10)
1019: jbr Lcvtlp_cvt
1020: Lcvtlp_pos:
1021: movb POSITIVE,(r3) # source is non-negative
1022: divl3 $10,r11,r0
1023: mull3 $10,r0,r1
1024: subl3 r1,r11,r2 # r2 = source mod 10
1025: movl r0,r11 # source = source / 10
1026: Lcvtlp_cvt:
1027: insv r2,$4,$4,(r3) # store least significant digit
1028: tstl r11
1029: jeql Lcvtlp_zloop
1030: Lcvtlp_loop: # while source is non-zero
1031: decl r10 # and for length of destination ...
1032: jeql Lcvtlp_over
1033: divl3 $10,r11,r1 # r1 = source / 10
1034: mull3 $10,r1,r0
1035: subl2 r0,r11 # source = source mod 10
1036: movb r11,-(r3) # store low "nibble" in next significant byte
1037: divl3 $10,r1,r11 # source = r1 / 10
1038: mull3 $10,r11,r0
1039: subl2 r0,r1 # r1 = source mod 10
1040: insv r1,$4,$4,(r3) # store high nibble
1041: tstl r11
1042: jneq Lcvtlp_loop # quit if source becomes zero
1043: Lcvtlp_zloop: # fill any remaining bytes with zeros
1044: decl r10
1045: jeql Lcvtlp_out
1046: clrb -(r3)
1047: jbr Lcvtlp_zloop
1048: Lcvtlp_over:
1049: overflowpsl
1050: Lcvtlp_out:
1051: clrl r1 # r0 is already zero
1052: clrl r2
1053: return
1054:
1055:
1056: .align 1
1057: _EMcvtpl:
1058: arguw(1,r11) # (1) source length == r11
1059: argl(2,r10) # (2) source address == r10
1060: clrl r3 # r3 == destination
1061: movl r10,r1 # r1 set up now for return
1062: ashl $-1,r11,r11 # source length is number of bytes
1063: jeql Lcvtpl_zero
1064: Lcvtpl_loop: # for source length
1065: mull2 $10,r3 # destination *= 10
1066: extzv $4,$4,(r10),r0
1067: addl2 r0,r3 # destination += high nibble
1068: mull2 $10,r3 # destination *= 10
1069: extzv $0,$4,(r10),r0
1070: addl2 r0,r3 # destination += low nibble
1071: incl r10
1072: sobgtr r11,Lcvtpl_loop
1073: Lcvtpl_zero: # least significant byte
1074: mull2 $10,r3
1075: extzv $4,$4,(r10),r0
1076: addl2 r0,r3 # dest = 10 * dest + high nibble
1077: savepsl
1078: extzv $0,$4,(r10),r2 # test sign nibble
1079: cmpl r2,NEGATIVE
1080: jeql Lcvtpl_neg
1081: cmpl r2,NEGATIVEalt
1082: jneq Lcvtpl_out
1083: Lcvtpl_neg: # source was negative - negate destination
1084: mnegl r3,r3
1085: savepsl
1086: Lcvtpl_out:
1087: toarg(r3,3)
1088: clrl r0
1089: clrl r2
1090: clrl r3
1091: return
1092:
1093:
1094: .align 1
1095: _EMcvtps:
1096: return
1097:
1098:
1099: .align 1
1100: _EMcvtsp:
1101: return
1102:
1103:
1104: .align 1
1105: _EMaddp6:
1106: return
1107:
1108:
1109: .align 1
1110: _EMsubp4:
1111: return
1112:
1113:
1114: .align 1
1115: _EMsubp6:
1116: return
1117:
1118:
1119: .align 1
1120: _EMcvtpt:
1121: return
1122:
1123:
1124: .align 1
1125: _EMmulp:
1126: return
1127:
1128:
1129: .align 1
1130: _EMcvttp:
1131: return
1132:
1133:
1134: .align 1
1135: _EMdivp:
1136: return
1137:
1138:
1139: .align 1
1140: _EMcmpp3:
1141: return
1142:
1143:
1144: .align 1
1145: _EMcmpp4:
1146: return
1147:
1148:
1149:
1150:
1151: /*
1152: * Emulation OpCode jump table:
1153: * ONLY GOES FROM 0xf8 (-8) TO 0x3B (59)
1154: */
1155: #define EMUTABLE 0x43
1156: #define NOEMULATE .long noemulate
1157: #define EMULATE(a) .long _EM/**/a
1158: _emJUMPtable:
1159: /* f8 */ EMULATE(ashp); EMULATE(cvtlp); NOEMULATE; NOEMULATE
1160: /* fc */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1161: /* 00 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1162: /* 04 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1163: /* 08 */ EMULATE(cvtps); EMULATE(cvtsp); NOEMULATE; EMULATE(crc)
1164: /* 0c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1165: /* 10 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1166: /* 14 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1167: /* 18 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1168: /* 1c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1169: /* 20 */ EMULATE(addp4); EMULATE(addp6); EMULATE(subp4); EMULATE(subp6)
1170: /* 24 */ EMULATE(cvtpt); EMULATE(mulp); EMULATE(cvttp); EMULATE(divp)
1171: /* 28 */ NOEMULATE; EMULATE(cmpc3); EMULATE(scanc); EMULATE(spanc)
1172: /* 2c */ NOEMULATE; EMULATE(cmpc5); EMULATE(movtc); EMULATE(movtuc)
1173: /* 30 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
1174: /* 34 */ EMULATE(movp); EMULATE(cmpp3); EMULATE(cvtpl); EMULATE(cmpp4)
1175: /* 38 */ EMULATE(editpc); EMULATE(matchc); EMULATE(locc); EMULATE(skpc)
1176:
1177: /*
1178: * The following is called with the stack set up as follows:
1179: *
1180: * (sp): Opcode
1181: * 4(sp): Instruction PC
1182: * 8(sp): Operand 1
1183: * 12(sp): Operand 2
1184: * 16(sp): Operand 3
1185: * 20(sp): Operand 4
1186: * 24(sp): Operand 5
1187: * 28(sp): Operand 6
1188: * 32(sp): Operand 7 (unused)
1189: * 36(sp): Operand 8 (unused)
1190: * 40(sp): Return PC
1191: * 44(sp): Return PSL
1192: * 48(sp): TOS before instruction
1193: *
1194: * Each individual routine is called with the stack set up as follows:
1195: *
1196: * (sp): Return address of trap handler
1197: * 4(sp): Opcode (will get return PSL)
1198: * 8(sp): Instruction PC
1199: * 12(sp): Operand 1
1200: * 16(sp): Operand 2
1201: * 20(sp): Operand 3
1202: * 24(sp): Operand 4
1203: * 28(sp): Operand 5
1204: * 32(sp): Operand 6
1205: * 36(sp): saved register 11
1206: * 40(sp): saved register 10
1207: * 44(sp): Return PC
1208: * 48(sp): Return PSL
1209: * 52(sp): TOS before instruction
1210: */
1211:
1212: .globl Xemulate
1213: .align 2
1214: Xemulate:
1215: movl r11,32(sp) # save register r11 in unused operand
1216: movl r10,36(sp) # save register r10 in unused operand
1217: cvtbl (sp),r10 # get opcode
1218: addl2 $8,r10 # shift negative opcodes
1219: subl3 r10,$EMUTABLE,r11 # forget it if opcode is out of range
1220: bcs noemulate
1221: movl _emJUMPtable[r10],r10 # call appropriate emulation routine
1222: jsb (r10) # routines put return values into regs 0-5
1223: movl 32(sp),r11 # restore register r11
1224: movl 36(sp),r10 # restore register r10
1225: insv (sp),$0,$4,44(sp) # and condition codes in Opcode spot
1226: addl2 $40,sp # adjust stack for return
1227: rei
1228: noemulate:
1229: addl2 $48,sp # adjust stack for
1230: .word 0xffff # "reserved instruction fault"
1231: .globl Xemulfpd
1232: .align 2
1233: Xemulfpd: # emulate, but FPD was set
1234: .word 0xffff # give up right away
1235:
1236: .globl __emulend
1237: __emulend: # end of emulation code
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.