/* Bytecode conversion definitions for GNU C-compiler.   Copyright (C) 1993, 1994, 1997 Free Software Foundation, Inc.This file is part of GNU CC.GNU CC is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe 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 ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See theGNU General Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU CC; see the file COPYING.  If not, write tothe Free Software Foundation, 59 Temple Place - Suite 330,Boston, MA 02111-1307, USA.  */#include "config.h"#include <stdio.h>#ifdef HAVE_STDLIB_H#include <stdlib.h>#endif#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 freeextern char *xmalloc ();/* 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;};