![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bc-optab.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to bc-optab.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Bytecode conversion definitions for GNU C-compiler.
2: Copyright (C) 1993 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: #include "config.h"
22: #include "tree.h"
23: #include "rtl.h"
24: #include "machmode.h"
25: #include "obstack.h"
26: #include "bytecode.h"
27: #include "bc-typecd.h"
28: #include "bc-opcode.h"
29: #include "bc-optab.h"
30:
31: #define obstack_chunk_alloc xmalloc
32: #define obstack_chunk_free free
33:
34: extern char *xmalloc ();
35: extern void free ();
36:
37: /* Table relating interpreter typecodes to machine modes. */
38: #define GET_TYPECODE_MODE(CODE) (typecode_mode[((int) CODE)])
39: enum machine_mode typecode_mode[] = {
40: #define DEFTYPECODE(CODE, NAME, MODE, TYPE) MODE,
41: #include "bc-typecd.def"
42: #undef DEFTYPECODE
43: };
44:
45: /* Machine mode to type code map */
46: static enum typecode signed_mode_to_code_map[MAX_MACHINE_MODE+1];
47: static enum typecode unsigned_mode_to_code_map[MAX_MACHINE_MODE+1];
48:
49: #define GET_TYPECODE_SIZE(CODE) GET_MODE_SIZE (GET_TYPECODE_MODE (CODE))
50:
51: #define BIG_ARBITRARY_NUMBER 100000
52:
53: /* Table of recipes for conversions among scalar types, to be filled
54: in as needed at run time. */
55: static struct conversion_recipe
56: {
57: unsigned char *opcodes; /* Bytecodes to emit in order. */
58: int nopcodes; /* Count of bytecodes. */
59: int cost; /* A rather arbitrary cost function. */
60: } conversion_recipe[NUM_TYPECODES][NUM_TYPECODES];
61:
62: /* Binary operator tables. */
63: struct binary_operator optab_plus_expr[] = {
64: { addSI, SIcode, SIcode, SIcode },
65: { addDI, DIcode, DIcode, DIcode },
66: { addSF, SFcode, SFcode, SFcode },
67: { addDF, DFcode, DFcode, DFcode },
68: { addXF, XFcode, XFcode, XFcode },
69: { addPSI, Pcode, Pcode, SIcode },
70: { -1, -1, -1, -1 },
71: };
72:
73: struct binary_operator optab_minus_expr[] = {
74: { subSI, SIcode, SIcode, SIcode },
75: { subDI, DIcode, DIcode, DIcode },
76: { subSF, SFcode, SFcode, SFcode },
77: { subDF, DFcode, DFcode, DFcode },
78: { subXF, XFcode, XFcode, XFcode },
79: { subPP, SIcode, Pcode, Pcode },
80: { -1, -1, -1, -1 },
81: };
82:
83: /* The ordering of the tables for multiplicative operators
84: is such that unsigned operations will be preferred to signed
85: operations when one argument is unsigned. */
86:
87: struct binary_operator optab_mult_expr[] = {
88: { mulSU, SUcode, SUcode, SUcode },
89: { mulDU, DUcode, DUcode, DUcode },
90: { mulSI, SIcode, SIcode, SIcode },
91: { mulDI, DIcode, DIcode, DIcode },
92: { mulSF, SFcode, SFcode, SFcode },
93: { mulDF, DFcode, DFcode, DFcode },
94: { mulXF, XFcode, XFcode, XFcode },
95: { -1, -1, -1, -1 },
96: };
97:
98: struct binary_operator optab_trunc_div_expr[] = {
99: { divSU, SUcode, SUcode, SUcode },
100: { divDU, DUcode, DUcode, DUcode },
101: { divSI, SIcode, SIcode, SIcode },
102: { divDI, DIcode, DIcode, DIcode },
103: { -1, -1, -1, -1 },
104: };
105:
106: struct binary_operator optab_trunc_mod_expr[] = {
107: { modSU, SUcode, SUcode, SUcode },
108: { modDU, DUcode, DUcode, DUcode },
109: { modSI, SIcode, SIcode, SIcode },
110: { modDI, DIcode, DIcode, DIcode },
111: { -1, -1, -1, -1 },
112: };
113:
114: struct binary_operator optab_rdiv_expr[] = {
115: { divSF, SFcode, SFcode, SFcode },
116: { divDF, DFcode, DFcode, DFcode },
117: { divXF, XFcode, XFcode, XFcode },
118: { -1, -1, -1, -1 },
119: };
120:
121: struct binary_operator optab_bit_and_expr[] = {
122: { andSI, SIcode, SIcode, SIcode },
123: { andDI, DIcode, DIcode, DIcode },
124: { -1, -1, -1, -1 },
125: };
126:
127: struct binary_operator optab_bit_ior_expr[] = {
128: { iorSI, SIcode, SIcode, SIcode },
129: { iorDI, DIcode, DIcode, DIcode },
130: { -1, -1, -1, -1 },
131: };
132:
133: struct binary_operator optab_bit_xor_expr[] = {
134: { xorSI, SIcode, SIcode, SIcode },
135: { xorDI, DIcode, DIcode, DIcode },
136: { -1, -1, -1, -1 },
137: };
138:
139: struct binary_operator optab_lshift_expr[] = {
140: { lshiftSI, SIcode, SIcode, SIcode },
141: { lshiftSU, SUcode, SUcode, SIcode },
142: { lshiftDI, DIcode, DIcode, SIcode },
143: { lshiftDU, DUcode, DUcode, SIcode },
144: { -1, -1, -1, -1 },
145: };
146:
147: struct binary_operator optab_rshift_expr[] = {
148: { rshiftSI, SIcode, SIcode, SIcode },
149: { rshiftSU, SUcode, SUcode, SIcode },
150: { rshiftDI, DIcode, DIcode, SIcode },
151: { rshiftDU, DUcode, DUcode, SIcode },
152: { -1, -1, -1, -1 },
153: };
154:
155: struct binary_operator optab_truth_and_expr[] = {
156: { andSI, SIcode, Tcode, Tcode },
157: { -1, -1, -1, -1 },
158: };
159:
160: struct binary_operator optab_truth_or_expr[] = {
161: { iorSI, SIcode, Tcode, Tcode },
162: { -1, -1, -1, -1 },
163: };
164:
165: struct binary_operator optab_lt_expr[] = {
166: { ltSI, Tcode, SIcode, SIcode },
167: { ltSU, Tcode, SUcode, SUcode },
168: { ltDI, Tcode, DIcode, DIcode },
169: { ltDU, Tcode, DUcode, DUcode },
170: { ltSF, Tcode, SFcode, SFcode },
171: { ltDF, Tcode, DFcode, DFcode },
172: { ltXF, Tcode, XFcode, XFcode },
173: { ltP, Tcode, Pcode, Pcode },
174: { -1, -1, -1, -1 },
175: };
176:
177: struct binary_operator optab_le_expr[] = {
178: { leSI, Tcode, SIcode, SIcode },
179: { leSU, Tcode, SUcode, SUcode },
180: { leDI, Tcode, DIcode, DIcode },
181: { leDU, Tcode, DUcode, DUcode },
182: { leSF, Tcode, SFcode, SFcode },
183: { leDF, Tcode, DFcode, DFcode },
184: { leXF, Tcode, XFcode, XFcode },
185: { leP, Tcode, Pcode, Pcode },
186: { -1, -1, -1, -1 },
187: };
188:
189: struct binary_operator optab_ge_expr[] = {
190: { geSI, Tcode, SIcode, SIcode },
191: { geSU, Tcode, SUcode, SUcode },
192: { geDI, Tcode, DIcode, DIcode },
193: { geDU, Tcode, DUcode, DUcode },
194: { geSF, Tcode, SFcode, SFcode },
195: { geDF, Tcode, DFcode, DFcode },
196: { geXF, Tcode, XFcode, XFcode },
197: { geP, Tcode, Pcode, Pcode },
198: { -1, -1, -1, -1 },
199: };
200:
201: struct binary_operator optab_gt_expr[] = {
202: { gtSI, Tcode, SIcode, SIcode },
203: { gtSU, Tcode, SUcode, SUcode },
204: { gtDI, Tcode, DIcode, DIcode },
205: { gtDU, Tcode, DUcode, DUcode },
206: { gtSF, Tcode, SFcode, SFcode },
207: { gtDF, Tcode, DFcode, DFcode },
208: { gtXF, Tcode, XFcode, XFcode },
209: { gtP, Tcode, Pcode, Pcode },
210: { -1, -1, -1, -1 },
211: };
212:
213: struct binary_operator optab_eq_expr[] = {
214: { eqSI, Tcode, SIcode, SIcode },
215: { eqDI, Tcode, DIcode, DIcode },
216: { eqSF, Tcode, SFcode, SFcode },
217: { eqDF, Tcode, DFcode, DFcode },
218: { eqXF, Tcode, XFcode, XFcode },
219: { eqP, Tcode, Pcode, Pcode },
220: { -1, -1, -1, -1 },
221: };
222:
223: struct binary_operator optab_ne_expr[] = {
224: { neSI, Tcode, SIcode, SIcode },
225: { neDI, Tcode, DIcode, DIcode },
226: { neSF, Tcode, SFcode, SFcode },
227: { neDF, Tcode, DFcode, DFcode },
228: { neXF, Tcode, XFcode, XFcode },
229: { neP, Tcode, Pcode, Pcode },
230: { -1, -1, -1, -1 },
231: };
232:
233: /* Unary operator tables. */
234: struct unary_operator optab_negate_expr[] = {
235: { negSI, SIcode, SIcode },
236: { negDI, DIcode, DIcode },
237: { negSF, SFcode, SFcode },
238: { negDF, DFcode, DFcode },
239: { negXF, XFcode, XFcode },
240: { -1, -1, -1 },
241: };
242:
243: struct unary_operator optab_bit_not_expr[] = {
244: { notSI, SIcode, SIcode },
245: { notDI, DIcode, DIcode },
246: { -1, -1, -1 },
247: };
248:
249: struct unary_operator optab_truth_not_expr[] = {
250: { notT, SIcode, SIcode },
251: { -1, -1, -1 },
252: };
253:
254: /* Increment operator tables. */
255: struct increment_operator optab_predecrement_expr[] = {
256: { predecQI, QIcode },
257: { predecQI, QUcode },
258: { predecHI, HIcode },
259: { predecHI, HUcode },
260: { predecSI, SIcode },
261: { predecSI, SUcode },
262: { predecDI, DIcode },
263: { predecDI, DUcode },
264: { predecP, Pcode },
265: { predecSF, SFcode },
266: { predecDF, DFcode },
267: { predecXF, XFcode },
268: { -1, -1 },
269: };
270:
271: struct increment_operator optab_preincrement_expr[] = {
272: { preincQI, QIcode },
273: { preincQI, QUcode },
274: { preincHI, HIcode },
275: { preincHI, HUcode },
276: { preincSI, SIcode },
277: { preincSI, SUcode },
278: { preincDI, DIcode },
279: { preincDI, DUcode },
280: { preincP, Pcode },
281: { preincSF, SFcode },
282: { preincDF, DFcode },
283: { preincXF, XFcode },
284: { -1, -1 },
285: };
286:
287: struct increment_operator optab_postdecrement_expr[] = {
288: { postdecQI, QIcode },
289: { postdecQI, QUcode },
290: { postdecHI, HIcode },
291: { postdecHI, HUcode },
292: { postdecSI, SIcode },
293: { postdecSI, SUcode },
294: { postdecDI, DIcode },
295: { postdecDI, DUcode },
296: { postdecP, Pcode },
297: { postdecSF, SFcode },
298: { postdecDF, DFcode },
299: { postdecXF, XFcode },
300: { -1, -1 },
301: };
302:
303: struct increment_operator optab_postincrement_expr[] = {
304: { postincQI, QIcode },
305: { postincQI, QUcode },
306: { postincHI, HIcode },
307: { postincHI, HUcode },
308: { postincSI, SIcode },
309: { postincSI, SUcode },
310: { postincDI, DIcode },
311: { postincDI, DUcode },
312: { postincP, Pcode },
313: { postincSF, SFcode },
314: { postincDF, DFcode },
315: { postincXF, XFcode },
316: { -1, -1 },
317: };
318:
319: /* Table of conversions supported by the interpreter. */
320: static struct conversion_info
321: {
322: enum bytecode_opcode opcode; /* here indicates the conversion needs no opcode. */
323: enum typecode from;
324: enum typecode to;
325: int cost; /* 1 for no-op conversions, 2 for widening conversions,
326: 4 for int/float conversions, 8 for narrowing conversions. */
327: } conversion_info[] = {
328: { -1, QIcode, QUcode, 1 },
329: { -1, HIcode, HUcode, 1 },
330: { -1, SIcode, SUcode, 1 },
331: { -1, DIcode, DUcode, 1 },
332: { -1, QUcode, QIcode, 1 },
333: { -1, HUcode, HIcode, 1 },
334: { -1, SUcode, SIcode, 1 },
335: { -1, DUcode, DIcode, 1 },
336: { -1, Tcode, SIcode, 1 },
337: { convertQIHI, QIcode, HIcode, 2 },
338: { convertQUHU, QUcode, HUcode, 2 },
339: { convertQUSU, QUcode, SUcode, 2 },
340: { convertHISI, HIcode, SIcode, 2 },
341: { convertHUSU, HUcode, SUcode, 2 },
342: { convertSIDI, SIcode, DIcode, 2 },
343: { convertSUDU, SUcode, DUcode, 2 },
344: { convertSFDF, SFcode, DFcode, 2 },
345: { convertDFXF, DFcode, XFcode, 2 },
346: { convertHIQI, HIcode, QIcode, 8 },
347: { convertSIQI, SIcode, QIcode, 8 },
348: { convertSIHI, SIcode, HIcode, 8 },
349: { convertSUQU, SUcode, QUcode, 8 },
350: { convertDISI, DIcode, SIcode, 8 },
351: { convertDFSF, DFcode, SFcode, 8 },
352: { convertXFDF, XFcode, DFcode, 8 },
353: { convertPSI, Pcode, SIcode, 2 },
354: { convertSIP, SIcode, Pcode, 2 },
355: { convertSIT, SIcode, Tcode, 2 },
356: { convertDIT, DIcode, Tcode, 2 },
357: { convertSFT, SFcode, Tcode, 2 },
358: { convertDFT, DFcode, Tcode, 2 },
359: { convertXFT, XFcode, Tcode, 2 },
360: { convertQISI, QIcode, SIcode, 2 },
361: { convertPT, Pcode, Tcode, 2 },
362: { convertSISF, SIcode, SFcode, 4 },
363: { convertSIDF, SIcode, DFcode, 4 },
364: { convertSIXF, SIcode, XFcode, 4 },
365: { convertSUSF, SUcode, SFcode, 4 },
366: { convertSUDF, SUcode, DFcode, 4 },
367: { convertSUXF, SUcode, XFcode, 4 },
368: { convertDISF, DIcode, SFcode, 4 },
369: { convertDIDF, DIcode, DFcode, 4 },
370: { convertDIXF, DIcode, XFcode, 4 },
371: { convertDUSF, DUcode, SFcode, 4 },
372: { convertDUDF, DUcode, DFcode, 4 },
373: { convertDUXF, DUcode, XFcode, 4 },
374: { convertSFSI, SFcode, SIcode, 4 },
375: { convertDFSI, DFcode, SIcode, 4 },
376: { convertXFSI, XFcode, SIcode, 4 },
377: { convertSFSU, SFcode, SUcode, 4 },
378: { convertDFSU, DFcode, SUcode, 4 },
379: { convertXFSU, XFcode, SUcode, 4 },
380: { convertSFDI, SFcode, DIcode, 4 },
381: { convertDFDI, DFcode, DIcode, 4 },
382: { convertXFDI, XFcode, DIcode, 4 },
383: { convertSFDU, SFcode, DUcode, 4 },
384: { convertDFDU, DFcode, DUcode, 4 },
385: { convertXFDU, XFcode, DUcode, 4 },
386: { convertSIQI, SIcode, QIcode, 8 },
387: };
388:
389: #define NUM_CONVERSIONS (sizeof conversion_info / sizeof (struct conversion_info))
390:
391: /* List form of a conversion recipe. */
392: struct conversion_list
393: {
394: enum bytecode_opcode opcode;
395: enum typecode to;
396: int cost;
397: struct conversion_list *prev;
398: };
399:
400: /* Determine if it is "reasonable" to add a given conversion to
401: a given list of conversions. The following criteria define
402: "reasonable" conversion lists:
403: * No typecode appears more than once in the sequence (no loops).
404: * At most one conversion from integer to float or vice versa is present.
405: * Either sign extensions or zero extensions may be present, but not both.
406: * No widening conversions occur after a signed/unsigned conversion.
407: * The sequence of sizes must be strict nonincreasing or nondecreasing. */
408: static int
409: conversion_reasonable_p (conversion, list)
410: struct conversion_info *conversion;
411: struct conversion_list *list;
412: {
413: struct conversion_list *curr;
414: int curr_size, prev_size;
415: int has_int_float, has_float_int;
416: int has_sign_extend, has_zero_extend;
417: int has_signed_unsigned, has_unsigned_signed;
418:
419: has_int_float = 0;
420: has_float_int = 0;
421: has_sign_extend = 0;
422: has_zero_extend = 0;
423: has_signed_unsigned = 0;
424: has_unsigned_signed = 0;
425:
426: /* Make sure the destination typecode doesn't already appear in
427: the list. */
428: for (curr = list; curr; curr = curr->prev)
429: if (conversion->to == curr->to)
430: return 0;
431:
432: /* Check for certain kinds of conversions. */
433: if (TYPECODE_INTEGER_P (conversion->from)
434: && TYPECODE_FLOAT_P (conversion->to))
435: has_int_float = 1;
436: if (TYPECODE_FLOAT_P (conversion->from)
437: && TYPECODE_INTEGER_P (conversion->to))
438: has_float_int = 1;
439: if (TYPECODE_SIGNED_P (conversion->from)
440: && TYPECODE_SIGNED_P (conversion->to)
441: && GET_TYPECODE_SIZE (conversion->from)
442: < GET_TYPECODE_SIZE (conversion->to))
443: has_sign_extend = 1;
444: if (TYPECODE_UNSIGNED_P (conversion->from)
445: && TYPECODE_UNSIGNED_P (conversion->to)
446: && GET_TYPECODE_SIZE (conversion->from)
447: < GET_TYPECODE_SIZE (conversion->to))
448: has_zero_extend = 1;
449:
450: for (curr = list; curr && curr->prev; curr = curr->prev)
451: {
452: if (TYPECODE_INTEGER_P (curr->prev->to)
453: && TYPECODE_FLOAT_P (curr->to))
454: has_int_float = 1;
455: if (TYPECODE_FLOAT_P (curr->prev->to)
456: && TYPECODE_INTEGER_P (curr->to))
457: has_float_int = 1;
458: if (TYPECODE_SIGNED_P (curr->prev->to)
459: && TYPECODE_SIGNED_P (curr->to)
460: && GET_TYPECODE_SIZE (curr->prev->to)
461: < GET_TYPECODE_SIZE (curr->to))
462: has_sign_extend = 1;
463: if (TYPECODE_UNSIGNED_P (curr->prev->to)
464: && TYPECODE_UNSIGNED_P (curr->to)
465: && GET_TYPECODE_SIZE (curr->prev->to)
466: < GET_TYPECODE_SIZE (curr->to))
467: has_zero_extend = 1;
468: if (TYPECODE_SIGNED_P (curr->prev->to)
469: && TYPECODE_UNSIGNED_P (curr->to))
470: has_signed_unsigned = 1;
471: if (TYPECODE_UNSIGNED_P (curr->prev->to)
472: && TYPECODE_SIGNED_P (curr->to))
473: has_unsigned_signed = 1;
474: }
475:
476: if (TYPECODE_INTEGER_P (conversion->from)
477: && TYPECODE_INTEGER_P (conversion->to)
478: && GET_TYPECODE_SIZE (conversion->to)
479: > GET_TYPECODE_SIZE (conversion->from)
480: && (has_signed_unsigned || has_unsigned_signed))
481: return 0;
482:
483: if (has_float_int && has_int_float || has_sign_extend && has_zero_extend)
484: return 0;
485:
486: /* Make sure the sequence of destination typecode sizes is
487: strictly nondecreasing or strictly nonincreasing. */
488: prev_size = GET_TYPECODE_SIZE (conversion->to);
489: for (curr = list; curr; curr = curr->prev)
490: {
491: curr_size = GET_TYPECODE_SIZE (curr->to);
492: if (curr_size != prev_size)
493: break;
494: }
495: if (!curr)
496: return 1;
497:
498: if (curr_size < prev_size)
499: for (prev_size = curr_size; curr; curr = curr->prev)
500: {
501: curr_size = GET_TYPECODE_SIZE (curr->to);
502: if (curr_size > prev_size)
503: return 0;
504: prev_size = curr_size;
505: }
506: else
507: for (prev_size = curr_size; curr; curr = curr->prev)
508: {
509: curr_size = GET_TYPECODE_SIZE (curr->to);
510: if (curr_size < prev_size)
511: return 0;
512: prev_size = curr_size;
513: }
514: return 1;
515: }
516:
517:
518: /* Exhaustively search all reasonable conversions to find one to
519: convert the given types. */
520: static struct conversion_recipe
521: deduce_conversion (from, to)
522: enum typecode from, to;
523: {
524: struct rl
525: {
526: struct conversion_list *list;
527: struct rl *next;
528: } *prev, curr, *good, *temp;
529: struct conversion_list *conv, *best;
530: int i, cost, bestcost;
531: struct conversion_recipe result;
532: struct obstack recipe_obstack;
533:
534:
535: obstack_init (&recipe_obstack);
536: curr.next = (struct rl *) obstack_alloc (&recipe_obstack, sizeof (struct rl));
537: curr.next->list =
538: (struct conversion_list *) obstack_alloc (&recipe_obstack,
539: sizeof (struct conversion_list));
540: curr.next->list->opcode = -1;
541: curr.next->list->to = from;
542: curr.next->list->cost = 0;
543: curr.next->list->prev = 0;
544: curr.next->next = 0;
545: good = 0;
546:
547: while (curr.next)
548: {
549: /* Remove successful conversions from further consideration. */
550: for (prev = &curr; prev; prev = prev->next)
551: if (prev->next && prev->next->list->to == to)
552: {
553: temp = prev->next->next;
554: prev->next->next = good;
555: good = prev->next;
556: prev->next = temp;
557: }
558:
559: /* Go through each of the pending conversion chains, trying
560: all possible candidate conversions on them. */
561: for (prev = curr.next, curr.next = 0; prev; prev = prev->next)
562: for (i = 0; i < NUM_CONVERSIONS; ++i)
563: if (conversion_info[i].from == prev->list->to
564: && conversion_reasonable_p (&conversion_info[i], prev->list))
565: {
566: temp = (struct rl *) obstack_alloc (&recipe_obstack,
567: sizeof (struct rl));
568: temp->list = (struct conversion_list *)
569: obstack_alloc (&recipe_obstack,
570: sizeof (struct conversion_list));
571: temp->list->opcode = conversion_info[i].opcode;
572: temp->list->to = conversion_info[i].to;
573: temp->list->cost = conversion_info[i].cost;
574: temp->list->prev = prev->list;
575: temp->next = curr.next;
576: curr.next = temp;
577: }
578: }
579:
580: bestcost = BIG_ARBITRARY_NUMBER;
581: best = 0;
582: for (temp = good; temp; temp = temp->next)
583: {
584: for (conv = temp->list, cost = 0; conv; conv = conv->prev)
585: cost += conv->cost;
586: if (cost < bestcost)
587: {
588: bestcost = cost;
589: best = temp->list;
590: }
591: }
592:
593: if (!best)
594: abort ();
595:
596: for (i = 0, conv = best; conv; conv = conv->prev)
597: if (conv->opcode != -1)
598: ++i;
599:
600: result.opcodes = (unsigned char *) xmalloc (i);
601: result.nopcodes = i;
602: for (conv = best; conv; conv = conv->prev)
603: if (conv->opcode != -1)
604: result.opcodes[--i] = conv->opcode;
605: result.cost = bestcost;
606: obstack_free (&recipe_obstack, 0);
607: return result;
608: }
609:
610: #define DEDUCE_CONVERSION(FROM, TO) \
611: (conversion_recipe[(int) FROM][(int) TO].opcodes ? 0 \
612: : (conversion_recipe[(int) FROM][(int) TO] \
613: = deduce_conversion (FROM, TO), 0))
614:
615:
616: /* Emit a conversion between the given scalar types. */
617: void
618: emit_typecode_conversion (from, to)
619: enum typecode from, to;
620: {
621: int i;
622:
623: DEDUCE_CONVERSION (from, to);
624: for (i = 0; i < conversion_recipe[(int) from][(int) to].nopcodes; ++i)
625: bc_emit_instruction (conversion_recipe[(int) from][(int) to].opcodes[i]);
626: }
627:
628:
629: /* Initialize mode_to_code_map[] */
630: void
631: bc_init_mode_to_code_map ()
632: {
633: int mode;
634:
635: for (mode = 0; mode < MAX_MACHINE_MODE + 1; mode++)
636: {
637: signed_mode_to_code_map[mode] =
638: unsigned_mode_to_code_map[mode] =
639: LAST_AND_UNUSED_TYPECODE;
640: }
641:
642: #define DEF_MODEMAP(SYM, CODE, UCODE, CONST, LOAD, STORE) \
643: { signed_mode_to_code_map[(int) SYM] = CODE; \
644: unsigned_mode_to_code_map[(int) SYM] = UCODE; }
645: #include "modemap.def"
646: #undef DEF_MODEMAP
647:
648: /* Initialize opcode maps for const, load, and store */
649: bc_init_mode_to_opcode_maps ();
650: }
651:
652: /* Given a machine mode return the preferred typecode. */
653: enum typecode
654: preferred_typecode (mode, unsignedp)
655: enum machine_mode mode;
656: int unsignedp;
657: {
658: enum typecode code = (unsignedp
659: ? unsigned_mode_to_code_map
660: : signed_mode_to_code_map) [MIN ((int) mode,
661: (int) MAX_MACHINE_MODE)];
662:
663: if (code == LAST_AND_UNUSED_TYPECODE)
664: abort ();
665:
666: return code;
667: }
668:
669:
670: /* Expand a conversion between the given types. */
671: void
672: bc_expand_conversion (from, to)
673: tree from, to;
674: {
675: enum typecode fcode, tcode;
676:
677: fcode = preferred_typecode (TYPE_MODE (from), TREE_UNSIGNED (from));
678: tcode = preferred_typecode (TYPE_MODE (to), TREE_UNSIGNED (to));
679:
680: emit_typecode_conversion (fcode, tcode);
681: }
682:
683: /* Expand a conversion of the given type to a truth value. */
684: void
685: bc_expand_truth_conversion (from)
686: tree from;
687: {
688: enum typecode fcode;
689:
690: fcode = preferred_typecode (TYPE_MODE (from), TREE_UNSIGNED (from));
691: emit_typecode_conversion (fcode, Tcode);
692: }
693:
694: /* Emit an appropriate binary operation. */
695: void
696: bc_expand_binary_operation (optab, resulttype, arg0, arg1)
697: struct binary_operator optab[];
698: tree resulttype, arg0, arg1;
699: {
700: int i, besti, cost, bestcost;
701: enum typecode resultcode, arg0code, arg1code;
702:
703: resultcode = preferred_typecode (TYPE_MODE (resulttype), TREE_UNSIGNED (resulttype));
704: arg0code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg0)), TREE_UNSIGNED (resulttype));
705: arg1code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg1)), TREE_UNSIGNED (resulttype));
706:
707: besti = -1;
708: bestcost = BIG_ARBITRARY_NUMBER;
709:
710: for (i = 0; optab[i].opcode != -1; ++i)
711: {
712: cost = 0;
713: DEDUCE_CONVERSION (arg0code, optab[i].arg0);
714: cost += conversion_recipe[(int) arg0code][(int) optab[i].arg0].cost;
715: DEDUCE_CONVERSION (arg1code, optab[i].arg1);
716: cost += conversion_recipe[(int) arg1code][(int) optab[i].arg1].cost;
717: if (cost < bestcost)
718: {
719: besti = i;
720: bestcost = cost;
721: }
722: }
723:
724: if (besti == -1)
725: abort ();
726:
727: expand_expr (arg1);
728: emit_typecode_conversion (arg1code, optab[besti].arg1);
729: expand_expr (arg0);
730: emit_typecode_conversion (arg0code, optab[besti].arg0);
731: bc_emit_instruction (optab[besti].opcode);
732: emit_typecode_conversion (optab[besti].result, resultcode);
733: }
734:
735: /* Emit an appropriate unary operation. */
736: void
737: bc_expand_unary_operation (optab, resulttype, arg0)
738: struct unary_operator optab[];
739: tree resulttype, arg0;
740: {
741: int i, besti, cost, bestcost;
742: enum typecode resultcode, arg0code;
743:
744: resultcode = preferred_typecode (TYPE_MODE (resulttype), TREE_UNSIGNED (resulttype));
745: arg0code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg0)), TREE_UNSIGNED (TREE_TYPE (arg0)));
746:
747: besti = -1;
748: bestcost = BIG_ARBITRARY_NUMBER;
749:
750: for (i = 0; optab[i].opcode != -1; ++i)
751: {
752: DEDUCE_CONVERSION (arg0code, optab[i].arg0);
753: cost = conversion_recipe[(int) arg0code][(int) optab[i].arg0].cost;
754: if (cost < bestcost)
755: {
756: besti = i;
757: bestcost = cost;
758: }
759: }
760:
761: if (besti == -1)
762: abort ();
763:
764: expand_expr (arg0);
765: emit_typecode_conversion (arg0code, optab[besti].arg0);
766: bc_emit_instruction (optab[besti].opcode);
767: emit_typecode_conversion (optab[besti].result, resultcode);
768: }
769:
770:
771: /* Emit an appropriate increment. */
772: void
773: bc_expand_increment (optab, type)
774: struct increment_operator optab[];
775: tree type;
776: {
777: enum typecode code;
778: int i;
779:
780: code = preferred_typecode (TYPE_MODE (type), TREE_UNSIGNED (type));
781: for (i = 0; (int) optab[i].opcode >= 0; ++i)
782: if (code == optab[i].arg)
783: {
784: bc_emit_instruction (optab[i].opcode);
785: return;
786: }
787: abort ();
788: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.