diff options
Diffstat (limited to 'gnu/usr.bin/cc/cc_int/bc-optab.c')
-rw-r--r-- | gnu/usr.bin/cc/cc_int/bc-optab.c | 788 |
1 files changed, 788 insertions, 0 deletions
diff --git a/gnu/usr.bin/cc/cc_int/bc-optab.c b/gnu/usr.bin/cc/cc_int/bc-optab.c new file mode 100644 index 0000000..b8ac57d --- /dev/null +++ b/gnu/usr.bin/cc/cc_int/bc-optab.c @@ -0,0 +1,788 @@ +/* Bytecode conversion definitions for GNU C-compiler. + Copyright (C) 1993, 1994 Free Software Foundation, Inc. + +This file is part of GNU CC. + +GNU CC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU CC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU CC; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +#include "config.h" +#include "tree.h" +#include "rtl.h" +#include "machmode.h" +#include "obstack.h" +#include "bytecode.h" +#include "bc-typecd.h" +#include "bc-opcode.h" +#include "bc-optab.h" + +#define obstack_chunk_alloc xmalloc +#define obstack_chunk_free free + +extern char *xmalloc (); +extern void free (); + +/* Table relating interpreter typecodes to machine modes. */ +#define GET_TYPECODE_MODE(CODE) (typecode_mode[((int) CODE)]) +enum machine_mode typecode_mode[] = { +#define DEFTYPECODE(CODE, NAME, MODE, TYPE) MODE, +#include "bc-typecd.def" +#undef DEFTYPECODE +}; + +/* Machine mode to type code map */ +static enum typecode signed_mode_to_code_map[MAX_MACHINE_MODE+1]; +static enum typecode unsigned_mode_to_code_map[MAX_MACHINE_MODE+1]; + +#define GET_TYPECODE_SIZE(CODE) GET_MODE_SIZE (GET_TYPECODE_MODE (CODE)) + +#define BIG_ARBITRARY_NUMBER 100000 + +/* Table of recipes for conversions among scalar types, to be filled + in as needed at run time. */ +static struct conversion_recipe +{ + unsigned char *opcodes; /* Bytecodes to emit in order. */ + int nopcodes; /* Count of bytecodes. */ + int cost; /* A rather arbitrary cost function. */ +} conversion_recipe[NUM_TYPECODES][NUM_TYPECODES]; + +/* Binary operator tables. */ +struct binary_operator optab_plus_expr[] = { + { addSI, SIcode, SIcode, SIcode }, + { addDI, DIcode, DIcode, DIcode }, + { addSF, SFcode, SFcode, SFcode }, + { addDF, DFcode, DFcode, DFcode }, + { addXF, XFcode, XFcode, XFcode }, + { addPSI, Pcode, Pcode, SIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_minus_expr[] = { + { subSI, SIcode, SIcode, SIcode }, + { subDI, DIcode, DIcode, DIcode }, + { subSF, SFcode, SFcode, SFcode }, + { subDF, DFcode, DFcode, DFcode }, + { subXF, XFcode, XFcode, XFcode }, + { subPP, SIcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +/* The ordering of the tables for multiplicative operators + is such that unsigned operations will be preferred to signed + operations when one argument is unsigned. */ + +struct binary_operator optab_mult_expr[] = { + { mulSU, SUcode, SUcode, SUcode }, + { mulDU, DUcode, DUcode, DUcode }, + { mulSI, SIcode, SIcode, SIcode }, + { mulDI, DIcode, DIcode, DIcode }, + { mulSF, SFcode, SFcode, SFcode }, + { mulDF, DFcode, DFcode, DFcode }, + { mulXF, XFcode, XFcode, XFcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_trunc_div_expr[] = { + { divSU, SUcode, SUcode, SUcode }, + { divDU, DUcode, DUcode, DUcode }, + { divSI, SIcode, SIcode, SIcode }, + { divDI, DIcode, DIcode, DIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_trunc_mod_expr[] = { + { modSU, SUcode, SUcode, SUcode }, + { modDU, DUcode, DUcode, DUcode }, + { modSI, SIcode, SIcode, SIcode }, + { modDI, DIcode, DIcode, DIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_rdiv_expr[] = { + { divSF, SFcode, SFcode, SFcode }, + { divDF, DFcode, DFcode, DFcode }, + { divXF, XFcode, XFcode, XFcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_bit_and_expr[] = { + { andSI, SIcode, SIcode, SIcode }, + { andDI, DIcode, DIcode, DIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_bit_ior_expr[] = { + { iorSI, SIcode, SIcode, SIcode }, + { iorDI, DIcode, DIcode, DIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_bit_xor_expr[] = { + { xorSI, SIcode, SIcode, SIcode }, + { xorDI, DIcode, DIcode, DIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_lshift_expr[] = { + { lshiftSI, SIcode, SIcode, SIcode }, + { lshiftSU, SUcode, SUcode, SIcode }, + { lshiftDI, DIcode, DIcode, SIcode }, + { lshiftDU, DUcode, DUcode, SIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_rshift_expr[] = { + { rshiftSI, SIcode, SIcode, SIcode }, + { rshiftSU, SUcode, SUcode, SIcode }, + { rshiftDI, DIcode, DIcode, SIcode }, + { rshiftDU, DUcode, DUcode, SIcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_truth_and_expr[] = { + { andSI, SIcode, Tcode, Tcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_truth_or_expr[] = { + { iorSI, SIcode, Tcode, Tcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_lt_expr[] = { + { ltSI, Tcode, SIcode, SIcode }, + { ltSU, Tcode, SUcode, SUcode }, + { ltDI, Tcode, DIcode, DIcode }, + { ltDU, Tcode, DUcode, DUcode }, + { ltSF, Tcode, SFcode, SFcode }, + { ltDF, Tcode, DFcode, DFcode }, + { ltXF, Tcode, XFcode, XFcode }, + { ltP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_le_expr[] = { + { leSI, Tcode, SIcode, SIcode }, + { leSU, Tcode, SUcode, SUcode }, + { leDI, Tcode, DIcode, DIcode }, + { leDU, Tcode, DUcode, DUcode }, + { leSF, Tcode, SFcode, SFcode }, + { leDF, Tcode, DFcode, DFcode }, + { leXF, Tcode, XFcode, XFcode }, + { leP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_ge_expr[] = { + { geSI, Tcode, SIcode, SIcode }, + { geSU, Tcode, SUcode, SUcode }, + { geDI, Tcode, DIcode, DIcode }, + { geDU, Tcode, DUcode, DUcode }, + { geSF, Tcode, SFcode, SFcode }, + { geDF, Tcode, DFcode, DFcode }, + { geXF, Tcode, XFcode, XFcode }, + { geP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_gt_expr[] = { + { gtSI, Tcode, SIcode, SIcode }, + { gtSU, Tcode, SUcode, SUcode }, + { gtDI, Tcode, DIcode, DIcode }, + { gtDU, Tcode, DUcode, DUcode }, + { gtSF, Tcode, SFcode, SFcode }, + { gtDF, Tcode, DFcode, DFcode }, + { gtXF, Tcode, XFcode, XFcode }, + { gtP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_eq_expr[] = { + { eqSI, Tcode, SIcode, SIcode }, + { eqDI, Tcode, DIcode, DIcode }, + { eqSF, Tcode, SFcode, SFcode }, + { eqDF, Tcode, DFcode, DFcode }, + { eqXF, Tcode, XFcode, XFcode }, + { eqP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +struct binary_operator optab_ne_expr[] = { + { neSI, Tcode, SIcode, SIcode }, + { neDI, Tcode, DIcode, DIcode }, + { neSF, Tcode, SFcode, SFcode }, + { neDF, Tcode, DFcode, DFcode }, + { neXF, Tcode, XFcode, XFcode }, + { neP, Tcode, Pcode, Pcode }, + { -1, -1, -1, -1 }, +}; + +/* Unary operator tables. */ +struct unary_operator optab_negate_expr[] = { + { negSI, SIcode, SIcode }, + { negDI, DIcode, DIcode }, + { negSF, SFcode, SFcode }, + { negDF, DFcode, DFcode }, + { negXF, XFcode, XFcode }, + { -1, -1, -1 }, +}; + +struct unary_operator optab_bit_not_expr[] = { + { notSI, SIcode, SIcode }, + { notDI, DIcode, DIcode }, + { -1, -1, -1 }, +}; + +struct unary_operator optab_truth_not_expr[] = { + { notT, SIcode, SIcode }, + { -1, -1, -1 }, +}; + +/* Increment operator tables. */ +struct increment_operator optab_predecrement_expr[] = { + { predecQI, QIcode }, + { predecQI, QUcode }, + { predecHI, HIcode }, + { predecHI, HUcode }, + { predecSI, SIcode }, + { predecSI, SUcode }, + { predecDI, DIcode }, + { predecDI, DUcode }, + { predecP, Pcode }, + { predecSF, SFcode }, + { predecDF, DFcode }, + { predecXF, XFcode }, + { -1, -1 }, +}; + +struct increment_operator optab_preincrement_expr[] = { + { preincQI, QIcode }, + { preincQI, QUcode }, + { preincHI, HIcode }, + { preincHI, HUcode }, + { preincSI, SIcode }, + { preincSI, SUcode }, + { preincDI, DIcode }, + { preincDI, DUcode }, + { preincP, Pcode }, + { preincSF, SFcode }, + { preincDF, DFcode }, + { preincXF, XFcode }, + { -1, -1 }, +}; + +struct increment_operator optab_postdecrement_expr[] = { + { postdecQI, QIcode }, + { postdecQI, QUcode }, + { postdecHI, HIcode }, + { postdecHI, HUcode }, + { postdecSI, SIcode }, + { postdecSI, SUcode }, + { postdecDI, DIcode }, + { postdecDI, DUcode }, + { postdecP, Pcode }, + { postdecSF, SFcode }, + { postdecDF, DFcode }, + { postdecXF, XFcode }, + { -1, -1 }, +}; + +struct increment_operator optab_postincrement_expr[] = { + { postincQI, QIcode }, + { postincQI, QUcode }, + { postincHI, HIcode }, + { postincHI, HUcode }, + { postincSI, SIcode }, + { postincSI, SUcode }, + { postincDI, DIcode }, + { postincDI, DUcode }, + { postincP, Pcode }, + { postincSF, SFcode }, + { postincDF, DFcode }, + { postincXF, XFcode }, + { -1, -1 }, +}; + +/* Table of conversions supported by the interpreter. */ +static struct conversion_info +{ + enum bytecode_opcode opcode; /* here indicates the conversion needs no opcode. */ + enum typecode from; + enum typecode to; + int cost; /* 1 for no-op conversions, 2 for widening conversions, + 4 for int/float conversions, 8 for narrowing conversions. */ +} conversion_info[] = { + { -1, QIcode, QUcode, 1 }, + { -1, HIcode, HUcode, 1 }, + { -1, SIcode, SUcode, 1 }, + { -1, DIcode, DUcode, 1 }, + { -1, QUcode, QIcode, 1 }, + { -1, HUcode, HIcode, 1 }, + { -1, SUcode, SIcode, 1 }, + { -1, DUcode, DIcode, 1 }, + { -1, Tcode, SIcode, 1 }, + { convertQIHI, QIcode, HIcode, 2 }, + { convertQUHU, QUcode, HUcode, 2 }, + { convertQUSU, QUcode, SUcode, 2 }, + { convertHISI, HIcode, SIcode, 2 }, + { convertHUSU, HUcode, SUcode, 2 }, + { convertSIDI, SIcode, DIcode, 2 }, + { convertSUDU, SUcode, DUcode, 2 }, + { convertSFDF, SFcode, DFcode, 2 }, + { convertDFXF, DFcode, XFcode, 2 }, + { convertHIQI, HIcode, QIcode, 8 }, + { convertSIQI, SIcode, QIcode, 8 }, + { convertSIHI, SIcode, HIcode, 8 }, + { convertSUQU, SUcode, QUcode, 8 }, + { convertDISI, DIcode, SIcode, 8 }, + { convertDFSF, DFcode, SFcode, 8 }, + { convertXFDF, XFcode, DFcode, 8 }, + { convertPSI, Pcode, SIcode, 2 }, + { convertSIP, SIcode, Pcode, 2 }, + { convertSIT, SIcode, Tcode, 2 }, + { convertDIT, DIcode, Tcode, 2 }, + { convertSFT, SFcode, Tcode, 2 }, + { convertDFT, DFcode, Tcode, 2 }, + { convertXFT, XFcode, Tcode, 2 }, + { convertQISI, QIcode, SIcode, 2 }, + { convertPT, Pcode, Tcode, 2 }, + { convertSISF, SIcode, SFcode, 4 }, + { convertSIDF, SIcode, DFcode, 4 }, + { convertSIXF, SIcode, XFcode, 4 }, + { convertSUSF, SUcode, SFcode, 4 }, + { convertSUDF, SUcode, DFcode, 4 }, + { convertSUXF, SUcode, XFcode, 4 }, + { convertDISF, DIcode, SFcode, 4 }, + { convertDIDF, DIcode, DFcode, 4 }, + { convertDIXF, DIcode, XFcode, 4 }, + { convertDUSF, DUcode, SFcode, 4 }, + { convertDUDF, DUcode, DFcode, 4 }, + { convertDUXF, DUcode, XFcode, 4 }, + { convertSFSI, SFcode, SIcode, 4 }, + { convertDFSI, DFcode, SIcode, 4 }, + { convertXFSI, XFcode, SIcode, 4 }, + { convertSFSU, SFcode, SUcode, 4 }, + { convertDFSU, DFcode, SUcode, 4 }, + { convertXFSU, XFcode, SUcode, 4 }, + { convertSFDI, SFcode, DIcode, 4 }, + { convertDFDI, DFcode, DIcode, 4 }, + { convertXFDI, XFcode, DIcode, 4 }, + { convertSFDU, SFcode, DUcode, 4 }, + { convertDFDU, DFcode, DUcode, 4 }, + { convertXFDU, XFcode, DUcode, 4 }, + { convertSIQI, SIcode, QIcode, 8 }, +}; + +#define NUM_CONVERSIONS (sizeof conversion_info / sizeof (struct conversion_info)) + +/* List form of a conversion recipe. */ +struct conversion_list +{ + enum bytecode_opcode opcode; + enum typecode to; + int cost; + struct conversion_list *prev; +}; + +/* Determine if it is "reasonable" to add a given conversion to + a given list of conversions. The following criteria define + "reasonable" conversion lists: + * No typecode appears more than once in the sequence (no loops). + * At most one conversion from integer to float or vice versa is present. + * Either sign extensions or zero extensions may be present, but not both. + * No widening conversions occur after a signed/unsigned conversion. + * The sequence of sizes must be strict nonincreasing or nondecreasing. */ +static int +conversion_reasonable_p (conversion, list) + struct conversion_info *conversion; + struct conversion_list *list; +{ + struct conversion_list *curr; + int curr_size, prev_size; + int has_int_float, has_float_int; + int has_sign_extend, has_zero_extend; + int has_signed_unsigned, has_unsigned_signed; + + has_int_float = 0; + has_float_int = 0; + has_sign_extend = 0; + has_zero_extend = 0; + has_signed_unsigned = 0; + has_unsigned_signed = 0; + + /* Make sure the destination typecode doesn't already appear in + the list. */ + for (curr = list; curr; curr = curr->prev) + if (conversion->to == curr->to) + return 0; + + /* Check for certain kinds of conversions. */ + if (TYPECODE_INTEGER_P (conversion->from) + && TYPECODE_FLOAT_P (conversion->to)) + has_int_float = 1; + if (TYPECODE_FLOAT_P (conversion->from) + && TYPECODE_INTEGER_P (conversion->to)) + has_float_int = 1; + if (TYPECODE_SIGNED_P (conversion->from) + && TYPECODE_SIGNED_P (conversion->to) + && GET_TYPECODE_SIZE (conversion->from) + < GET_TYPECODE_SIZE (conversion->to)) + has_sign_extend = 1; + if (TYPECODE_UNSIGNED_P (conversion->from) + && TYPECODE_UNSIGNED_P (conversion->to) + && GET_TYPECODE_SIZE (conversion->from) + < GET_TYPECODE_SIZE (conversion->to)) + has_zero_extend = 1; + + for (curr = list; curr && curr->prev; curr = curr->prev) + { + if (TYPECODE_INTEGER_P (curr->prev->to) + && TYPECODE_FLOAT_P (curr->to)) + has_int_float = 1; + if (TYPECODE_FLOAT_P (curr->prev->to) + && TYPECODE_INTEGER_P (curr->to)) + has_float_int = 1; + if (TYPECODE_SIGNED_P (curr->prev->to) + && TYPECODE_SIGNED_P (curr->to) + && GET_TYPECODE_SIZE (curr->prev->to) + < GET_TYPECODE_SIZE (curr->to)) + has_sign_extend = 1; + if (TYPECODE_UNSIGNED_P (curr->prev->to) + && TYPECODE_UNSIGNED_P (curr->to) + && GET_TYPECODE_SIZE (curr->prev->to) + < GET_TYPECODE_SIZE (curr->to)) + has_zero_extend = 1; + if (TYPECODE_SIGNED_P (curr->prev->to) + && TYPECODE_UNSIGNED_P (curr->to)) + has_signed_unsigned = 1; + if (TYPECODE_UNSIGNED_P (curr->prev->to) + && TYPECODE_SIGNED_P (curr->to)) + has_unsigned_signed = 1; + } + + if (TYPECODE_INTEGER_P (conversion->from) + && TYPECODE_INTEGER_P (conversion->to) + && GET_TYPECODE_SIZE (conversion->to) + > GET_TYPECODE_SIZE (conversion->from) + && (has_signed_unsigned || has_unsigned_signed)) + return 0; + + if (has_float_int && has_int_float || has_sign_extend && has_zero_extend) + return 0; + + /* Make sure the sequence of destination typecode sizes is + strictly nondecreasing or strictly nonincreasing. */ + prev_size = GET_TYPECODE_SIZE (conversion->to); + for (curr = list; curr; curr = curr->prev) + { + curr_size = GET_TYPECODE_SIZE (curr->to); + if (curr_size != prev_size) + break; + } + if (!curr) + return 1; + + if (curr_size < prev_size) + for (prev_size = curr_size; curr; curr = curr->prev) + { + curr_size = GET_TYPECODE_SIZE (curr->to); + if (curr_size > prev_size) + return 0; + prev_size = curr_size; + } + else + for (prev_size = curr_size; curr; curr = curr->prev) + { + curr_size = GET_TYPECODE_SIZE (curr->to); + if (curr_size < prev_size) + return 0; + prev_size = curr_size; + } + return 1; +} + + +/* Exhaustively search all reasonable conversions to find one to + convert the given types. */ +static struct conversion_recipe +deduce_conversion (from, to) + enum typecode from, to; +{ + struct rl + { + struct conversion_list *list; + struct rl *next; + } *prev, curr, *good, *temp; + struct conversion_list *conv, *best; + int i, cost, bestcost; + struct conversion_recipe result; + struct obstack recipe_obstack; + + + obstack_init (&recipe_obstack); + curr.next = (struct rl *) obstack_alloc (&recipe_obstack, sizeof (struct rl)); + curr.next->list = + (struct conversion_list *) obstack_alloc (&recipe_obstack, + sizeof (struct conversion_list)); + curr.next->list->opcode = -1; + curr.next->list->to = from; + curr.next->list->cost = 0; + curr.next->list->prev = 0; + curr.next->next = 0; + good = 0; + + while (curr.next) + { + /* Remove successful conversions from further consideration. */ + for (prev = &curr; prev; prev = prev->next) + if (prev->next && prev->next->list->to == to) + { + temp = prev->next->next; + prev->next->next = good; + good = prev->next; + prev->next = temp; + } + + /* Go through each of the pending conversion chains, trying + all possible candidate conversions on them. */ + for (prev = curr.next, curr.next = 0; prev; prev = prev->next) + for (i = 0; i < NUM_CONVERSIONS; ++i) + if (conversion_info[i].from == prev->list->to + && conversion_reasonable_p (&conversion_info[i], prev->list)) + { + temp = (struct rl *) obstack_alloc (&recipe_obstack, + sizeof (struct rl)); + temp->list = (struct conversion_list *) + obstack_alloc (&recipe_obstack, + sizeof (struct conversion_list)); + temp->list->opcode = conversion_info[i].opcode; + temp->list->to = conversion_info[i].to; + temp->list->cost = conversion_info[i].cost; + temp->list->prev = prev->list; + temp->next = curr.next; + curr.next = temp; + } + } + + bestcost = BIG_ARBITRARY_NUMBER; + best = 0; + for (temp = good; temp; temp = temp->next) + { + for (conv = temp->list, cost = 0; conv; conv = conv->prev) + cost += conv->cost; + if (cost < bestcost) + { + bestcost = cost; + best = temp->list; + } + } + + if (!best) + abort (); + + for (i = 0, conv = best; conv; conv = conv->prev) + if (conv->opcode != -1) + ++i; + + result.opcodes = (unsigned char *) xmalloc (i); + result.nopcodes = i; + for (conv = best; conv; conv = conv->prev) + if (conv->opcode != -1) + result.opcodes[--i] = conv->opcode; + result.cost = bestcost; + obstack_free (&recipe_obstack, 0); + return result; +} + +#define DEDUCE_CONVERSION(FROM, TO) \ + (conversion_recipe[(int) FROM][(int) TO].opcodes ? 0 \ + : (conversion_recipe[(int) FROM][(int) TO] \ + = deduce_conversion (FROM, TO), 0)) + + +/* Emit a conversion between the given scalar types. */ +void +emit_typecode_conversion (from, to) + enum typecode from, to; +{ + int i; + + DEDUCE_CONVERSION (from, to); + for (i = 0; i < conversion_recipe[(int) from][(int) to].nopcodes; ++i) + bc_emit_instruction (conversion_recipe[(int) from][(int) to].opcodes[i]); +} + + +/* Initialize mode_to_code_map[] */ +void +bc_init_mode_to_code_map () +{ + int mode; + + for (mode = 0; mode < MAX_MACHINE_MODE + 1; mode++) + { + signed_mode_to_code_map[mode] = + unsigned_mode_to_code_map[mode] = + LAST_AND_UNUSED_TYPECODE; + } + +#define DEF_MODEMAP(SYM, CODE, UCODE, CONST, LOAD, STORE) \ + { signed_mode_to_code_map[(int) SYM] = CODE; \ + unsigned_mode_to_code_map[(int) SYM] = UCODE; } +#include "modemap.def" +#undef DEF_MODEMAP + + /* Initialize opcode maps for const, load, and store */ + bc_init_mode_to_opcode_maps (); +} + +/* Given a machine mode return the preferred typecode. */ +enum typecode +preferred_typecode (mode, unsignedp) + enum machine_mode mode; + int unsignedp; +{ + enum typecode code = (unsignedp + ? unsigned_mode_to_code_map + : signed_mode_to_code_map) [MIN ((int) mode, + (int) MAX_MACHINE_MODE)]; + + if (code == LAST_AND_UNUSED_TYPECODE) + abort (); + + return code; +} + + +/* Expand a conversion between the given types. */ +void +bc_expand_conversion (from, to) + tree from, to; +{ + enum typecode fcode, tcode; + + fcode = preferred_typecode (TYPE_MODE (from), TREE_UNSIGNED (from)); + tcode = preferred_typecode (TYPE_MODE (to), TREE_UNSIGNED (to)); + + emit_typecode_conversion (fcode, tcode); +} + +/* Expand a conversion of the given type to a truth value. */ +void +bc_expand_truth_conversion (from) + tree from; +{ + enum typecode fcode; + + fcode = preferred_typecode (TYPE_MODE (from), TREE_UNSIGNED (from)); + emit_typecode_conversion (fcode, Tcode); +} + +/* Emit an appropriate binary operation. */ +void +bc_expand_binary_operation (optab, resulttype, arg0, arg1) + struct binary_operator optab[]; + tree resulttype, arg0, arg1; +{ + int i, besti, cost, bestcost; + enum typecode resultcode, arg0code, arg1code; + + resultcode = preferred_typecode (TYPE_MODE (resulttype), TREE_UNSIGNED (resulttype)); + arg0code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg0)), TREE_UNSIGNED (resulttype)); + arg1code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg1)), TREE_UNSIGNED (resulttype)); + + besti = -1; + bestcost = BIG_ARBITRARY_NUMBER; + + for (i = 0; optab[i].opcode != -1; ++i) + { + cost = 0; + DEDUCE_CONVERSION (arg0code, optab[i].arg0); + cost += conversion_recipe[(int) arg0code][(int) optab[i].arg0].cost; + DEDUCE_CONVERSION (arg1code, optab[i].arg1); + cost += conversion_recipe[(int) arg1code][(int) optab[i].arg1].cost; + if (cost < bestcost) + { + besti = i; + bestcost = cost; + } + } + + if (besti == -1) + abort (); + + expand_expr (arg1, 0, VOIDmode, 0); + emit_typecode_conversion (arg1code, optab[besti].arg1); + expand_expr (arg0, 0, VOIDmode, 0); + emit_typecode_conversion (arg0code, optab[besti].arg0); + bc_emit_instruction (optab[besti].opcode); + emit_typecode_conversion (optab[besti].result, resultcode); +} + +/* Emit an appropriate unary operation. */ +void +bc_expand_unary_operation (optab, resulttype, arg0) + struct unary_operator optab[]; + tree resulttype, arg0; +{ + int i, besti, cost, bestcost; + enum typecode resultcode, arg0code; + + resultcode = preferred_typecode (TYPE_MODE (resulttype), TREE_UNSIGNED (resulttype)); + arg0code = preferred_typecode (TYPE_MODE (TREE_TYPE (arg0)), TREE_UNSIGNED (TREE_TYPE (arg0))); + + besti = -1; + bestcost = BIG_ARBITRARY_NUMBER; + + for (i = 0; optab[i].opcode != -1; ++i) + { + DEDUCE_CONVERSION (arg0code, optab[i].arg0); + cost = conversion_recipe[(int) arg0code][(int) optab[i].arg0].cost; + if (cost < bestcost) + { + besti = i; + bestcost = cost; + } + } + + if (besti == -1) + abort (); + + expand_expr (arg0, 0, VOIDmode, 0); + emit_typecode_conversion (arg0code, optab[besti].arg0); + bc_emit_instruction (optab[besti].opcode); + emit_typecode_conversion (optab[besti].result, resultcode); +} + + +/* Emit an appropriate increment. */ +void +bc_expand_increment (optab, type) + struct increment_operator optab[]; + tree type; +{ + enum typecode code; + int i; + + code = preferred_typecode (TYPE_MODE (type), TREE_UNSIGNED (type)); + for (i = 0; (int) optab[i].opcode >= 0; ++i) + if (code == optab[i].arg) + { + bc_emit_instruction (optab[i].opcode); + return; + } + abort (); +} |