summaryrefslogtreecommitdiffstats
path: root/contrib/gcc/bc-optab.c
diff options
context:
space:
mode:
Diffstat (limited to 'contrib/gcc/bc-optab.c')
-rw-r--r--contrib/gcc/bc-optab.c789
1 files changed, 0 insertions, 789 deletions
diff --git a/contrib/gcc/bc-optab.c b/contrib/gcc/bc-optab.c
deleted file mode 100644
index b7ff486..0000000
--- a/contrib/gcc/bc-optab.c
+++ /dev/null
@@ -1,789 +0,0 @@
-/* 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, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, 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 ();
-}
OpenPOWER on IntegriCloud