![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to movz.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 movz.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry |
1.1 root 1:
2: /* constants definition for mzeroextended instruction */
3: /* */
4: /* */
5:
6: #define MOVZBW 0xb9 /*opcodes */
7: #define MOVZBL 0xa9
8: #define MOVZWL 0xc3
9:
10: extern long scoplp;
11: extern long force_lp;
12:
13: asm(".set PSWMASK,0xf");
14:
15: #define MAX_PATTERNS 2
16:
17: #define IDESTB1 0xaaaaaa00 /*destination */
18: /*initial values */
19: #define IDESTB2 0xaaaaaaaa
20: #define IDESTW1 0xffff0000
21: #define IDESTW2 -1
22:
23: #define SB1 0xaaaaaaff /*source values */
24: #define SB2 0xaaaaaa00
25: #define SW1 -1
26: #define SW2 0xffff0000
27:
28: #define EDESTBW1 0xaaaa00ff /*expected destination */
29: #define EDESTBW2 0xaaaa0000
30:
31: #define EDESTBL1 0x000000ff
32: #define EDESTBL2 0
33:
34: #define EDESTWL1 0x0000ffff
35: #define EDESTWL2 0
36:
37: #define FLG1 14 /*initial flags */
38: #define FLG2 1
39:
40: #define EFLG1 1 /*expected flags */
41: #define EFLG2 5
42:
43: #define ERROR1 1 /*error definitions */
44: #define ERROR2 2
45: #define ERROR3 3
46: #define ERROR4 4
47: #define ERROR5 5
48: /*error messages */
49:
50: /* standard definition file */
51: /* for 'C' diagnostic porgrams. */
52: /* */
53: /* */
54: #define HIGH 31
55: #define IPL 18
56: #define PSWMASK 255
57: #define FLAGS 0x0000000f
58:
59:
60:
61:
62:
63: /* Global variables for movz test */
64: /* */
65: /* */
66:
67: static long index = 0;
68: static long dest = 0; /*destination location */
69: static long source = 0; /*source location */
70: static long psw; /*processor status word */
71:
72: static long flag_value[MAX_PATTERNS] = {FLG1,FLG2};
73: /*flag values for initialization */
74:
75: static long error_count = 0;
76:
77:
78: static long expbw[MAX_PATTERNS] = {EDESTBW1,EDESTBW2};
79: /*expected values */
80:
81: static long expbl[MAX_PATTERNS] = {EDESTBL1,EDESTBL2};
82: static long expwl[MAX_PATTERNS] = {EDESTWL1,EDESTWL2};
83:
84:
85: static long exp_psw[MAX_PATTERNS] = {EFLG1,EFLG2};
86: /*expected psw */
87:
88: static long sourceb[MAX_PATTERNS] = {SB1,SB2};
89: /*source values */
90:
91: static long sourcew[MAX_PATTERNS] = {SW1,SW2};
92:
93: static long destb[MAX_PATTERNS] = {IDESTB1,IDESTB2};
94: static long destw[MAX_PATTERNS] = {IDESTW1,IDESTW2};
95:
96:
97: static char *title;
98: movz()
99: {
100: asm("movl $2,_no_opr");
101: title = "** MOVZ_WL **\n";
102: movzwl();
103: title = "** MOVZ_BW **\n";
104: movzbw();
105: title = "** MOVZ_BL **\n";
106: movzbl();
107: asm("jmp *return");
108: }
109:
110:
111: static movzwl() /* move zero extended word to long test */
112: {
113: asm("bicpsw $PSWMASK"); /*psw = 0*/
114: for(index=0; index<MAX_PATTERNS; index++)
115: {
116: t_movzwl();
117: t_movzwl1(); /* Special case : dest. addr = src addr */
118: }
119: }
120:
121: static t_movzwl() /*single test called by main test*/
122: {
123: long *lptr, exp_dest, op1, op2, exp_flg;
124:
125: for (;;)
126: {
127: setjmp();
128: asm("m1: movab m1,_stpc");
129: asm("movl $1,_subtst");
130: lptr = destw+index;
131: op2 = dest = *lptr; /* Use pointer instead of index */
132: /* dest = destw[index]; */
133: lptr = sourcew+index;
134: op1 = source = *lptr;
135: /* source = sourcew[index]; */
136: asm("movw _index,r10");
137: asm("bicpsw $PSWMASK");
138: asm("bispsw _flag_value[r10]");
139: asm("movzwl _source+2,_dest"); /* memory to memory */
140: asm("movpsl _psw"); /* save psw */
141: psw &= FLAGS; /* Get flag bits */
142: lptr = expwl+index;
143: exp_dest = *lptr;
144: if (dest != exp_dest)
145: {
146: asm("movl $1,_ercode");
147: if (scoplp) longjmp();
148: error(dest,exp_dest,op1,op2);
149: }
150: if (source != op1)
151: {
152: asm("movl $3,_ercode");
153: if (scoplp) longjmp();
154: error(source,op1,op1,op2);
155: }
156: lptr = exp_psw+index;
157: exp_flg = *lptr;
158: if (psw != exp_flg)
159: {
160: asm("movl $2,_ercode");
161: if (scoplp) longjmp();
162: error(psw,exp_flg,op1,op2,exp_flg,psw);
163: }
164: if (force_lp) longjmp();
165: else
166: return(0); /*no error exit*/
167: }
168: }
169:
170: static t_movzwl1()
171: {
172: long *lptr, op1, op2, exp_dest, exp_flg;
173:
174: for (;;)
175: {
176: setjmp();
177: asm("m2: movab m2,_stpc");
178: asm("movl $2,_subtst");
179: lptr = sourcew+index;
180: op1 = source = *lptr;
181: /* source = sourcew[index]; */
182: asm("movw _index,r10");
183: asm("bicpsw $PSWMASK");
184: asm("bispsw _flag_value[r10]");
185: asm("movzwl _source+2,_source"); /* register to memory */
186: asm("movpsl _psw"); /* Save psw */
187: psw &= FLAGS; /* Get flags */
188: lptr = expwl+index;
189: exp_dest = *lptr;
190: if (source != exp_dest)
191: {
192: asm("movl $1,_ercode");
193: if (scoplp) longjmp();
194: error(source,exp_dest,op1,op1);
195: }
196: lptr = exp_psw+index;
197: exp_flg = *lptr;
198: if (psw != exp_flg)
199: {
200: asm("movl $2,_ercode");
201: if (scoplp) longjmp();
202: error(psw,exp_flg,op1,op1);
203: }
204: if (force_lp) longjmp();
205: else
206: return(0); /*no error exit*/
207: }
208: }
209:
210:
211:
212: static movzbw() /* move zero extended byte to word test */
213: {
214: asm("bicpsw $PSWMASK"); /*psw = 0*/
215: for (index = 0; index < MAX_PATTERNS; index++)
216: {
217: t_movzbw ();
218: t_movzbw1(); /*one more test where */
219: /* dest address = source address */
220: t_movzbw2(); /*one more test where */
221: /* register to register */
222: }
223: }
224:
225:
226: static t_movzbw()
227: {
228:
229: for (;;)
230: {
231: setjmp();
232: asm("m3: movab m3,_stpc");
233: asm("movl $3,_subtst");
234: dest = destb[index]; /*initialize destination, source, & psw */
235: source = sourceb[index];
236: asm("movw _index,r10");
237: asm("bicpsw $PSWMASK");
238: asm("bispsw _flag_value[r10]");
239: asm("movzbw _source+3,_dest+2"); /* memory to memory */
240: asm("movpsl _psw"); /*save psw */
241: psw &= FLAGS; /*mask out all bits except flag bits */
242: if (dest != expbw[index])
243: {
244: asm("movl $1,_ercode");
245: if (scoplp) longjmp();
246: error(dest,expbw[index],source,destb[index],expbw[index],dest);
247: }
248: if (source != sourceb[index])
249: {
250: asm("movl $3,_ercode");
251: if (scoplp) longjmp();
252: error(source,sourceb[index],source,destb[index]);
253: }
254: if (psw != exp_psw[index])
255: {
256: asm("movl $2,_ercode");
257: if (scoplp) longjmp();
258: error(psw,exp_psw[index],source,destb[index]);
259: }
260: if (force_lp) longjmp();
261: else
262: return(0);
263: }
264: }
265:
266:
267:
268: static t_movzbw1()
269: {
270:
271: for (;;)
272: {
273: /*initialize source, & psw */
274: setjmp();
275: asm("m4: movab m4,_stpc");
276: asm("movl $4,_subtst");
277: source = sourceb[index];
278: asm("movw _index,r10");
279: asm("movl _source,r5"); /* load source register */
280: asm("bicpsw $PSWMASK");
281: asm("bispsw _flag_value[r10]");
282: asm("movzbw _source+3,_source+2");
283: asm("movpsl _psw"); /*save psw */
284: psw &= FLAGS; /*mask out all bits except flag bits */
285: if (source != expbw[index])
286: {
287: asm("movl $1,_ercode");
288: if (scoplp) longjmp();
289: error(source,expbw[index],sourceb[index],sourceb[index]);
290: }
291: if (psw != exp_psw[index])
292: {
293: asm("movl $2,_ercode");
294: if (scoplp) longjmp();
295: error(psw,exp_psw[index],sourceb[index],sourceb[index]);
296: }
297: if (force_lp) longjmp();
298: else
299: return(0);
300: }
301: }
302:
303: static t_movzbw2()
304: {
305:
306: for (;;)
307: {
308: /*initialize source, & psw */
309: setjmp();
310: asm("m5: movab m5,_stpc");
311: asm("movl $5,_subtst");
312: source = sourceb[index];
313: asm("movw _index,r10");
314: asm("movl _source,r5"); /* load source register */
315: asm("movl _source,r6"); /* load dest register */
316: asm("bicpsw $PSWMASK");
317: asm("bispsw _flag_value[r10]");
318: asm("movzbw _source+3,_source+2");
319: asm("movpsl _psw"); /*save psw */
320: psw &= FLAGS; /*mask out all bits except flag bits */
321: if (source != expbw[index])
322: {
323: asm("movl $1,_ercode");
324: if (scoplp) longjmp();
325: error(source,expbw[index],sourceb[index],sourceb[index]);
326: }
327: if (psw != exp_psw[index])
328: {
329: asm("movl $2,_ercode");
330: if (scoplp) longjmp();
331: error(psw,exp_psw[index],sourceb[index],sourceb[index]);
332: }
333: if (force_lp) longjmp();
334: else
335: return(0);
336: }
337: }
338:
339: static movzbl()
340: {
341: asm("bicpsw $PSWMASK"); /*psw = 0*/
342: for (index = 0; index < MAX_PATTERNS; index++)
343: {
344: t_movzbl ();
345: t_movzbl1(); /*one more test where */
346: /* dest address = source address */
347: }
348: }
349:
350: static t_movzbl()
351: {
352:
353: for (;;)
354: {
355: setjmp();
356: asm("m6: movab m6,_stpc");
357: asm("movl $6,_subtst");
358: dest = destb[index]; /*initialize destination, source, & psw */
359: source = sourceb[index];
360: asm("movw _index,r10");
361: asm("bicpsw $PSWMASK");
362: asm("bispsw _flag_value[r10]");
363: asm("movzbl _source+3,_dest"); /* memory to memory */
364: asm("movpsl _psw"); /*save psw */
365: psw &= FLAGS; /*mask out all bits except flag bits */
366: if (dest != expbl[index])
367: {
368: asm("movl $1,_ercode");
369: if (scoplp) longjmp();
370: error(dest,expbl[index],source,destb[index]);
371: }
372: if (source != sourceb[index])
373: {
374: asm("movl $3,_ercode");
375: if (scoplp) longjmp();
376: error(source,sourceb[index],source,destb[index]);
377: }
378: if (psw != exp_psw[index])
379: {
380: asm("movl $2,_ercode");
381: if (scoplp) longjmp();
382: error(psw,exp_psw[index],source,destb[index]);
383: }
384: if (force_lp) longjmp();
385: else
386: return(0); /*no error exit*/
387: }
388: }
389:
390:
391:
392: static t_movzbl1()
393: {
394: for (;;)
395: {
396: /*initialize source, & psw */
397: setjmp();
398: asm("m7: movab m7,_stpc");
399: asm("movl $7,_subtst");
400: source = sourceb[index];
401: asm("movw _index,r10");
402: asm("movl _source,r5"); /* load source register */
403: asm("bicpsw $PSWMASK");
404: asm("bispsw _flag_value[r10]");
405: /*execute movz instruction */
406: asm("movzbl _source+3,_source"); /* register to memory */
407: asm("movpsl _psw"); /*save psw */
408: psw &= FLAGS; /*mask out all bits except flag bits */
409: if (source != expbl[index])
410: {
411: asm("movl $1,_ercode");
412: if (scoplp) longjmp();
413: error(source,expbl[index],sourceb[index],sourceb[index]);
414: }
415: if (psw != exp_psw[index])
416: {
417: asm("movl $2,_ercode");
418: if (scoplp) longjmp();
419: error(psw,exp_psw[index],sourceb[index],sourceb[index]);
420: }
421: if (force_lp) longjmp();
422: else
423: return(0); /*no error exit*/
424: }
425: }
426:
427:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.