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