More bytecode stuff going away.

From-SVN: r17433

diff --git a/gcc/bytecode.def b/gcc/bytecode.def
deleted file mode 100644 (file)
index 5b24df7..0000000
--- a/gcc/bytecode.def
+++ /dev/null
@@ -1,322 +0,0 @@
-# -*- C -*-
-# bytecode.def - definitions of bytecodes for the stack machine.
-
-# The production of the bytecode interpreter and compiler is
-# heavily automated by using this file creatively.
-
-# Various elementary data types are understood by the bytecode interpreter.
-# Q[IU] - quarter word (byte) signed and unsigned integers (char).
-# H[IU] - half word signed and unsigned integers (short int, maybe int).
-# S[IU] - single word signed and unsigned integers (maybe int, long int).
-# D[IU] - double word signed and unsigned integers (long long int).
-# SF - single precision floating point (float).
-# DF - double precision floating point (double).
-# XF - extended precision floating point (long double).
-# P - pointer type for address arithmetic and other purposes.
-
-# The bytecode specification consists of a series of define_operator
-# forms, that are parsed by preprocessors to automatically build
-# various switch statements.
-#      define_operator(name,
-#                      <C prototype code for implementing the operator>,
-#                      <list of variations>)
-# The <C prototype> is self explanatory.
-# The <list of variations> consists of a (parenthesized list) of
-# variation items, each of which is in itself a list.  A variation
-# item consists of a name suffix, the types of the input arguments
-# expected on the stack (shallowest item first) and (optionally) the
-# types of the output arguments (similarly ordered).  Finally, the
-# types of the literal arguments (if any) may appear.
-
-# Substitution in the C prototype code is as follows:
-# Substitution happens only after a dollar sign.  To get a literal
-# dollar sign (why would you ever want one anyway?) use $$.
-# $R1 means "result 1" $TR1 means "type name of result one"
-# $S1 means "source 1" and similarly with $TS1.
-# $L1 means "literal (inline) argument 1" and $TL1 means type thereof.
-#
-
-# Notice that the number following $R doesn't affect the push order;
-# it's used only for clarity and orthogonality, although it's checked
-# to make sure it doesn't exceed the number of outputs. A $R reference
-# results in a push, and represents the result lvalue. E.g.
-
-#      $R1 = 2\, $R2 = 17
-# will expand to:
-#      INTERP_PUSH($TR1) = 2, INTERP_PUSH($TR2) = 17
-#
-
-# Opcode 0 should never happen.
-define_operator(neverneverland, abort\(\), (()))
-
-# Stack manipulations.
-define_operator(drop, 0, ((, (SI))))
-define_operator(duplicate, 0, ((, (SI), (SI, SI))))
-define_operator(over, 0, ((, (SI), (SI, SI))))
-
-# Adjust stack pointer
-
-define_operator(setstack, 0, ((SI,,,(SI))))
-define_operator(adjstack, 0, ((SI,,,(SI))))
-
-# Constants, loads, and stores.
-define_operator(const,
-               $R1 = $L1,
-               ((QI,, (QI), (QI)), (HI,, (HI), (HI)),
-                (SI,, (SI), (SI)), (DI,, (DI), (DI)),
-                (SF,, (SF), (SF)), (DF,, (DF), (DF)),
-                (XF,, (XF), (XF)), (P,, (P), (P))))
-define_operator(load,
-               $R1 = *\($TR1 *\) $S1,
-               ((QI, (P), (QI)), (HI, (P), (HI)),
-                (SI, (P), (SI)), (DI, (P), (DI)),
-                (SF, (P), (SF)), (DF, (P), (DF)),
-                (XF, (P), (XF)), (P, (P), (P))))
-define_operator(store,
-               *\($TS2 *\) $S1 = $S2,
-               ((QI, (P, QI)), (HI, (P, HI)),
-                (SI, (P, SI)), (DI, (P, DI)),
-                (SF, (P, SF)), (DF, (P, DF)),
-                (XF, (P, XF)), (P, (P, P)),
-                (BLK, (SI, BLK, BLK))))
-
-# Clear memory block
-
-define_operator(clear, $S1 + $S2, ((BLK, (SI, BLK))))
-
-
-# Advance pointer by SI constant
-
-define_operator(addconst, $R1 = $S1, ((PSI, (P), (P), (SI))))
-
-
-# newlocalSI is used for creating variable-sized storage during function
-# initialization.
-
-# Create local space, return pointer to block
-
-define_operator(newlocal, $R1 = $S1, ((SI, (SI), (P))))
-
-
-# Push the address of a local variable.
-define_operator(local, $R1 = locals + $L1, ((P,, (P), (SI))))
-
-# Push the address of an argument variable.
-define_operator(arg, $R1 = args + $L1, ((P,, (P), (SI))))
-
-# Arithmetic conversions.
-define_operator(convert,
-               $R1 = \($TR1\) $S1,
-               (# Signed integral promotions (sign extensions).
-                (QIHI, (QI), (HI)), (HISI, (HI), (SI)), (SIDI, (SI), (DI)),
-                (QISI, (QI), (SI)),
-                # Unsigned integral promotions (zero extensions).
-                (QUHU, (QU), (HU)), (HUSU, (HU), (SU)), (SUDU, (SU), (DU)),
-                (QUSU, (QU), (SU)),
-                # Floating promotions.
-                (SFDF, (SF), (DF)), (DFXF, (DF), (XF)),
-                # Integral truncation.
-                (HIQI, (HI), (QI)), (SIHI, (SI), (HI)), (DISI, (DI), (SI)),
-                (SIQI, (SI), (QI)),
-                 # Unsigned truncation.
-                (SUQU, (SU), (QU)),
-                # Floating truncation.
-                (DFSF, (DF), (SF)), (XFDF, (XF), (DF)),
-                # Integral conversions to floating types.
-                (SISF, (SI), (SF)), (SIDF, (SI), (DF)), (SIXF, (SI), (XF)),
-                (SUSF, (SU), (SF)), (SUDF, (SU), (DF)), (SUXF, (SU), (XF)),
-                (DISF, (DI), (SF)), (DIDF, (DI), (DF)), (DIXF, (DI), (XF)),
-                (DUSF, (DU), (SF)), (DUDF, (DU), (DF)), (DUXF, (DU), (XF)),
-                # Floating conversions to integral types.
-                (SFSI, (SF), (SI)), (DFSI, (DF), (SI)), (XFSI, (XF), (SI)),
-                (SFSU, (SF), (SU)), (DFSU, (DF), (SU)), (XFSU, (XF), (SU)),
-                (SFDI, (SF), (DI)), (DFDI, (DF), (DI)), (XFDI, (XF), (DI)),
-                (SFDU, (SF), (DU)), (DFDU, (DF), (DU)), (XFDU, (XF), (DU)),
-                # Pointer/integer conversions.
-                (PSI, (P), (SI)), (SIP, (SI), (P))))
-
-# Truth value conversion.  These are necessary because conversions of, e.g.,
-# floating types to integers may not function correctly for large values.
-define_operator(convert,
-               $R1 = !!$S1,
-               ((SIT, (SI), (T)), (DIT, (DI), (T)),
-                (SFT, (SF), (T)), (DFT, (DF), (T)),
-                (XFT, (XF), (T)), (PT, (P), (T))))
-
-# Bit field load/store.
-
-# Load and zero-extend bitfield
-
-define_operator(zxload, $R1 = $S1, ((BI, (SU, SU, P), (SU))))
-
-# Load and sign-extend bitfield
-
-define_operator(sxload, $R1 = $S1, ((BI, (SU, SU, P), (SI))))
-
-# Store integer in bitfield
-
-define_operator(sstore, $R1 = $S1, ((BI, (SU, SU, P, SI))))
-
-
-# Binary operations.
-define_operator(add,
-               $R1 = $S1 + $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
-                (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
-                (XF, (XF, XF), (XF)),
-                (PSI, (P, SI), (P))))
-define_operator(sub,
-               $R1 = $S1 - $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
-                (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
-                (XF, (XF, XF), (XF)),
-                (PP, (P, P), (SI))))
-define_operator(mul,
-               $R1 = $S1 * $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
-                (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU)),
-                (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
-                (XF, (XF, XF), (XF))))
-define_operator(div,
-               $R1 = $S1 / $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
-                (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU)),
-                (SF, (SF, SF), (SF)), (DF, (DF, DF), (DF)),
-                (XF, (XF, XF), (XF))))
-define_operator(mod,
-               $R1 = $S1 % $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI)),
-                (SU, (SU, SU), (SU)), (DU, (DU, DU), (DU))))
-define_operator(and,
-               $R1 = $S1 & $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
-define_operator(ior,
-               $R1 = $S1 | $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
-define_operator(xor,
-               $R1 = $S1 ^ $S2,
-               ((SI, (SI, SI), (SI)), (DI, (DI, DI), (DI))))
-define_operator(lshift,
-               $R1 = $S1 << $S2,
-               ((SI, (SI, SI), (SI)), (SU, (SU, SI), (SU)),
-                (DI, (DI, SI), (DI)), (DU, (DU, SI), (DU))))
-define_operator(rshift,
-               $R1 = $S1 >> $S2,
-               ((SI, (SI, SI), (SI)), (SU, (SU, SI), (SU)),
-                (DI, (DI, SI), (DI)), (DU, (DU, SI), (DU))))
-define_operator(lt,
-               $R1 = $S1 < $S2,
-               ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
-                (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-define_operator(le,
-               $R1 = $S1 <= $S2,
-               ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
-                (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-define_operator(ge,
-               $R1 = $S1 >= $S2,
-               ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
-                (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-define_operator(gt,
-               $R1 = $S1 > $S2,
-               ((SI, (SI, SI), (T)), (SU, (SU, SU), (T)),
-                (DI, (DI, DI), (T)), (DU, (DU, DU), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-define_operator(eq,
-               $R1 = $S1 == $S2,
-               ((SI, (SI, SI), (T)), (DI, (DI, DI), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-define_operator(ne,
-               $R1 = $S1 != $S2,
-               ((SI, (SI, SI), (T)), (DI, (DI, DI), (T)),
-                (SF, (SF, SF), (T)), (DF, (DF, DF), (T)),
-                (XF, (XF, XF), (T)), (P, (P, P), (T))))
-
-# Unary operations.
-define_operator(neg,
-               $R1 = -$S1,
-               ((SI, (SI), (SI)), (DI, (DI), (DI)),
-                (SF, (SF), (SF)), (DF, (DF), (DF)),
-                (XF, (XF), (XF))))
-define_operator(not,
-               $R1 = ~$S1,
-               ((SI, (SI), (SI)), (DI, (DI), (DI))))
-define_operator(not,
-               $R1 = !$S1,
-               ((T, (SI), (SI))))
-
-# Increment operations.
-define_operator(predec,
-               $R1 = *\($TR1 *\) $S1 -= $S2,
-               ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
-                (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
-                (P, (P, SI), (P)), (SF, (P, SF), (SF)),
-                (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
-                (BI, (SU, SU, P, SI), (SI))))
-
-define_operator(preinc,
-               $R1 = *\($TR1 *\) $S1 += $S2,
-               ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
-                (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
-                (P, (P, SI), (P)), (SF, (P, SF), (SF)),
-                (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
-                (BI, (SU, SU, P, SI), (SI))))
-
-define_operator(postdec,
-               $R1 = *\($TR1 *\) $S1\, *\($TR1 *\) $S1 -= $S2,
-               ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
-                (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
-                (P, (P, SI), (P)), (SF, (P, SF), (SF)),
-                (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
-                (BI, (SU, SU, P, SI), (SI))))
-
-define_operator(postinc,
-               $R1 = *\($TR1 *\) $S1\, *\($TR1 *\) $S1 += $S2,
-               ((QI, (P, QI), (QI)), (HI, (P, HI), (HI)),
-                (SI, (P, SI), (SI)), (DI, (P, DI), (DI)),
-                (P, (P, SI), (P)), (SF, (P, SF), (SF)),
-                (DF, (P, DF), (DF)), (XF, (P, XF), (XF)),
-                (BI, (SU, SU, P, SI), (SI))))
-
-# Jumps.
-define_operator(xjumpif, if \($S1\) pc = code->pc0 + $L1, ((, (T),, (SI))))
-define_operator(xjumpifnot, if \(! $S1\) pc = code->pc0 + $L1, ((, (T),, (SI))))
-define_operator(jump, pc = code->pc0 + $L1, ((,,,(SI))))
-
-# This is for GCC2. It jumps to the address on the stack.
-define_operator(jump, pc = \(void *\) $S1, ((P,,)))
-
-# Switches.  In order to (eventually) support ranges we provide four different
-# varieties of switches.  Arguments are the switch index from the stack, the
-# bytecode offset of the switch table, the size of the switch table, and 
-# the default label.
-define_operator(caseSI, CASESI\($S1\, $L1\, $L2\, $L3\), ((, (SI),, (SI, SI, SI))))
-define_operator(caseSU, CASESU\($S1\, $L1\, $L2\, $L3\), ((, (SU),, (SI, SI, SI))))
-define_operator(caseDI, CASEDI\($S1\, $L1\, $L2\, $L3\), ((, (DI),, (SI, SI, SI))))
-define_operator(caseDU, CASEDU\($S1\, $L1\, $L2\, $L3\), ((, (DU),, (SI, SI, SI))))
-
-# Procedure call.
-# Stack arguments are (deepest first):
-#      procedure arguments in reverse order.
-#      pointer to the place to hold the return value.
-#      address of the call description vector.
-#      pointer to the procedure to be called.
-define_operator(call, CALL\($S1\, $S2\, $S3\, sp\), ((, (P, P, P))))
-
-# Procedure return.
-# Pushes on interpreter stack:
-#       value of retptr (pointer to return value storage slot)
-define_operator(return, $R1 = retptr, ((P,,(P))))
-
-# Really return.
-define_operator(ret, return, (()))
-
-# Print an obnoxious line number.
-define_operator(linenote, fprintf\(stderr\, "%d\\n"\, $L1\), ((,,,(SI))))

diff --git a/gcc/bytecode.h b/gcc/bytecode.h
deleted file mode 100644 (file)
index a029f93..0000000
--- a/gcc/bytecode.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* Bytecode definitions for GNU C-compiler.
-   Copyright (C) 1993, 1994, 1996 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.  */
-
-
-extern int output_bytecode;
-extern int stack_depth;
-extern int max_stack_depth;
-
-/* Emit DI constant according to target machine word ordering */
-
-#define bc_emit_bytecode_DI_const(CST)                                 \
-{ int opcode;                                                  \
-  opcode = (WORDS_BIG_ENDIAN                                   \
-           ? TREE_INT_CST_HIGH (CST)                           \
-           : TREE_INT_CST_LOW (CST));                          \
-  bc_emit_bytecode_const ((char *) &opcode, sizeof opcode);    \
-  opcode = (WORDS_BIG_ENDIAN                                   \
-           ? TREE_INT_CST_LOW (CST)                            \
-           : TREE_INT_CST_HIGH (CST));                         \
-  bc_emit_bytecode_const ((char *) &opcode, sizeof opcode);    \
-}
-
-extern void bc_expand_expr ();
-extern void bc_output_data_constructor ();
-extern void bc_store_field ();
-extern void bc_load_bit_field ();
-extern void bc_store_bit_field ();
-extern void bc_push_offset_and_size ();
-extern void bc_init_mode_to_code_map ();
-
-/* These are just stubs, so the compiler will compile for targets
-   that aren't yet supported by the bytecode generator. */
-
-#ifndef TARGET_SUPPORTS_BYTECODE
-
-#define MACHINE_SEG_ALIGN 1
-#define INT_ALIGN 1
-#define PTR_ALIGN 1
-#define NAMES_HAVE_UNDERSCORES
-#define BC_NOP   (0)
-#define BC_GLOBALIZE_LABEL(FP, NAME) BC_NOP
-#define BC_OUTPUT_COMMON(FP, NAME, SIZE, ROUNDED) BC_NOP
-#define BC_OUTPUT_BSS(FP, NAME, SIZE, ROUNDED)    BC_NOP
-#define BC_OUTPUT_LOCAL(FP, NAME, SIZE, ROUNDED)  BC_NOP
-#define BC_OUTPUT_ALIGN(FP, ALIGN)   BC_NOP
-#define BC_OUTPUT_LABEL(FP, NAME)    BC_NOP
-#define BC_OUTPUT_SKIP(FP, SIZE)     BC_NOP
-#define BC_OUTPUT_LABELREF(FP, NAME) BC_NOP
-#define BC_OUTPUT_FLOAT(FP, VAL)     BC_NOP
-#define BC_OUTPUT_DOUBLE(FP, VAL)    BC_NOP
-#define BC_OUTPUT_BYTE(FP, VAL)      BC_NOP
-#define BC_OUTPUT_FILE ASM_OUTPUT_FILE
-#define BC_OUTPUT_ASCII ASM_OUTPUT_ASCII
-#define BC_OUTPUT_IDENT ASM_OUTPUT_IDENT
-#define BCXSTR(RTX)  ((RTX)->bc_label)
-#define BC_WRITE_FILE(FP)            BC_NOP
-#define BC_WRITE_SEGSYM(SEGSYM, FP)  BC_NOP
-#define BC_WRITE_RELOC_ENTRY(SEGRELOC, FP, OFFSET) BC_NOP
-#define BC_START_BYTECODE_LINE(FP)   BC_NOP
-#define BC_WRITE_BYTECODE(SEP, VAL, FP) BC_NOP
-#define BC_WRITE_RTL(R, FP)          BC_NOP
-#define BC_EMIT_TRAMPOLINE(TRAMPSEG, CALLINFO) BC_NOP
-#define VALIDATE_STACK               BC_NOP
-
-#endif /* !TARGET_SUPPORTS_BYTECODE */

diff --git a/gcc/bytetypes.h b/gcc/bytetypes.h
deleted file mode 100644 (file)
index f915669..0000000
--- a/gcc/bytetypes.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/* These should come from genemit */
-
-/* Use __signed__ in case compiling with -traditional.  */
-
-typedef __signed__ char QItype;
-typedef unsigned char QUtype;
-typedef __signed__ short int HItype;
-typedef unsigned short int HUtype;
-typedef __signed__ long int SItype;
-typedef unsigned long int SUtype;
-typedef __signed__ long long int DItype;
-typedef unsigned long long int DUtype;
-typedef float SFtype;
-typedef double DFtype;
-typedef long double XFtype;
-typedef char *Ptype;
-typedef int Ttype;
-
-
-typedef union stacktype
-{
-  QItype QIval;
-  QUtype QUval;
-  HItype HIval;
-  HUtype HUval;
-  SItype SIval;
-  SUtype SUval;
-  DItype DIval;
-  DUtype DUval;
-  SFtype SFval;
-  DFtype DFval;
-  XFtype XFval;
-  Ptype Pval;
-  Ttype Tval;
-} stacktype;