![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to trans.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to trans.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: * translation routines; sometimes we pass data on
4:
5: * through directly (asm syntax->asm syntax, with
6:
7: * some macro expansion), and other times we also
8:
9: * do asm syntax->gas syntax translation
10:
11: */
12:
13:
14:
15: #include "asmtrans.h"
16:
17:
18:
19: int syntax = GAS;
20:
21:
22:
23: char *
24:
25: immediate(op)
26:
27: char *op;
28:
29: {
30:
31: return concat("#", op);
32:
33: }
34:
35:
36:
37: char *
38:
39: indirect(op)
40:
41: char *op;
42:
43: {
44:
45: if (syntax == GAS) {
46:
47: return concat(op, "@");
48:
49: } else {
50:
51: return concat3("(", op, ")");
52:
53: }
54:
55: }
56:
57:
58:
59: char *
60:
61: postinc(op)
62:
63: char *op;
64:
65: {
66:
67: if (syntax == GAS) {
68:
69: return concat(op, "@+");
70:
71: } else {
72:
73: return concat3("(", op, ")+");
74:
75: }
76:
77: }
78:
79:
80:
81: char *
82:
83: predec(op)
84:
85: char *op;
86:
87: {
88:
89: if (syntax == GAS) {
90:
91: return concat(op, "@-");
92:
93: } else {
94:
95: return concat3("-(", op, ")");
96:
97: }
98:
99: }
100:
101:
102:
103: char *
104:
105: indexed(op1, op2)
106:
107: char *op1, *op2;
108:
109: {
110:
111: if (syntax == GAS) {
112:
113: return concat4(op2, "@(", op1, ")");
114:
115: } else {
116:
117: return concat4(op1, "(", op2, ")");
118:
119: }
120:
121: }
122:
123:
124:
125: char *
126:
127: sizedop(op, size)
128:
129: char *op, *size;
130:
131: {
132:
133: if (syntax == GAS) {
134:
135: return changesiz(concat(op, size));
136:
137: } else {
138:
139: return concat4("(", op, ")", size);
140:
141: }
142:
143: }
144:
145:
146:
147: char *
148:
149: twoindex(disp, base, index)
150:
151: char *disp, *base, *index;
152:
153: {
154:
155: if (syntax == GAS) {
156:
1.1.1.2 root 157: return concat6(base, "@(", disp, ",", changesiz2(index), ")");
1.1 root 158:
159: } else {
160:
161: return concat6(disp, "(", base, ",", index, ")");
162:
163: }
164:
165: }
166:
167:
168:
169: char *
170:
171: bitfield(op1, op2, op3)
172:
173: char *op1, *op2, *op3;
174:
175: {
176:
177: if (syntax == GAS) {
178:
179: return concat6(op1, "{#", op2, ":#", op3, "}");
180:
181: } else {
182:
183: return concat6(op1, "{", op2, ":", op3, "}");
184:
185: }
186:
187: }
188:
189:
190:
191: char *
192:
1.1.1.2 root 193: postindex(bd, an , index, od)
194:
195: char *bd, *an, *index , *od;
196:
197: {
198:
199: if (syntax == GAS) {
200:
201: return concat8(an, "@(", bd, ")@(", od, ",", changesiz2(index), ")");
202:
203: } else {
204:
205: return concat9("([",an, ",", bd, "],", index, ",", od ,")");
206:
207: }
208:
209: }
210:
211:
212:
213: char *
214:
215: postindex0(bd)
216:
217: char *bd;
218:
219: {
220:
221: if (syntax == GAS) {
222:
1.1.1.3 ! root 223: return concat3("@(", bd, ")@()");
1.1.1.2 root 224:
225: } else {
226:
227: return concat3("([", bd, "])");
228:
229: }
230:
231: }
232:
233:
234:
235: char *
236:
237: postindex1(bd,od)
238:
239: char *bd, *od;
240:
241: {
242:
243: if (syntax == GAS) {
244:
245: return concat5("@(", bd, ")@(", od, ")");
246:
247: } else {
248:
249: return concat5("([", bd, "],", od, ")");
250:
251: }
252:
253: }
254:
255:
256:
257: char *
258:
259: preindex(bd, an , index, od)
260:
261: char *bd, *an, *index , *od;
262:
263: {
264:
265: if (syntax == GAS) {
266:
267: return concat8(an, "@(", bd, ",", changesiz2(index), ")@(", od, ")");
268:
269: } else {
270:
271: return concat9("([",an, ",", bd, ",", index, "],", od, ")");
272:
273: }
274:
275: }
276:
277:
278:
279: char *
280:
1.1 root 281: do_ops(label, opcode, space, operand)
282:
283: char *label, *opcode, *space, *operand;
284:
285: {
286:
287: static char temp[LINSIZ];
288:
289: static char optemp[40];
290:
291: char *to, *from;
292:
293: char c;
294:
295:
296:
297: if (syntax == GAS) {
298:
299: if (!strcmp(opcode, "ds.l")) {
300:
301: strcpy(temp, "\t.even\n\t.comm");
302:
303: strcat(temp, space);
304:
305: strcat(temp, label);
306:
307: strcat(temp, ",");
308:
309: strcat(temp, "4*");
310:
311: strcat(temp, operand);
312:
313: return strdup(temp);
314:
315: } else if (!strcmp(opcode, "ds.w")) {
316:
317: strcpy(temp, "\t.even\n\t.comm");
318:
319: strcat(temp, space);
320:
321: strcat(temp, label);
322:
323: strcat(temp, ",");
324:
325: strcat(temp, "2*");
326:
327: strcat(temp, operand);
328:
329: return strdup(temp);
330:
331: } else if (!strcmp(opcode, "ds.b")) {
332:
333: strcpy(temp, "\t.comm");
334:
335: strcat(temp, space);
336:
337: strcat(temp, label);
338:
339: strcat(temp, ",");
340:
341: strcat(temp, operand);
342:
343: return strdup(temp);
344:
345: } else {
346:
347: to = optemp;
348:
349: from = opcode;
350:
351: for(;;) {
352:
353: c = *from++;
354:
355: if (!c) break;
356:
357: /* change 'foo.b' -> 'foob' */
358:
359: /* special case: bra.s -> 'bra', since gas automatically
360:
361: * selects offset sizes and since some gas's actually
362:
363: * mess up if an explicit '.s' is given
364:
365: */
366:
367: if (c == '.' && *from && from[1] == 0) {
368:
369: if (*from == 's') from++;
370:
371: continue;
372:
373: }
374:
375: *to++ = c;
376:
377: }
378:
379: *to = 0;
380:
381: opcode = optemp;
382:
383: }
384:
385: }
386:
387:
388:
389: to = temp;
390:
391:
392:
393: if (*label) {
394:
395: int colonseen = 0;
396:
397: char c;
398:
399:
400:
401: for (from = label; (c = *from++) != 0;) {
402:
403: if (c == ':') colonseen = 1;
404:
405: *to++ = c;
406:
407: }
408:
409: /* gas labels must have a ':' after them */
410:
411: if (!colonseen && syntax == GAS)
412:
413: *to++ = ':';
414:
415: }
416:
417:
418:
419: *to++ = '\t';
420:
421: strcpy(to, opcode);
422:
423: strcat(temp, space);
424:
425: strcat(temp, operand);
426:
427: return strdup(temp);
428:
429: }
430:
431:
432:
433: char *
434:
435: changesiz(op)
436:
437: char *op;
438:
439: {
440:
441: char *r = op;
442:
443:
444:
445: if (syntax != GAS) return op;
446:
447:
448:
449: while (*op) {
450:
451: if (*op == '.') *op = ':';
452:
453: op++;
454:
455: }
456:
457: return r;
458:
459: }
460:
461:
462:
463: char *
464:
1.1.1.2 root 465: changesiz2(op) /* rw: hack for scaled index */
466:
467: char *op;
468:
469: {
470:
471: char *r = op;
472:
473:
474:
475: if (syntax != GAS) return op;
476:
477:
478:
479: while (*op) {
480:
481: if (*op == '.' || *op == '*' ) *op = ':';
482:
483: op++;
484:
485: }
486:
487: return r;
488:
489: }
490:
491:
492:
493: char *
494:
1.1 root 495: hexop(op)
496:
497: char *op;
498:
499: {
500:
501: if (syntax == GAS)
502:
503: return concat("0x", op);
504:
505: else
506:
507: return concat("$", op);
508:
509: }
510:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.