![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to regmask.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / c2|
Return to regmask.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / c2 |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)regmask.c 1.1 86/02/03 Copyr 1985 Sun Micro";
3: #endif
4:
5: /*
6: * Copyright (c) 1985 by Sun Microsystems, Inc.
7: */
8:
9: #include "as.h"
10: #include "c2.h"
11:
12: regmask RegMasks[PCREG+1][LR+1] = {
13: /* d0 */ { {0}, {01}, {03}, {07} },
14: /* d1 */ { {0}, {010}, {030}, {070} },
15: /* d2 */ { {0}, {0100}, {0300}, {0700} },
16: /* d3 */ { {0}, {01000}, {03000}, {07000} },
17: /* d4 */ { {0}, {010000}, {030000}, {070000} },
18: /* d5 */ { {0}, {0100000}, {0300000}, {0700000} },
19: /* d6 */ { {0}, {01000000}, {03000000}, {07000000} },
20: /* d7 */ { {0}, {010000000}, {030000000}, {070000000} },
21: /* a0 */ { {0}, {0100000000}, {0100000000}, {0100000000} },
22: /* a1 */ { {0}, {0200000000}, {0200000000}, {0200000000} },
23: /* a2 */ { {0}, {0400000000}, {0400000000}, {0400000000} },
24: /* a3 */ { {0}, {01000000000}, {01000000000}, {01000000000} },
25: /* a4 */ { {0}, {02000000000}, {02000000000}, {02000000000} },
26: /* a5 */ { {0}, {04000000000}, {04000000000}, {04000000000} },
27: /* a6 */ { {0}, {010000000000}, {010000000000}, {010000000000} },
28: /* a7 */ { {0}, {020000000000}, {020000000000}, {020000000000} },
29: /* f0 */ { {0}, {0,1}, {0,1}, {0,1} },
30: /* f1 */ { {0}, {0,2}, {0,2}, {0,2} },
31: /* f2 */ { {0}, {0,4}, {0,4}, {0,4} },
32: /* f3 */ { {0}, {0,010}, {0,010}, {0,010} },
33: /* f4 */ { {0}, {0,020}, {0,020}, {0,020} },
34: /* f5 */ { {0}, {0,040}, {0,040}, {0,040} },
35: /* f6 */ { {0}, {0,0100}, {0,0100}, {0,0100} },
36: /* f7 */ { {0}, {0,0200}, {0,0200}, {0,0200} },
37: /* cc */ { {0}, {0,0400}, {0,0400}, {0,0400} },
38: /* fcc*/ { {0}, {0,01000}, {0,01000}, {0,01000} },
39: /* pc */ { {0}, {0}, {0}, {0} },
40: };
41:
42: regmask exitmask;
43: regmask regmask0 = {0,0};
44: regmask regmask_all = { -1, 0x3ff };
45: regmask regmask_nontemp = {0xfcffffc0, 0x0fc }; /* all registers except d0/d1, a0,a1, f0,f1 */
46:
47: int
48: inmask( a, b )
49: int a;
50: regmask b;
51: {
52: if (a < A0REG)
53: return( (RegMasks[a][LR].da & b.da)>>(3*a));
54: else if (a< FP0REG)
55: return( (RegMasks[a][LR].da & b.da)>>(a+24-A0REG));
56: else
57: return( (RegMasks[a][LR].f & b.f) >> (a-FP0REG));
58: }
59:
60: regmask
61: addmask( a, b )
62: regmask a, b;
63: {
64: a.da |= b.da;
65: a.f |= b.f;
66: return a;
67: }
68:
69: regmask
70: submask( a, b )
71: regmask a, b;
72: {
73: a.da &= ~b.da;
74: a.f &= ~b.f & 01777;
75: return a;
76: }
77:
78: regmask
79: andmask( a, b )
80: regmask a, b;
81: {
82: a.da &= b.da;
83: a.f &= b.f;
84: return a;
85: }
86:
87: regmask
88: notmask( a )
89: regmask a;
90: {
91: a.da = ~a.da;
92: a.f = ~a.f & 01777;
93: return a;
94: }
95:
96: int
97: emptymask( a )
98: regmask a;
99: {
100: return a.da == 0 && a.f == 0;
101: }
102:
103: int
104: samemask( a, b)
105: regmask a, b;
106: {
107: return ((a.da==b.da) && (a.f==b.f));
108: }
109:
110: regmask
111: movemmask( so, rw, operands )
112: subop_t so;
113: struct oper *operands[];
114: {
115: register short imask, regbit, regno;
116: regmask r;
117: int sl;
118: operand_t t;
119: r = regmask0;
120: switch (so){
121: case SUBOP_W: sl = WR+LW; break; /* movemw */
122: case SUBOP_X:
123: case SUBOP_L: sl = LR+LW; break; /* moveml */
124: }
125: sl &= rw;
126: if (rw==RMASK){
127: /* which registers are read by this operation? */
128: if (operands[0]->type_o != T_IMMED) return regmask0; /* this instruction writes */
129: if (operands[0]->sym_o) return regmask0 ; /* lord knows */
130: imask = operands[0]->value_o;
131: t = operands[1]->type_o;
132: } else {
133: /* which registers are written by this operation */
134: sl >>= RWWIDTH;
135: if (operands[1]->type_o != T_IMMED) return regmask0; /* this instructino reads */
136: if (operands[1]->sym_o) return regmask0 ; /* lord knows */
137: imask = operands[1]->value_o;
138: t = operands[0]->type_o;
139: }
140: if (so == SUBOP_X){
141: for (regbit=(1<<7), regno=FP0REG; regno<=FP0REG+7; regno++, regbit>>=1)
142: if (imask®bit)
143: r = addmask( r, MAKERMASK( regno, sl ));
144: } else if (t == T_PREDEC){
145: for (regbit=(1<<15), regno=0; regno<=15; regno++, regbit>>=1)
146: if (imask®bit)
147: r = addmask( r, MAKERMASK( regno, sl ));
148: } else {
149: for (regbit= 1 , regno=0; regno<=15; regno++, regbit<<=1)
150: if (imask®bit)
151: r = addmask( r, MAKERMASK( regno, sl ));
152: }
153: return r;
154: }
155:
156: void
157: printmask( mask )
158: regmask mask;
159: {
160: register m;
161: register regno;
162: m = mask.da;
163: /* D registers first */
164: for (regno=0; regno<=7; regno ++){
165: if (m&4) printf(" L%d", regno);
166: else if (m&2) printf(" W%d", regno);
167: else if (m&1) printf(" B%d", regno);
168: m >>= 3;
169: }
170: /* now A registers */
171: for (regno=8; regno <= 15; regno++){
172: if (m&1) printf(" A%d", regno-8);
173: m >>= 1;
174: }
175: /* finally F registers and ccs */
176: m = mask.f;
177: for (regno=0; regno <=7; regno++){
178: if (m&1) printf(" F%d", regno);
179: m >>= 1;
180: }
181: if (m&1) printf(" CC");
182: if (m&2) printf(" FCC");
183: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.