![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mcom.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 mcom.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry |
1.1 root 1:
2: /* standard definition file */
3: /* for 'C' diagnostic porgrams. */
4: /* */
5: /* */
6: #define HIGH 31
7: #define IPL 18
8: #define PSWMASK 255
9: #define T 16
10: #define IV 32
11: #define FU 64
12: #define DV 128
13: #define FLAGS 0x0000000f
14:
15: extern long scoplp;
16: extern long force_lp;
17:
18: asm(".set PSWMASK,0xf");
19:
20: /* constants definition for mcomplemented instructions test */
21: /* */
22: /* */
23:
24: #define MCOMB 0x29 /*opcodes */
25: #define MCOMW 0x2b
26: #define MCOML 0x2d
27:
28: #define MAX_PATTERNS 4 /*max test patterns */
29:
30: #define IDEST 0x11111111/*initialization */
31: /*for destination */
32:
33: #define S1 0 /*source values */
34: #define S2 0x55555555
35: #define S3 0xaaaaaaaa
36: #define S4 -1
37:
38: #define EB1 0x111111ff/*expected data*/
39: #define EW1 0x1111ffff
40: #define EL1 0xffffffff
41: #define EB2 0x111111aa
42: #define EW2 0x1111aaaa
43: #define EL2 0xaaaaaaaa
44: #define EB3 0x11111155
45: #define EW3 0x11115555
46: #define EL3 0x55555555
47: #define EB4 0x11111100
48: #define EW4 0x11110000
49: #define EL4 0
50:
51: #define EB11 0x000000ff
52: #define EW11 0x0000ffff
53: #define EL11 0xffffffff
54: #define EB22 0x555555aa
55: #define EW22 0x5555aaaa
56: #define EL22 0xaaaaaaaa
57: #define EB33 0xaaaaaa55
58: #define EW33 0xaaaa5555
59: #define EL33 0x55555555
60: #define EB44 0xffffff00
61: #define EW44 0xffff0000
62: #define EL44 0
63:
64:
65: #define FLG1 6 /*initial flag val*/
66: #define FLG2 6
67: #define FLG3 15
68: #define FLG4 11
69:
70:
71: #define EFLG1 9 /*expected flag val*/
72: #define EFLG2 9
73: #define EFLG3 1
74: #define EFLG4 5
75:
76: #define ERROR1 1 /*error definitions */
77: #define ERROR2 2
78: #define ERROR3 3
79: #define ERROR4 4
80: #define ERROR5 5
81: /*error messages */
82: #define EM1 "destination not equal to expected \n"
83: #define EM2 "source altered by the instruction \n"
84: #define EM3 "flags not equal to expected \n"
85:
86:
87:
88: /* Global variables for mcom test */
89: /* */
90: /* */
91:
92: static short index = 0;
93: static long dest = 0; /*destination location */
94: static long source = 0; /*source location */
95: static long psw; /*processor status word */
96:
97: static short flag_value[MAX_PATTERNS] = {FLG1,FLG2,FLG3,FLG4};
98: /*flag values for initialization */
99:
100: static long error_count = 0;
101:
102:
103: static long expb[MAX_PATTERNS] = {EB1,EB2,EB3,EB4};
104: /*expected values */
105:
106: static long expb1[MAX_PATTERNS] = {EB11,EB22,EB33,EB44};
107:
108: static long expw[MAX_PATTERNS] = {EW1,EW2,EW3,EW4};
109: static long expw1[MAX_PATTERNS] = {EW11,EW22,EW33,EW44};
110:
111: static long expl[MAX_PATTERNS] = {EL1,EL2,EL3,EL4};
112: static long expl1[MAX_PATTERNS] = {EL11,EL22,EL33,EL44};
113:
114: static short exp_psw[MAX_PATTERNS] = {EFLG1,EFLG2,EFLG3,EFLG4};
115: /*expected psw */
116:
117: static long src[MAX_PATTERNS] = {S1,S2,S3,S4};
118: /*source values */
119:
120:
121: static char *title;
122: static char *msg;
123: static long op1, op2, *lptr, exp_dest;
124: static short init_flg;
125:
126: mcom()
127: {
128: asm("movl $2,_no_opr"); /* two operands in use */
129: title = "** MCOM_L **\n";
130: mcoml();
131: title = "** MCOM_W **\n";
132: mcomw();
133: title = "** MCOM_B **\n";
134: mcomb();
135: asm("jmp *return");
136: }
137:
138:
139: static mcoml()
140: {
141: for (index = 0; index < MAX_PATTERNS; index++)
142: {
143: t_mcoml ();
144: t_mcoml1(); /*one more test where */
145: /* dest address = source address */
146: }
147: }
148:
149:
150: static t_mcoml()
151: {
152:
153: for (;;)
154: {
155: setjmp();
156: asm("mc1: movab mc1,_stpc");
157: op2 = dest = IDEST; /* Init destination, source, & psw */
158: lptr = src + index;
159: op1 = source = *lptr; /* do not use index */
160: init_flg = (short)flag_value[index];
161:
162: asm("movl $0x1,_subtst");
163: asm("bicpsw $PSWMASK");
164: asm("bispsw _init_flg");
165: asm("mcoml _source,_dest");
166: asm("movpsl _psw"); /*save psw */
167: psw &= FLAGS; /*mask out all bits except flag bits */
168: lptr = expl + index;
169: exp_dest = *lptr;
170: if (dest != exp_dest)
171: {
172: asm("movl $1,_ercode"); /* error data miscompare */
173: if (scoplp) longjmp();
174: error(dest,exp_dest,op1,op2);
175: }
176: if (source != op1)
177: {
178: asm("movl $3,_ercode"); /* error operand miscompare */
179: if (scoplp) longjmp();
180: error(source,op1,op1,op2);
181: }
182: if (psw != exp_psw[index])
183: {
184: asm("movl $2,_ercode"); /* error flag miscompare */
185: if (scoplp) longjmp();
186: error(psw,exp_psw[index],op1,op2);
187: }
188: else
189: if (force_lp) longjmp();
190: return(0);
191: }
192: }
193:
194:
195: static t_mcoml1()
196: {
197: for (;;)
198: {
199: setjmp();
200: asm("mc2: movab mc2,_stpc");
201: /*initialize source, & psw */
202: lptr = src + index;
203: op1 = source = *lptr; /* do not use index */
204: init_flg = (short)flag_value[index];
205:
206: if (index==0) {
207: asm("movl $0x2,_subtst");
208: asm("bicpsw $PSWMASK")
209: asm("bispsw _init_flg")
210: asm("mcoml _source,_source") /* memory to memory */
211: asm("movpsl _psw") /*save psw */
212: }
213: if (index==1) {
214: asm("movl $0x3,_subtst");
215: asm("bicpsw $PSWMASK")
216: asm("movl _source,r7") /* load register */
217: asm("bispsw _init_flg")
218: asm("mcoml _source,r7") /* memory to register */
219: asm("movl r7,_source") /* reload target address */
220: asm("movpsl _psw") /*save psw */
221: }
222: if (index==2) {
223: asm("movl $0x4,_subtst");
224: asm("bicpsw $PSWMASK")
225: asm("movl _source,r6") /* load register */
226: asm("bispsw _init_flg")
227: asm("mcoml r6,_source") /* register to memory */
228: asm("movpsl _psw") /*save psw */
229: }
230: if (index==3) {
231: asm("movl $0x5,_subtst");
232: asm("bicpsw $PSWMASK")
233: asm("movl _source,r6") /* load register */
234: asm("movl _source,r7") /* load register */
235: asm("bispsw _init_flg")
236: asm("mcoml r6,r7") /* register to register */
237: asm("movl r7,_source") /* reload target address */
238: asm("movpsl _psw") /*save psw */
239: }
240: psw &= FLAGS; /*mask out all bits except flag bits */
241: lptr = expl1 + index;
242: exp_dest = *lptr;
243: if (source != exp_dest)
244: {
245: asm("movl $1,_ercode"); /* error data miscompare */
246: if (scoplp) longjmp();
247: error(source,exp_dest,op1,op1);
248: }
249: if (psw != exp_psw[index])
250: {
251: asm("movl $2,_ercode"); /* error flag miscompare */
252: if (scoplp) longjmp();
253: error(psw,exp_psw[index],op1,op1);
254: }
255: else
256: if (force_lp) longjmp();
257: return(0);
258: }
259: }
260:
261:
262:
263: static mcomw()
264: {
265: for (index = 0; index < MAX_PATTERNS; index++)
266: {
267: t_mcomw();
268: t_mcomw1(); /*one more test where */
269: /* dest address = source address */
270: }
271: }
272:
273: static t_mcomw()
274: {
275:
276: for (;;)
277: {
278: setjmp();
279: asm("mc3: movab mc3,_stpc");
280: op2 = dest = IDEST; /* Init destination, source, & psw */
281: lptr = src + index;
282: op1 = source = *lptr; /* do not use index */
283: init_flg = (short)flag_value[index];
284:
285: if (index==0) {
286: asm("movl $0x6,_subtst");
287: asm("bicpsw $PSWMASK")
288: asm("bispsw _init_flg")
289: asm("mcomw _source+2,_dest+2") /* memory to memory */
290: asm("movpsl _psw") /*save psw */
291: }
292: if (index==1) {
293: asm("movl $0x7,_subtst");
294: asm("bicpsw $PSWMASK")
295: asm("movl _source,r6") /* load register */
296: asm("movl _dest,r7") /* load register */
297: asm("bispsw _init_flg")
298: asm("mcomw r6,r7") /* register to register */
299: asm("movpsl _psw") /*save psw */
300: asm("movw r7,_dest+2") /* reload memory location for check */
301: }
302: if (index==2) {
303: asm("movl $0x8,_subtst");
304: asm("bicpsw $PSWMASK")
305: asm("movl _source,r6") /* load register */
306: asm("bispsw _init_flg")
307: asm("mcomw r6,_dest+2") /* register to memory */
308: asm("movpsl _psw") /*save psw */
309: }
310: if (index==3) {
311: asm("movl $0x9,_subtst");
312: asm("bicpsw $PSWMASK")
313: asm("movl _dest,r7") /* load register */
314: asm("bispsw _init_flg")
315: asm("mcomw _source+2,r7") /* memory to register */
316: asm("movw r7,_dest+2") /* reload compare location */
317: asm("movpsl _psw") /*save psw */
318: }
319: psw &= FLAGS; /*mask out all bits except flag bits */
320: lptr = expw + index;
321: exp_dest = *lptr;
322: if (dest != exp_dest)
323: {
324: asm("movl $1,_ercode"); /* error data miscompare */
325: if (scoplp) longjmp();
326: error(dest,exp_dest,op1,op2);
327: }
328: if (source != op1)
329: {
330: asm("movl $3,_ercode"); /* error operand miscompare */
331: if (scoplp) longjmp();
332: error(source,op1,op1,op2);
333: }
334: if (psw != exp_psw[index])
335: {
336: asm("movl $2,_ercode"); /* error flag miscompare */
337: if (scoplp) longjmp();
338: error(psw,exp_psw[index],op1,op2);
339: }
340: else
341: if (force_lp) longjmp();
342: return(0);
343: }
344: }
345:
346: static t_mcomw1()
347: {
348: for ( ; ; )
349: {
350: /*initialize source, & psw */
351: setjmp();
352: asm("mc4: movab mc4,_stpc");
353: lptr = src + index;
354: op1 = source = *lptr; /* do not use index */
355: init_flg = (short)flag_value[index];
356: asm("movl $0xa,_subtst");
357: asm("bicpsw $PSWMASK")
358: asm("bispsw _init_flg")
359: asm("mcomw _source+2,_source+2")
360: asm("movpsl _psw") /*save psw */
361: psw &= FLAGS; /*mask out all bits except flag bits */
362: lptr = expw1 + index;
363: exp_dest = *lptr;
364: if (source != exp_dest)
365: {
366: asm("movl $1,_ercode"); /* error data miscompare */
367: if (scoplp) longjmp();
368: error(source,exp_dest,op1,op1);
369: }
370: if (psw != exp_psw[index])
371: {
372: asm("movl $2,_ercode"); /* error flag miscompare */
373: if (scoplp) longjmp();
374: error(psw,exp_psw[index],op1,op1);
375: }
376: else
377: if (force_lp) longjmp();
378: return(0);
379: }
380: }
381:
382:
383: static mcomb()
384: {
385: for (index = 0; index < MAX_PATTERNS; index++)
386: {
387: t_mcomb();
388: t_mcomb1(); /*one more test where */
389: /* dest address = source address */
390: }
391: }
392:
393: static t_mcomb()
394: {
395: for ( ; ; )
396: {
397: setjmp();
398: asm("mc5: movab mc5,_stpc");
399: op2 = dest = IDEST; /* Init destination, source, & psw */
400: lptr = src + index;
401: op1 = source = *lptr; /* do not use index */
402: init_flg = (short)flag_value[index];
403:
404: if (index==0) {
405: asm("movl $0xb,_subtst")
406: asm("bicpsw $PSWMASK")
407: asm("bispsw _init_flg")
408: asm("mcomb _source+3,_dest+3") /* memory to memory */
409: asm("movpsl _psw") /*save psw */
410: }
411: if (index==1) {
412: asm("movl $0xc,_subtst")
413: asm("bicpsw $PSWMASK")
414: asm("bispsw _init_flg")
415: asm("movl _source,r6") /* load data into reg */
416: asm("mcomb r6,_dest+3") /* register to memory */
417: asm("movpsl _psw") /*save psw */
418: }
419: if (index==2) {
420: asm("movl $0xd,_subtst")
421: asm("bicpsw $PSWMASK")
422: asm("bispsw _init_flg")
423: asm("movl _dest,r7") /* load dest register */
424: asm("mcomb _source+3,r7") /* memory to register */
425: asm("movpsl _psw") /*save psw */
426: asm("movb r7,_dest+3") /* reload memory */
427: }
428: if (index==3) {
429: asm("movl $0xe,_subtst")
430: asm("bicpsw $PSWMASK")
431: asm("movl _source,r6") /* load data into reg */
432: asm("movl _dest,r7") /* load dest register */
433: asm("bispsw _init_flg")
434: asm("mcomb r6,r7") /* register to register */
435: asm("movpsl _psw") /*save psw */
436: asm("movb r7,_dest+3") /* reload memory */
437: }
438: psw &= FLAGS; /*mask out all bits except flag bits */
439: lptr = expb + index;
440: exp_dest = *lptr;
441: if (dest != exp_dest)
442: {
443: asm("movl $1,_ercode"); /* error data miscompare */
444: if (scoplp) longjmp();
445: error(dest,exp_dest,op1,op2);
446: }
447: if (source != op1)
448: {
449: asm("movl $3,_ercode"); /* error operand miscompare */
450: if (scoplp) longjmp();
451: error(source,op1,op1,op2);
452: }
453: if (psw != exp_psw[index])
454: {
455: asm("movl $2,_ercode"); /* error flag miscompare */
456: if (scoplp) longjmp();
457: error(psw,exp_psw[index],op1,op2);
458: }
459: else
460: if (force_lp) longjmp();
461: return(0);
462: }
463: }
464:
465:
466:
467: static t_mcomb1()
468: {
469: for (;;)
470: {
471: setjmp();
472: asm("mc6: movab mc6,_stpc");
473: /*initialize source, & psw */
474: lptr = src + index;
475: op1 = source = *lptr; /* do not use index */
476: init_flg = (short)flag_value[index];
477: asm("movl $0xf,_subtst")
478: asm("bicpsw $PSWMASK")
479: asm("bispsw _init_flg")
480: asm("mcomb _source+3,_source+3")
481: asm("movpsl _psw") /*save psw */
482: psw &= FLAGS; /*mask out all bits except flag bits */
483: lptr = expb1 + index;
484: exp_dest = *lptr;
485: if (source != exp_dest)
486: {
487: asm("movl $1,_ercode"); /* error data miscompare */
488: if (scoplp) longjmp();
489: error(source,exp_dest,op1,op1);
490: }
491: if (psw != exp_psw[index])
492: {
493: asm("movl $2,_ercode"); /* error flag miscompare */
494: if (scoplp) longjmp();
495: error(psw,exp_psw[index],op1,op1);
496: }
497: else
498: if (force_lp) longjmp();
499: return(0);
500: }
501: }
502:
503:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.