![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c22.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / c2|
Return to c22.c CVS log | Up to [Research Unix] / researchv10no / cmd / c2 |
1.1 root 1: static char sccsid[] = "@(#)c22.c 4.1 10/16/80";
2: #include "c2.h"
3: /* char c22[] = "@(#)c22.c 1.10 80/03/14 10:27:37"; */
4: #define readonly
5:
6: readonly char revbr[] = {
7: JNE, JEQ, JGT, JLT, JGE, JLE,
8: JNE, JEQ, JHI, JLO, JHIS, JLOS,
9: JBS, JBC, JLBS, JLBC, JBSC, JBCC, JBSS, JBCS };
10:
11: /* cursed be the preprocessor, whose impotence and stupidity
12: /* prevented this table being macro-generated from ../as/instrs
13: */
14: readonly struct optab optab[] = {
15: {"jbr",JBR},
16: {"jeql",T(CBR,JEQ)},
17: {"jneq",T(CBR,JNE)},
18: {"jleq",T(CBR,JLE)},
19: {"jgeq",T(CBR,JGE)},
20: {"jlss",T(CBR,JLT)},
21: {"jgtr",T(CBR,JGT)},
22: {"jbc",T(CBR,JBC)},
23: {"jbs",T(CBR,JBS)},
24: {"jlequ",T(CBR,JLOS)},
25: {"jgequ",T(CBR,JHIS)},
26: {"jlssu",T(CBR,JLO)},
27: {"jgtru",T(CBR,JHI)},
28: {"jlbc",T(CBR,JLBC)},
29: {"jlbs",T(CBR,JLBS)},
30: {"jbcc",T(CBR,JBCC)},
31: {"jbsc",T(CBR,JBSC)},
32: {"jbcs",T(CBR,JBCS)},
33: {"jbss",T(CBR,JBSS)},
34: {"acbb",T(ACB,BYTE)},
35: {"acbd",T(ACB,DOUBLE)},
36: {"acbf",T(ACB,FLOAT)},
37: {"acbl",T(ACB,LONG)},
38: {"acbw",T(ACB,WORD)},
39: {"addb2",T(ADD,U(BYTE,OP2))},
40: {"addb3",T(ADD,U(BYTE,OP3))},
41: {"addd2",T(ADD,U(DOUBLE,OP2))},
42: {"addd3",T(ADD,U(DOUBLE,OP3))},
43: {"addf2",T(ADD,U(FLOAT,OP2))},
44: {"addf3",T(ADD,U(FLOAT,OP3))},
45: {"addl2",T(ADD,U(LONG,OP2))},
46: {"addl3",T(ADD,U(LONG,OP3))},
47: {"addw2",T(ADD,U(WORD,OP2))},
48: {"addw3",T(ADD,U(WORD,OP3))},
49: {"aobleq",AOBLEQ},
50: {"aoblss",AOBLSS},
51: {"ashl",T(ASH,LONG)},
52: {"ashq",T(ASH,QUAD)},
53: {"bbc",T(CBR,JBC)},
54: {"bbcc",T(CBR,JBCC)},
55: {"bbcci",T(CBR,JBCC)},
56: {"bbcs",T(CBR,JBCS)},
57: {"bbs",T(CBR,JBS)},
58: {"bbsc",T(CBR,JBSC)},
59: {"bbss",T(CBR,JBSS)},
60: {"bbssi",T(CBR,JBSS)},
61: {"bcc",T(CBR,JHIS)},
62: {"bcs",T(CBR,JLO)},
63: {"beql",T(CBR,JEQ)},
64: {"beqlu",T(CBR,JEQ)},
65: {"bgeq",T(CBR,JGE)},
66: {"bgequ",T(CBR,JHIS)},
67: {"bgtr",T(CBR,JGT)},
68: {"bgtru",T(CBR,JHI)},
69: {"bicb2",T(BIC,U(BYTE,OP2))},
70: {"bicb3",T(BIC,U(BYTE,OP3))},
71: {"bicl2",T(BIC,U(LONG,OP2))},
72: {"bicl3",T(BIC,U(LONG,OP3))},
73: {"bicw2",T(BIC,U(WORD,OP2))},
74: {"bicw3",T(BIC,U(WORD,OP3))},
75: {"bisb2",T(BIS,U(BYTE,OP2))},
76: {"bisb3",T(BIS,U(BYTE,OP3))},
77: {"bisl2",T(BIS,U(LONG,OP2))},
78: {"bisl3",T(BIS,U(LONG,OP3))},
79: {"bisw2",T(BIS,U(WORD,OP2))},
80: {"bisw3",T(BIS,U(WORD,OP3))},
81: {"bitb",T(BIT,BYTE)},
82: {"bitl",T(BIT,LONG)},
83: {"bitw",T(BIT,WORD)},
84: {"blbs",T(CBR,JLBS)},
85: {"blbc",T(CBR,JLBC)},
86: {"bleq",T(CBR,JLE)},
87: {"blequ",T(CBR,JLOS)},
88: {"blss",T(CBR,JLT)},
89: {"blssu",T(CBR,JLO)},
90: {"bneq",T(CBR,JNE)},
91: {"bnequ",T(CBR,JNE)},
92: {"brb",JBR},
93: {"brw",JBR},
94: {"bvc",T(CBR,0)},
95: {"bvs",T(CBR,0)},
96: {"callg",CALLS},
97: {"calls",CALLS},
98: {"caseb",T(CASE,BYTE)},
99: {"casel",T(CASE,LONG)},
100: {"casew",T(CASE,WORD)},
101: {"clrb",T(CLR,BYTE)},
102: {"clrd",T(CLR,DOUBLE)},
103: {"clrf",T(CLR,FLOAT)},
104: {"clrl",T(CLR,LONG)},
105: {"clrq",T(CLR,QUAD)},
106: {"clrw",T(CLR,WORD)},
107: {"cmpb",T(CMP,BYTE)},
108: {"cmpd",T(CMP,DOUBLE)},
109: {"cmpf",T(CMP,FLOAT)},
110: {"cmpl",T(CMP,LONG)},
111: {"cmpw",T(CMP,WORD)},
112: {"cvtbd",T(CVT,U(BYTE,DOUBLE))},
113: {"cvtbf",T(CVT,U(BYTE,FLOAT))},
114: {"cvtbl",T(CVT,U(BYTE,LONG))},
115: {"cvtbw",T(CVT,U(BYTE,WORD))},
116: {"cvtdb",T(CVT,U(DOUBLE,BYTE))},
117: {"cvtdf",T(CVT,U(DOUBLE,FLOAT))},
118: {"cvtdl",T(CVT,U(DOUBLE,LONG))},
119: {"cvtdw",T(CVT,U(DOUBLE,WORD))},
120: {"cvtfb",T(CVT,U(FLOAT,BYTE))},
121: {"cvtfd",T(CVT,U(FLOAT,DOUBLE))},
122: {"cvtfl",T(CVT,U(FLOAT,LONG))},
123: {"cvtfw",T(CVT,U(FLOAT,WORD))},
124: {"cvtlb",T(CVT,U(LONG,BYTE))},
125: {"cvtld",T(CVT,U(LONG,DOUBLE))},
126: {"cvtlf",T(CVT,U(LONG,FLOAT))},
127: {"cvtlw",T(CVT,U(LONG,WORD))},
128: {"cvtrdl",T(CVT,U(DOUBLE,LONG))},
129: {"cvtrfl",T(CVT,U(FLOAT,LONG))},
130: {"cvtwb",T(CVT,U(WORD,BYTE))},
131: {"cvtwd",T(CVT,U(WORD,DOUBLE))},
132: {"cvtwf",T(CVT,U(WORD,FLOAT))},
133: {"cvtwl",T(CVT,U(WORD,LONG))},
134: {"decb",T(DEC,BYTE)},
135: {"decl",T(DEC,LONG)},
136: {"decw",T(DEC,WORD)},
137: {"divb2",T(DIV,U(BYTE,OP2))},
138: {"divb3",T(DIV,U(BYTE,OP3))},
139: {"divd2",T(DIV,U(DOUBLE,OP2))},
140: {"divd3",T(DIV,U(DOUBLE,OP3))},
141: {"divf2",T(DIV,U(FLOAT,OP2))},
142: {"divf3",T(DIV,U(FLOAT,OP3))},
143: {"divl2",T(DIV,U(LONG,OP2))},
144: {"divl3",T(DIV,U(LONG,OP3))},
145: {"divw2",T(DIV,U(WORD,OP2))},
146: {"divw3",T(DIV,U(WORD,OP3))},
147: {"extv",T(EXTV,LONG)},
148: {"extzv",T(EXTZV,LONG)},
149: {"incb",T(INC,BYTE)},
150: {"incl",T(INC,LONG)},
151: {"incw",T(INC,WORD)},
152: {"insv",T(INSV,-1)},
153: {"jmp",JMP},
154: {"mcomb",T(COM,BYTE)},
155: {"mcoml",T(COM,LONG)},
156: {"mcomw",T(COM,WORD)},
157: {"mnegb",T(NEG,BYTE)},
158: {"mnegd",T(NEG,DOUBLE)},
159: {"mnegf",T(NEG,FLOAT)},
160: {"mnegl",T(NEG,LONG)},
161: {"mnegw",T(NEG,WORD)},
162: {"movab",T(MOVA,BYTE)},
163: {"movad",T(MOVA,DOUBLE)},
164: {"movaf",T(MOVA,FLOAT)},
165: {"moval",T(MOVA,LONG)},
166: {"movaq",T(MOVA,QUAD)},
167: {"movaw",T(MOVA,WORD)},
168: {"movb",T(MOV,BYTE)},
169: {"movd",T(MOV,DOUBLE)},
170: {"movf",T(MOV,FLOAT)},
171: {"movl",T(MOV,LONG)},
172: {"movq",T(MOV,QUAD)},
173: {"movw",T(MOV,WORD)},
174: {"movzbl",T(MOVZ,U(BYTE,LONG))},
175: {"movzbw",T(MOVZ,U(BYTE,WORD))},
176: {"movzwl",T(MOVZ,U(WORD,LONG))},
177: {"mulb2",T(MUL,U(BYTE,OP2))},
178: {"mulb3",T(MUL,U(BYTE,OP3))},
179: {"muld2",T(MUL,U(DOUBLE,OP2))},
180: {"muld3",T(MUL,U(DOUBLE,OP3))},
181: {"mulf2",T(MUL,U(FLOAT,OP2))},
182: {"mulf3",T(MUL,U(FLOAT,OP3))},
183: {"mull2",T(MUL,U(LONG,OP2))},
184: {"mull3",T(MUL,U(LONG,OP3))},
185: {"mulw2",T(MUL,U(WORD,OP2))},
186: {"mulw3",T(MUL,U(WORD,OP3))},
187: {"pushab",T(PUSHA,BYTE)},
188: {"pushad",T(PUSHA,DOUBLE)},
189: {"pushaf",T(PUSHA,FLOAT)},
190: {"pushal",T(PUSHA,LONG)},
191: {"pushaq",T(PUSHA,QUAD)},
192: {"pushaw",T(PUSHA,WORD)},
193: {"pushl",T(PUSH,LONG)},
194: {"ret",T(JBR,RET)},
195: {"sobgeq",SOBGEQ},
196: {"sobgtr",SOBGTR},
197: {"subb2",T(SUB,U(BYTE,OP2))},
198: {"subb3",T(SUB,U(BYTE,OP3))},
199: {"subd2",T(SUB,U(DOUBLE,OP2))},
200: {"subd3",T(SUB,U(DOUBLE,OP3))},
201: {"subf2",T(SUB,U(FLOAT,OP2))},
202: {"subf3",T(SUB,U(FLOAT,OP3))},
203: {"subl2",T(SUB,U(LONG,OP2))},
204: {"subl3",T(SUB,U(LONG,OP3))},
205: {"subw2",T(SUB,U(WORD,OP2))},
206: {"subw3",T(SUB,U(WORD,OP3))},
207: {"tstb",T(TST,BYTE)},
208: {"tstd",T(TST,DOUBLE)},
209: {"tstf",T(TST,FLOAT)},
210: {"tstl",T(TST,LONG)},
211: {"tstw",T(TST,WORD)},
212: {"xorb2",T(XOR,U(BYTE,OP2))},
213: {"xorb3",T(XOR,U(BYTE,OP3))},
214: {"xorl2",T(XOR,U(LONG,OP2))},
215: {"xorl3",T(XOR,U(LONG,OP3))},
216: {"xorw2",T(XOR,U(WORD,OP2))},
217: {"xorw3",T(XOR,U(WORD,OP3))},
218: {"movc3",T(CHRINS,U(3,5))}, /* number of operands, highest register smashed */
219: {".globl",EROU},
220: {".text",TEXT},
221: {".data",DATA},
222: {".bss",BSS},
223: {".align",ALIGN},
224: {".word",WGEN},
225: {".long",LGEN},
226: {".set",SET},
227: {".lcomm",LCOMM},
228: {".comm",COMM},
229: {".end",END},
230: {"rsb",T(JBR,RSB)},
231: {"jsb",JSB},
232: {"mfpr",T(MFPR,LONG)},
233: {"mtpr",T(MTPR,LONG)},
234: {"prober",T(PROBER,BYTE)},
235: {"probew",T(PROBEW,BYTE)},
236: {"adawi",0},
237: {"addp4",0},
238: {"addp6",0},
239: {"adwc",0},
240: {"ashp",0},
241: {"bicpsw",0},
242: {"bispsw",0},
243: {"bpt",0},
244: {"bsbb",0},
245: {"bsbw",0},
246: {"chme",0},
247: {"chmk",0},
248: {"chms",0},
249: {"chmu",0},
250: {"cmpc3",T(CHRINS, U(3,3))},
251: {"cmpc5",T(CHRINS, U(5,3))},
252: {"cmpp3",0},
253: {"cmpp4",0},
254: {"cmpv",0},
255: {"cmpzv",0},
256: {"crc",T(CHRINS, U(4,3))}, /* hack */
257: {"cvtlp",0},
258: {"cvtpl",0},
259: {"cvttp",0},
260: {"cvtpt",0},
261: {"cvtps",0},
262: {"cvtsp",0},
263: {"divp",0},
264: {"editpc",0},
265: {"ediv",0},
266: {"emodd",0},
267: {"emodf",0},
268: {"emul",0},
269: {"ffc",0},
270: {"ffs",0},
271: {"halt",0},
272: {"index",0},
273: {"insque",0},
274: {"ldpctx",0},
275: {"locc",T(CHRINS, U(3,1))},
276: {"matchc",T(CHRINS, U(4,3))},
277: {"movc5",T(CHRINS, U(5,5))},
278: {"movp",0},
279: {"movpsl",0},
280: {"movtc",T(CHRINS, U(6,5))},
281: {"movtuc",T(CHRINS, U(6,5))},
282: {"mulp",0},
283: {"nop",0},
284: {"polyd",0},
285: {"polyf",0},
286: {"popr",0},
287: {"pushr",0},
288: {"rei",0},
289: {"remque",0},
290: {"rotl",0},
291: {"sbwc",0},
292: {"scanc",T(CHRINS, U(4,3))},
293: {"skpc",T(CHRINS, U(3,1))},
294: {"spanc",T(CHRINS, U(4,3))},
295: {"subp4",0},
296: {"subp6",0},
297: {"svpctx",0},
298: {"xfc",0},
299: {"escd",0},
300: {"esce",0},
301: {"escf",0},
302: { 0, 0}
303: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.