![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to convert.c 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 / entry|
Return to convert.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry |
1.1 root 1:
2:
3: /* constants definition for convert instruction */
4: /* */
5: /* */
6: extern long scoplp;
7: extern long force_lp;
8:
9: #define CVTBW 0x99 /*opcodes */
10: #define CVTBL 0x89
11: #define CVTWB 0x33
12: #define CVTWL 0x23
13: #define CVTLB 0x6f
14: #define CVTLW 0x7f
15: asm(".set PSWMASK,0xf");
16: #define MAX_PATTERNS 4
17:
18: #define IDESTB1 0x1111007f /*destination */
19: /*initial values */
20: #define IDESTB2 0x1111aa00 /*for bw,bl */
21: #define IDESTB3 0x1111aaaa
22: #define IDESTB4 0x1111ffff
23:
24:
25: #define IDESTWL1 0x1111007f /* wl */
26: #define IDESTWL2 0x1111aa00
27: #define IDESTWL3 0x1111aaaa
28: #define IDESTWL4 0x11110000
29:
30:
31: #define IDESTWB1 0x111180ff /* wb */
32: #define IDESTWB2 0x11110000
33: #define IDESTWB3 0x11117f80
34: #define IDESTWB4 0x11110080
35:
36:
37: #define IDESTLW1 0xffff0000 /* lw */
38: #define IDESTLW2 0x00008000
39: #define IDESTLW3 0x8000ffff
40: #define IDESTLW4 0x00007fff
41:
42:
43: #define IDESTLB1 0xffffff00 /* lb */
44: #define IDESTLB2 0x00000080
45: #define IDESTLB3 0x800000ff
46: #define IDESTLB4 0x0000007f
47:
48:
49: #define SB1 0x11110080 /*source values */
50: #define SB2 0x1111aa7f /* bw, bl */
51: #define SB3 0x1111aa00
52: #define SB4 0x11110000
53:
54: #define SWL1 0x11118000 /* wl */
55: #define SWL2 0x11117fff
56: #define SWL3 0x11110000
57: #define SWL4 0x11111111
58:
59: #define SWB1 0x11118000 /* wb */
60: #define SWB2 0x111100ff
61: #define SWB3 0x11117f7f
62: #define SWB4 0x1111007f
63:
64: #define SLW1 0xffffffff /*lw */
65: #define SLW2 0x00007fff
66: #define SLW3 0x80000000
67: #define SLW4 0x00008000
68:
69: #define SLB1 0xffffffff /* lb */
70: #define SLB2 0x0000007f
71: #define SLB3 0x80000000
72: #define SLB4 0x00000080
73:
74:
75: #define EXPBW1 0x1111ff80 /*expected destination */
76: #define EXPBW2 0x1111007f /* bw */
77: #define EXPBW3 0x11110000
78: #define EXPBW4 0x11110000
79:
80: #define EXPBL1 0xffffff80 /* bl */
81: #define EXPBL2 0x0000007f
82: #define EXPBL3 0x00000000
83: #define EXPBL4 0x00000000
84:
85: #define EXPWL1 0xffff8000 /* wl */
86: #define EXPWL2 0x00007fff
87: #define EXPWL3 0
88: #define EXPWL4 0x00001111
89:
90: #define EXPWB1 0x11118000 /* wb */
91: #define EXPWB2 0x111100ff
92: #define EXPWB3 0x11117f7f
93: #define EXPWB4 0x1111007f
94:
95:
96: #define FLG1 7 /*initial flags */
97: #define FLG2 8 /* bw, bl, wl */
98: #define FLG3 0
99: #define FLG4 0
100:
101: #define FLGW1 9 /* wb */
102: #define FLGW2 5
103: #define FLGW3 15
104: #define FLGW4 15
105:
106: #define FLGL1 7 /* lw, lb */
107: #define FLGL2 15
108: #define FLGL3 0
109: #define FLGL4 0
110:
111:
112:
113: #define EFLG1 9 /*expected flags */
114: #define EFLG2 1 /* bw, bl */
115: #define EFLG3 5
116: #define EFLG4 5
117:
118: #define EFLGWL1 9 /* wl */
119: #define EFLGWL2 1
120: #define EFLGWL3 5
121: #define EFLGWL4 1
122:
123: #define EFLGWB1 11 /* wb */
124: #define EFLGWB2 3
125: #define EFLGWB3 3
126: #define EFLGWB4 1
127:
128: #define EFLGL1 9 /* lw, lb */
129: #define EFLGL2 1
130: #define EFLGL3 11
131: #define EFLGL4 3
132:
133:
134:
135: #define ERROR1 1 /*error definitions */
136: #define ERROR2 2
137: #define ERROR3 3
138: #define ERROR4 4
139: #define ERROR5 5
140: /*error messages */
141: #define EM1 "destination not equal to expected \n"
142: #define EM2 "source altered by the instruction \n"
143: #define EM3 "flags not equal to expected \n"
144:
145:
146: /* standard definition file */
147: /* for 'C' diagnostic porgrams. */
148: /* */
149: /* */
150: #define HIGH 31
151: #define IPL 18
152: #define PSWMASK 255
153: #define T 16
154: #define IV 32
155: #define FU 64
156: #define DV 128
157: #define FLAGS 0x0000000f
158:
159:
160:
161:
162:
163:
164: /* Global variables for convert test */
165: /* */
166: /* */
167:
168: static short index = 0;
169: static long dest = 0; /*destination location */
170: static long source = 0; /*source location */
171: static long psw; /*processor status word */
172: static long error_count = 0;
173:
174: /*initial flag values */
175: static long flag_valueb[MAX_PATTERNS] = {FLG1,FLG2,FLG3,FLG4};
176: static long flag_valuewl[MAX_PATTERNS] = {FLG1,FLG2,FLG3,FLG4};
177: static long flag_valuewb[MAX_PATTERNS] = {FLGW1,FLGW2,FLGW3,FLGW4};
178: static long flag_valuel[MAX_PATTERNS] = {FLGL1,FLGL2,FLGL3,FLGL4};
179:
180:
181: /*expected destination */
182: static long expbw[MAX_PATTERNS] = {EXPBW1,EXPBW2,EXPBW3,EXPBW4};
183: static long expbl[MAX_PATTERNS] = {EXPBL1,EXPBL2,EXPBL3,EXPBL4};
184: static long expwl[MAX_PATTERNS] = {EXPWL1,EXPWL2,EXPWL3,EXPWL4};
185: static long expwb[MAX_PATTERNS] = {EXPWB1,EXPWB2,EXPWB3,EXPWB4};
186: static long explw[MAX_PATTERNS] = {SLW1,SLW2,SLW3,SLW4};
187: static long explb[MAX_PATTERNS] = {SLB1,SLB2,SLB3,SLB4};
188:
189:
190: /*expected psw */
191: static long exp_pswb[MAX_PATTERNS] = {EFLG1,EFLG2,EFLG3,EFLG4};
192: static long exp_pswwl[MAX_PATTERNS] = {EFLGWL1,EFLGWL2,EFLGWL3,EFLGWL4};
193: static long exp_pswwb[MAX_PATTERNS] = {EFLGWB1,EFLGWB2,EFLGWB3,EFLGWB4};
194: static long exp_pswl[MAX_PATTERNS] = {EFLGL1,EFLGL2,EFLGL3,EFLGL4};
195:
196:
197: /*source values */
198: static long sourceb[MAX_PATTERNS] = {SB1,SB2,SB3,SB4};
199: static long sourcewl[MAX_PATTERNS] = {SWL1,SWL2,SWL3,SWL4};
200: static long sourcewb[MAX_PATTERNS] = {SWB1,SWB2,SWB3,SWB4};
201: static long sourcelw[MAX_PATTERNS] = {SLW1,SLW2,SLW3,SLW4};
202: static long sourcelb[MAX_PATTERNS] = {SLB1,SLB2,SLB3,SLB4};
203:
204:
205: /*initial destination values */
206: static long destb[MAX_PATTERNS] = {IDESTB1,IDESTB2,IDESTB3,IDESTB4};
207: static long destwl[MAX_PATTERNS] = {IDESTWL1,IDESTWL2,IDESTWL3,IDESTWL4};
208: static long destwb[MAX_PATTERNS] = {IDESTWB1,IDESTWB2,IDESTWB3,IDESTWB4};
209: static long destlw[MAX_PATTERNS] = {IDESTLW1,IDESTLW2,IDESTLW3,IDESTLW4};
210: static long destlb[MAX_PATTERNS] = {IDESTLB1,IDESTLB2,IDESTLB3,IDESTLB4};
211:
212: static char *tst_name;
213: convert()
214: {
215: asm("movl $2,_no_opr");
216: tst_name = " ** CVTLB ** \n";
217: cvtlb();
218: tst_name = " ** CVTLW ** \n";
219: cvtlw();
220: tst_name = " ** CVTBL ** \n";
221: cvtbl();
222: tst_name = " ** CVTWL ** \n";
223: cvtwl(); /* convert word to long */
224: tst_name = " ** CVTWB ** \n";
225: cvtwb(); /* convert word to byte */
226: tst_name = " ** CVTBW ** \n";
227: cvtbw(); /* convert byte to word */
228: asm("jmp *return");
229: }
230:
231: static long *p_destwb;
232: static long *p_destb;
233: static long *p_destlb;
234: static long *p_destlw;
235: static long *p_destwl;
236: static long *p_exp_pswb;
237: static long *p_exp_pswl;
238: static long *p_exp_pswwb;
239: static long *p_exp_pswwl;
240: static long *p_expbl;
241: static long *p_expbw;
242: static long *p_explb;
243: static long *p_explw;
244: static long *p_expwb;
245: static long *p_expwl;
246: static long *p_sourceb;
247: static long *p_sourcelb;
248: static long *p_sourcelw;
249: static long *p_sourcewb;
250: static long *p_sourcewl;
251:
252: static init_ptr()
253: {
254: p_destwb = destwb;
255: p_destb = destb;
256: p_destlb = destlb;
257: p_destlw = destlw;
258: p_destwl = destwl;
259: p_exp_pswb = exp_pswb;
260: p_exp_pswl = exp_pswl;
261: p_exp_pswwb = exp_pswwb;
262: p_exp_pswwl = exp_pswwl;
263: p_expbl = expbl;
264: p_expbw = expbw;
265: p_explb = explb;
266: p_explw = explw;
267: p_expwb = expwb;
268: p_expwl = expwl;
269: p_sourceb = sourceb;
270: p_sourcelb = sourcelb;
271: p_sourcelw = sourcelw;
272: p_sourcewb = sourcewb;
273: p_sourcewl = sourcewl;
274: }
275:
276: static bump_ptr()
277: {
278: p_destwb++;
279: p_destb++;
280: p_destlb++;
281: p_destlw++;
282: p_destwl++;
283: p_exp_pswb++;
284: p_exp_pswl++;
285: p_exp_pswwb++;
286: p_exp_pswwl++;
287: p_expbl++;
288: p_expbw++;
289: p_explb++;
290: p_explw++;
291: p_expwb++;
292: p_expwl++;
293: p_sourceb++;
294: p_sourcelb++;
295: p_sourcelw++;
296: p_sourcewb++;
297: p_sourcewl++;
298: }
299:
300: static cvtwb() /* convert word to byte test */
301: {
302: asm("bicpsw $PSWMASK"); /*psw = 0*/
303: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
304: {
305: t_cvtwb ();
306: t_cvtwb1(); /*one more test where */
307: /* dest address = source address */
308: }
309: }
310:
311:
312: static t_cvtwb() /*single test called by main test*/
313: {
314: for ( ; ; )
315: {
316: setjmp();
317: asm("c1: movab c1,_stpc");
318: asm("movl $1,_subtst");
319: dest = *p_destwb; /*initialize dest.,source & psw */
320: source = *p_sourcewb;
321: asm("movw _index,r10");
322: asm("bicpsw $PSWMASK");
323: asm("bispsw _flag_valuewb[r10]");
324: /*execute cvt instruction */
325: asm("cvtwb _source+2,_dest+3"); /* memory to memory */
326: asm("movpsl _psw"); /*save psw */
327: psw &= FLAGS; /*mask out all bits except flag bits */
328: if (dest != *p_expwb)
329: {
330: asm("movl $1,_ercode");
331: if (scoplp) longjmp();
332: error(dest,*p_expwb,source,*p_destwb,*p_expwb,dest);
333: }
334: if (source != *p_sourcewb)
335: {
336: asm("movl $3,_ercode");
337: if (scoplp) longjmp();
338: error(source,*p_sourcewb,source,*p_destwb);
339: }
340: if (psw != *p_exp_pswwb)
341: {
342: asm("movl $2,_ercode");
343: if (scoplp) longjmp();
344: error(psw,*p_exp_pswwb,source,dest);
345: }
346: if (force_lp) longjmp();
347: else
348: return(0); /*no error exit*/
349: }
350: }
351:
352:
353: /*single test 1 called by main test*/
354: /*source location = destination location*/
355: static t_cvtwb1()
356: {
357:
358: for ( ; ; )
359: {
360: /*initialize source, & psw */
361: setjmp();
362: asm("c2: movab c2,_stpc");
363: asm("movl $2,_subtst");
364: source = *p_sourcewb;
365: asm("movw _index,r10");
366: asm("movw _source+2,r5"); /* load first operand register */
367: asm("movl _source,r6"); /* load first operand register */
368: asm("bicpsw $PSWMASK");
369: asm("bispsw _flag_valuel[r10]");
370: /*execute cvt instruction */
371: asm("cvtwb r5,r6"); /* register to register */
372: asm("movpsl _psw"); /*save psw */
373: psw &= FLAGS; /*mask out all bits except flag bits */
374: source = *p_expwb;
375: if (source != *p_expwb)
376: {
377: asm("movl $1,_ercode");
378: if (scoplp) longjmp();
379: error(source,*p_expwb,*p_sourcewb,*p_sourcewb);
380: }
381: if (psw != *p_exp_pswwb)
382: {
383: asm("movl $1,_ercode");
384: if (scoplp) longjmp();
385: error(psw,*p_exp_pswwb,*p_sourcewb,*p_sourcewb);
386: }
387: if (force_lp) longjmp();
388: else
389: return(0); /*no error exit*/
390: }
391: }
392:
393:
394:
395: static cvtwl() /* convert word to long test */
396: {
397: asm("bicpsw $PSWMASK"); /*psw = 0*/
398: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
399: {
400: t_cvtwl ();
401: t_cvtwl1(); /*one more test where */
402: /* dest address = source address */
403: }
404: }
405:
406: static t_cvtwl() /*single test called by main test*/
407: {
408: for ( ; ; )
409: {
410: setjmp();
411: asm("c3: movab c3,_stpc");
412: asm("movl $3,_subtst");
413: dest = *p_destwl; /*initialize dest., source, & psw */
414: source = *p_sourcewl;
415: asm("movw _index,r10");
416: asm("bicpsw $PSWMASK");
417: asm("bispsw _flag_valueb[r10]");
418: /*execute cvt instruction */
419: asm("cvtwl _source+2,_dest"); /* memory to memory */
420: asm("movpsl _psw"); /*save psw */
421: psw &= FLAGS; /*mask out all bits except flag bits */
422: if (dest != *p_expwl)
423: {
424: asm("movl $1,_ercode");
425: if (scoplp) longjmp();
426: error(dest,*p_destwl,source,*p_destwl);
427: }
428: if (source != *p_sourcewl)
429: {
430: asm("movl $3,_ercode");
431: if (scoplp) longjmp();
432: error(source,*p_sourcewl,source,*p_destwl);
433: }
434: if (psw != *p_exp_pswwl)
435: {
436: asm("movl $2,_ercode");
437: if (scoplp) longjmp();
438: error(psw,*p_exp_pswwl,source,*p_destwl);
439: }
440: if (force_lp) longjmp();
441: else
442: return(0); /*no error exit*/
443: }
444: }
445:
446:
447:
448: /*single test 1 called by main test*/
449: /* register to register operation */
450: static t_cvtwl1()
451: {
452:
453: for ( ; ; )
454: {
455: /*initialize source, & psw */
456: setjmp();
457: asm("c4: movab c4,_stpc");
458: asm("movl $4,_subtst");
459: source = *p_sourcewl;
460: asm("movw _index,r10");
461: asm("movw _source+2,r5"); /* load first operand register */
462: asm("movl _source,r6"); /* load second operand register */
463: asm("bicpsw $PSWMASK");
464: asm("bispsw _flag_valueb[r10]");
465: /*execute cvt instruction */
466: asm("cvtwl r5,r6"); /* register to register operation */
467: asm("movpsl _psw"); /*save psw */
468: psw &= FLAGS; /*mask out all bits except flag bits */
469: asm("movl r6,_source") /* reload source location */
470: if (source != *p_expwl)
471: {
472: asm("movl $1,_ercode");
473: if (scoplp) longjmp();
474: error(source,*p_sourcewl,*p_sourcewl,*p_sourcewl);
475: }
476: if (psw != *p_exp_pswwl)
477: {
478: asm("movl $2,_ercode");
479: if (scoplp) longjmp();
480: error(psw,*p_exp_pswwl,*p_sourcewl,*p_sourcewl);
481: }
482: if (force_lp) longjmp();
483: else
484: return(0); /*no error exit*/
485: } /*end of for loop*/
486: } /*end of test*/
487:
488:
489:
490: static cvtbw() /* convert byte to long test */
491:
492: {
493: asm("bicpsw $PSWMASK"); /*psw = 0*/
494: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
495: {
496: t_cvtbw ();
497: t_cvtbw1(); /*one more test where */
498: /* dest address = source address */
499: }
500: }
501:
502: static t_cvtbw() /*single test called by main test*/
503: {
504: for ( ; ; )
505: {
506: setjmp();
507: asm("c5: movab c5,_stpc");
508: asm("movl $5,_subtst");
509: dest = *p_destb; /*initialize destination, source, & psw */
510: source = *p_sourceb;
511: asm("movw _index,r10");
512: asm("bicpsw $PSWMASK");
513: asm("bispsw _flag_valueb[r10]");
514: /*execute cvt instruction */
515: asm("cvtbw _source+3,_dest+2"); /* memory to memory */
516: asm("movpsl _psw"); /*save psw */
517: psw &= FLAGS; /*mask out all bits except flag bits */
518: if (dest != *p_expbw)
519: {
520: asm("movl $1,_ercode");
521: if (scoplp) longjmp();
522: error(dest,*p_expbw,source,*p_destb);
523: }
524: if (source != *p_sourceb)
525: {
526: asm("movl $3,_ercode");
527: if (scoplp) longjmp();
528: error(source,*p_sourceb,source,*p_destb);
529: }
530: if (psw != *p_exp_pswb)
531: {
532: asm("movl $2,_ercode");
533: if (scoplp) longjmp();
534: error(psw,*p_exp_pswb,source,*p_destb);
535: }
536: if (force_lp) longjmp();
537: else
538: return(0); /*no error exit*/
539: }
540: }
541:
542: /*single test 1 called by main test*/
543: /*source location = destination location*/
544: static t_cvtbw1()
545: {
546: for ( ; ; )
547: {
548: /*initialize source, & psw */
549: setjmp();
550: asm("c6: movab c6,_stpc");
551: asm("movl $6,_subtst");
552: source = *p_sourceb;
553: asm("movb _source+3,r5"); /* load first operand register */
554: asm("movl _source,r6"); /* load second operand register */
555: asm("movw _index,r10");
556: asm("bicpsw $PSWMASK");
557: asm("bispsw _flag_valueb[r10]");
558: /*execute cvt instruction */
559: asm("cvtbw _source+3,_source+2"); /* register to register */
560: asm("movpsl _psw"); /*save psw */
561: psw &= FLAGS; /*mask out all bits except flag bits */
562: if (source != *p_expbw)
563: {
564: asm("movl $1,_ercode");
565: if (scoplp) longjmp();
566: error(source,*p_expbw,*p_sourceb,*p_sourceb);
567: }
568: if (psw != *p_exp_pswb)
569: {
570: asm("movl $2,_ercode");
571: if (scoplp) longjmp();
572: error(psw,*p_exp_pswb,*p_sourceb,*p_sourceb);
573: }
574: if (force_lp) longjmp();
575: else
576: return(0); /*no error exit*/
577: } /*end of for loop*/
578: } /*end of test*/
579:
580:
581:
582:
583: static cvtlb() /* convert long to byte */
584: {
585: asm("bicpsw $PSWMASK"); /*psw = 0*/
586: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
587: {
588: t_cvtlb ();
589: t_cvtlb1(); /*one more test where */
590: /* dest address = source address */
591: }
592: }
593:
594: static t_cvtlb() /*single test called by main test*/
595: {
596:
597: for ( ; ; )
598: {
599: setjmp();
600: asm("c7: movab c7,_stpc");
601: asm("movl $7,_subtst");
602: dest = *p_destlb; /*init destination, source, & psw */
603: source = *p_sourcelb;
604: asm("movw _index,r10");
605: asm("bicpsw $PSWMASK");
606: asm("bispsw _flag_valuel[r10]");
607: /*execute cvt instruction */
608: asm("cvtlb _source,_dest+3"); /* memory to memory */
609: asm("movpsl _psw"); /*save psw */
610: psw &= FLAGS; /*mask out all bits except flag bits */
611: if (dest != *p_explb)
612: {
613: asm("movl $1,_ercode");
614: if (scoplp) longjmp();
615: error(dest,*p_explb,source,*p_destlb);
616: }
617: if (source != *p_sourcelb)
618: {
619: asm("movl $3,_ercode");
620: if (scoplp) longjmp();
621: error(source,*p_sourcelb,source,*p_destlb);
622: }
623: if (psw != *p_exp_pswl)
624: {
625: asm("movl $2,_ercode");
626: if (scoplp) longjmp();
627: error(psw,*p_exp_pswl,source,*p_destlb);
628: }
629: if (force_lp) longjmp();
630: else
631: return(0); /*no error exit*/
632: }
633: }
634:
635:
636:
637: static t_cvtlb1 () /*single test 1 called by main test*/
638: /*source location = destination location*/
639: {
640:
641: for ( ; ; )
642: {
643: /*initialize source, & psw */
644: setjmp();
645: asm("c8: movab c8,_stpc");
646: asm("movl $8,_subtst");
647: source = *p_sourcelb;
648: asm("movw _index,r10");
649: asm("movl _source,r5"); /* load first operand register */
650: asm("movl _source,r6"); /* load second operand register */
651: asm("bicpsw $PSWMASK");
652: asm("bispsw _flag_valuel[r10]");
653: /*execute cvt instruction */
654: asm("cvtlb r5,r6"); /* register to register */
655: asm("movpsl _psw"); /*save psw */
656: psw &= FLAGS; /*mask out all bits except flag bits */
657: asm("movb r6,_source+3"); /* load source location */
658: if (source != *p_explb)
659: {
660: asm("movl $1,_ercode");
661: if (scoplp) longjmp();
662: error(source,*p_explb,*p_sourcelb,*p_sourcelb);
663: }
664: if (psw != *p_exp_pswl)
665: {
666: asm("movl $2,_ercode");
667: if (scoplp) longjmp();
668: error(psw,*p_exp_pswl,*p_sourcelb,*p_sourcelb);
669: }
670: if (force_lp) longjmp();
671: else
672: return(0); /*no error exit*/
673: } /*end of for loop*/
674: } /*end of test*/
675:
676:
677:
678: static cvtlw() /* convert long to word */
679: {
680: asm("bicpsw $PSWMASK"); /*psw = 0*/
681: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
682: {
683: t_cvtlw ();
684: t_cvtlw1(); /*one more test where */
685: /* dest address = source address */
686: }
687: }
688:
689: static t_cvtlw() /*single test called by main test*/
690: {
691: for ( ; ; )
692: {
693: setjmp();
694: asm("c9: movab c9,_stpc");
695: asm("movl $9,_subtst");
696: dest = *p_destlw; /*init destination, source, & psw */
697: source = *p_sourcelw;
698: asm("movw _index,r10");
699: asm("bicpsw $PSWMASK");
700: asm("bispsw _flag_valuel[r10]");
701: /*execute cvt instruction */
702: asm("cvtlw _source,_dest+2"); /* memory to memory */
703: asm("movpsl _psw"); /*save psw */
704: psw &= FLAGS; /*mask out all bits except flag bits */
705: if (dest != *p_explw)
706: {
707: asm("movl $1,_ercode");
708: if (scoplp) longjmp();
709: error(dest,*p_explw,source,*p_destlw);
710: }
711: if (source != *p_sourcelw)
712: {
713: asm("movl $3,_ercode");
714: if (scoplp) longjmp();
715: error(source,*p_sourcelw,source,*p_destlw);
716: }
717: if (psw != *p_exp_pswl)
718: {
719: asm("movl $2,_ercode");
720: if (scoplp) longjmp();
721: error(psw,*p_exp_pswl,source,*p_destlw);
722: }
723: if (force_lp) longjmp();
724: else
725: return(0); /*no error exit*/
726: }
727: }
728:
729:
730:
731: static t_cvtlw1 () /*single test 1 called by main test*/
732: /*source location = destination location*/
733: {
734:
735: for ( ; ; )
736: {
737: /*initialize source, & psw */
738: setjmp();
739: asm("c10: movab c10,_stpc");
740: asm("movl $0xa,_subtst");
741: source = *p_sourcelw;
742: asm("movw _index,r10");
743: asm("movl _source,r5"); /* load first operand register */
744: asm("movl _source,r6"); /* load second operand register */
745: asm("bicpsw $PSWMASK");
746: asm("bispsw _flag_valuel[r10]");
747: /*execute cvt instruction */
748: asm("cvtlw r5,r6"); /* register to register operation */
749: asm("movpsl _psw"); /*save psw */
750: psw &= FLAGS; /*mask out all bits except flag bits */
751: asm("movw r6,_source+2"); /* load source location */
752: if (source != *p_explw)
753: {
754: asm("movl $1,_ercode");
755: if (scoplp) longjmp();
756: error(source,*p_explw,*p_sourcelw,*p_sourcelw);
757: }
758: if (psw != *p_exp_pswl)
759: {
760: asm("movl $2,_ercode");
761: if (scoplp) longjmp();
762: error(psw,*p_exp_pswl,*p_sourcelw,*p_sourcelw);
763: }
764: if (force_lp) longjmp();
765: else
766: return(0); /*no error exit*/
767: }
768: }
769:
770:
771:
772: static cvtbl() /* convert byte to long test */
773: {
774: asm("bicpsw $PSWMASK"); /*psw = 0*/
775: for (init_ptr(), index = 0; index < MAX_PATTERNS; bump_ptr(), index++)
776: {
777: t_cvtbl ();
778: t_cvtbl1(); /*one more test where */
779: /* dest address = source address */
780: }
781: }
782:
783: static t_cvtbl() /*single test called by main test*/
784: {
785:
786: for ( ; ; )
787: {
788: setjmp();
789: asm("c11: movab c11,_stpc");
790: asm("movl $0xb,_subtst");
791: dest = *p_destb; /*initialize destination, source, & psw */
792: source = *p_sourceb;
793: asm("movw _index,r10");
794: asm("bicpsw $PSWMASK");
795: asm("bispsw _flag_valueb[r10]");
796: /*execute cvt instruction */
797: asm("cvtbl _source+3,_dest"); /* memory to memory */
798: asm("movpsl _psw"); /*save psw */
799: psw &= FLAGS; /*mask out all bits except flag bits */
800: if (dest != *p_expbl)
801: {
802: asm("movl $1,_ercode");
803: if (scoplp) longjmp();
804: error(dest,*p_expbl,source,*p_destb);
805: }
806: if (source != *p_sourceb)
807: {
808: asm("movl $3,_ercode");
809: if (scoplp) longjmp();
810: error(source,*p_sourceb,source,*p_destb);
811: }
812: if (psw != *p_exp_pswb)
813: {
814: asm("movl $2,_ercode");
815: if (scoplp) longjmp();
816: error(psw,*p_exp_pswb,source,*p_destb,*p_exp_pswb,psw);
817: }
818: if (force_lp) longjmp();
819: else
820: return(0); /*no error exit*/
821: }
822: }
823:
824:
825:
826: static t_cvtbl1 () /*single test 1 called by main test*/
827: /*source location = destination location*/
828: {
829:
830: for ( ; ; )
831: {
832: /*initialize source, & psw */
833: setjmp();
834: asm("c12: movab c12,_stpc");
835: asm("movl $0xc,_subtst");
836: source = *p_sourceb;
837: asm("movw _index,r10");
838: asm("movb _source+3,r5"); /* load first operand register */
839: asm("movl _source,r6"); /* load second operand register */
840: asm("bicpsw $PSWMASK");
841: asm("bispsw _flag_valueb[r10]");
842: /*execute cvt instruction */
843: asm("cvtbl r5,r6"); /* register to register operation */
844: asm("movpsl _psw"); /*save psw */
845: asm("movl r6,_source"); /* reload source register */
846: psw &= FLAGS; /*mask out all bits except flag bits */
847: if (source != *p_expbl)
848: {
849: asm("movl $1,_ercode");
850: if (scoplp) longjmp();
851: error(source,*p_expbl,*p_sourceb,*p_sourceb);
852: }
853: if (psw != *p_exp_pswb)
854: {
855: asm("movl $2,_ercode");
856: if (scoplp) longjmp();
857: error(psw,*p_exp_pswb,*p_sourceb,*p_sourceb);
858: }
859: if (force_lp) longjmp();
860: else
861: return(0); /*no error exit*/
862: } /*end of for loop*/
863: } /*end of test*/
864:
865:
866:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.