a4cd5630b0
non-i386, non-unix, and generatable files have been trimmed, but can easily be added in later if needed. gcc-2.7.2.1 will follow shortly, it's a very small delta to this and it's handy to have both available for reference for such little cost. The freebsd-specific changes will then be committed, and once the dust has settled, the bmakefiles will be committed to use this code.
790 lines
22 KiB
C
790 lines
22 KiB
C
/* 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 ();
|
|
}
|