Changes for GCC version 2.6.1 from version 2.6.0. Changes in files you can reconstruct with Bison, etags, makeinfo, and TeX have been omitted. Some of these files are updated just by building the compiler. You can update rest of these files by executing this command make TAGS info dvi -f Makefile.in in the directory of GCC sources, provided the necessary tools (etags, makeinfo, TeX and texi2dvi) are installed. Before applying these diffs, go to the directory gcc-2.6.0 and execute the following commands: rm README.IRIX5 rm config/1750a/m1750.inc rm config/sparc/t-sunos4 rm cp/lib-except.c rm gplus.perf mkdir config/dsp16xx mkdir config/msdos mkdir config/pdp11 mkdir config/winnt Then use the command patch -p1 feeding it the following diffs as input. Then rename the directory to gcc-2.6.1. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ChangeLog gcc-2.6.1/ChangeLog *** gcc-2.6.0/ChangeLog Thu Jul 14 09:43:11 1994 --- gcc-2.6.1/ChangeLog Tue Nov 1 21:32:40 1994 *************** *** 1,2 **** --- 1,2469 ---- + Tue Nov 1 19:19:41 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * Version 2.6.1 released. + + Tue Nov 1 18:51:00 1994 Torbjorn Granlund (tege@cygnus.com) + + * pa.md (add_high_const): Add missing mode for PLUS. + + Tue Nov 1 18:39:53 1994 Stephen L Moshier (moshier@world.std.com) + + * cse.c (simplify_unary_operation, case TRUNCATE): Set LV and HV. + + Tue Nov 1 18:36:23 1994 Pat Rankin (rankin@eql.caltech.edu) + + * vax.c (struct extern_list): Put code back outside of #ifdef VMS. + (vms_check_external, vms_flush_pending_externals): Likewise. + + Mon Oct 31 16:18:12 1994 Michael Meissner + + * i386/i386.md (movsf, movdf, movxf): If we are moving floating + point constants to a non-memory location that aren't 0 or 1, + assume we need the pic register if -fpic. + + Mon Oct 31 13:26:45 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * sparc.h (GO_IF_LEGITIMATE_ADDRESS): Don't allow TFmode LO_SUM. + * sparc.md (movtf+3): Disable pattern. + + Mon Oct 31 08:11:47 1994 Doug Evans + + * expr.c (expand_expr, COND_EXPR case): Don't use original target as + a temp if it's a volatile mem ref. Finish previous patch (don't + expand "X ? A & 1 : A" as "A & (X != 0)"). + + Mon Oct 31 08:07:09 1994 Pat Rankin (rankin@eql.caltech.edu) + + * vax.c: Include tree.h #ifdef VMS. + (struct extern_list): Move inside #ifdef VMS; add SIZE and IN_CONST + fields; make `extern_head' static; add second list head. + (vms_check_external): Move inside #ifdef VMS; give new args; maintain + list of both pending external symbols and previously defined ones. + (vms_flush_pending_externals): New function. + * vax/vms.h (ASM_GLOBALIZE_LABEL): Pass new args to vms_check_external. + (ASM_OUTPUT_EXTERNAL): Just call vms_check_external. + (ASM_{,FINISH_}DECLARE_OBJECT_NAME, ASM_FILE_END): Define. + + Mon Oct 31 08:00:59 1994 Michael Gschwind (mike@vlsivie.tuwien.ac.at) + + * pdp11.h (TARGET_SWITCHES): Add -split and -no-split. + (TARGET_SPLIT, TARGET_NOSPLIT): New macros. + (TRAMPOLINE_TEMPLATE, INITIALIZE_TRAMPOLINE): Abort if -split. + + Mon Oct 31 07:53:34 1994 Warner Losh + + * i386/x-freebsd (CLIB): Add definition. + + Mon Oct 31 07:49:17 1994 Jeffrey A Law + + * reorg.c (mark_set_resources): Properly handle SUBREGs. + + Mon Oct 31 07:24:32 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expr.c (expand_expr, case COMPONENT_REF): Don't extract + field from a CONSTRUCTOR if it already has a TREE_CST_RTL. + (expand_expr, case ADDR_EXPR): Call mark_temp_addr_taken + on the temporary made when operand needs to be stored into memory. + * function.c (preserve_temp_slots): Preserve anything whose + address was taken when X is zero. + + Sun Oct 30 15:11:51 1994 Richard Kenner + + * msdos/top.sed, i386/config-nt.sed: Update version to 2.6.1. + * pa/t-pa-hpux: Add missing newline at end. + + Sat Oct 29 21:16:29 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * emit-rtl.c (operand_subword): Fix typo: HOST_BITS_PER_INT + should be HOST_BITS_PER_WIDE_INT. + + Fri Oct 28 19:13:13 1994 Andrew McCallum (mccallum@vein.cs.rochester.edu) + + * objc/misc.c (__objc_xcalloc): Use calloc instead malloc/bzero. + + Fri Oct 28 19:07:53 1994 Michael Gschwind (mike@vlsivie.tuwien.ac.at) + + * pdp11.h (TRAMPOLINE_SIZE): Install real implementation. + (INITIALIZE_TRAMPOLINE, TRAMPOLINE_TEMPLATE): Likewise. + + Fri Oct 28 19:01:27 1994 Craig Burley (burley@gnu.ai.mit.edu) + + * Makefile.in (stage?-start): Add semicolon between fi and done. + + Fri Oct 28 17:12:26 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (cse_insn): Don't record a DEST if paradoxical SUBREG + and SRC is a SIGN_EXTEND or ZERO_EXTEND. + + * alpha.md (reload_outqi): Correctly handle scratch assignments + for unaligned case when ADDR is a REG. + + Fri Oct 28 07:55:40 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.md (adddi3): Fixup code in case operands[0] is equal + to operands[2]. + + Thu Oct 27 18:58:39 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reload1.c (count_possible_groups): Fix typo in setting + counted_for_groups. + + Thu Oct 27 15:30:41 1994 Per Bothner + + * c-typeck.c (process_init_element): In the case of + [LO .. HI] = VALUE, use save_expr to only evaluate VALUE once. + + Thu Oct 27 15:15:25 1994 Torbjorn Granlund (tege@rtl.cygnus.com) + + * gcc.c (process_command): Don't forget to split -Wl arguments at + commas. + + * gcc.c (process_command): Handle -Wl, and -Xlinker similar to -l, + i.e., preserve their order with respect to linker input files. + + Thu Oct 27 13:11:16 1994 Douglas Rupp (drupp@cs.washington.edu) + + * configure (i[345]86-*-winnt3*): Allow any version 3.x. + Don't use a t-winnt file and move x-winnt to config/i386. + * i386/x-winnt: Build ld-winnt.exe only on host. + * winnt/t-winnt: Deleted. + + Thu Oct 27 13:05:16 1994 Mike Collison (collison@chianti.sw.stratus.com) + + * reload.c (debug_reload): New function to print reload info + set up by find_reloads. + + Wed Oct 26 18:27:03 1994 David Mosberger-Tang + + * alpha.h (FUNCTION_PROFILER): Use $28 instead of $27. + (LINK_SPEC): Pass -pg to linker. + (LIB_SPEC): Link in -lprof1 with -pg, not -lprof2. + (STARTFILE_SPEC): USe gcrt0.o if -pg, not mcrt0.o. + + Wed Oct 26 18:22:34 1994 Doug Evans (dje@cygnus.com) + + * expr.c (expand_expr, COND_EXPR case): Don't expand + "X ? A & 1 : A" as "A & (X != 0)". + + Wed Oct 26 18:06:52 1994 Douglas Rupp (drupp@cs.washington.edu) + + * winnt/ld.c (expand_lib, main): Fix off-by-one bugs in several + calls to malloc. + + Wed Oct 26 22:00:09 1994 Richard Kenner + + * winnt/t-winnt: Remove some spurious blank lines. + + Wed Oct 26 14:14:39 1994 Michael Meissner (meissner@osf.org) + + * i386/osfrose.h (REAL_NM_FILE_NAME): Use /usr/ccs/gcc/bfd-nm + instead of /usr/ccs/bin/nm, since the GNU nm does not output stab + symbols by default. + + Wed Oct 26 13:47:06 1994 Michael Gschwind (mike@vlsivie.tuwien.ac.at) + + * config.sub (pdp11): New machine name. + * configure (pdp11-*-*): New configuration. + * pdp11.c, pdp11.h, pdp11.md, xm-pdp11.h: New files. + + Wed Oct 26 07:33:40 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * flow.c (find_basic_blocks): Ensure each live basic block is + actually reachable. + (life_analysis): Clean up handling of basic_block_drops_in. + + Tue Oct 25 18:40:12 1994 Paul Eggert + + * cccp.c (rescan): ".." no longer terminates a preprocessing + number, since that's incompatible with the C standard. + + Tue Oct 25 16:16:40 1994 Michael Dobson (dobson@info.usuhs.mil) + + * we32k.h (CPP_PREDEFINES): Define u3b2, not u3b. + + Tue Oct 25 16:15:27 1994 Jim Wilson (wilson@cygnus.com) + + * reorg.c (fill_slots_from_thread): Update THREAD if it is split. + + Mon Oct 24 00:12:46 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * toplev.c (lang_options): Add -f{no-,}access-control. + + Mon Oct 24 06:14:03 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * arm/arm.md (peepholes for call followed by branch): Disable. + + Sun Oct 23 08:54:27 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * arm/x-riscix (INSTALL): Invoke install.sh with -c flag. + + Fri Oct 21 00:42:08 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * Makefile.in (LIB2FUNCS): Add _pure. + + * libgcc2.c (__pure_virtual): New function to go into vtable + entries for pure virtual methods instead of abort. + + Thu Oct 20 18:40:36 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * alpha.md (define_split comparison op with power of two minus 1): + Fix typo. + + Thu Oct 20 13:14:24 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * collect2.c (add_to_list): Check for duplicates. + + * alpha/alpha.h (LINK_SPEC): Pass -shared through; don't + pass -init __main if -shared. + (STARTFILE_SPEC): Wrap startfiles in %{!shared:}. + (INIT_NAME_FORMAT): Define. + (FINI_NAME_FORMAT): Define. + * alpha/osf12.h (LINK_SPEC): Ditto. + * alpha/gdb-osf12.h: #include osf12.h instead of alpha.h + + * gcc.c (STARTFILE_SPEC): Wrap startfiles in %{!shared:}. + + Thu Oct 20 16:07:46 1994 Jim Wilson (wilson@cygnus.com) + + * unroll.c (loop_iterations): Move all failure exits after the + computation of final_value. + + * mips.md (movdf_internal2+1): Disable when TARGET_64BIT. + + * i960.c (VARARGS_STDARG_FUNCTION): New macro. + (i960_function_name_declare, output_function_profiler, + i960_function_epilogue, i960_output_call_insn, i960_output_ret_insn, + i960_reg_parm_stack_space): Use it. + (compute_frame_size): Don't use current_function_pretend_args_size. + (i960_function_arg_advance, i960_function_arg): Don't use parameter + named. + (i960_setup_incoming_varargs): No need to adjust first_reg_offset + after setting it. Don't save last named argument to stack. + Don't set pretend_size. + * i960.h (SIGNED_CHAR_SPEC): Use #if instead of ?:. + * va-i960.h (va_start): Use builtin_arts_info instead of + builtin_next_arg. + + * cse.c (merge_equiv_classes, cse_insn): Call rehash_using_reg + after insert_regs. + (canon_hash): Don't use qty_const to compute hash code for a + register. + + Thu Oct 20 09:41:51 1994 Richard Kenner (kenner@vlsi1.ultra.nyu) + + * stor-layout.c (variable_size): Return SIZE if it contains + a PLACEHOLDER_EXPR. + + Tue Oct 18 19:51:24 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * collect2.c (main): Check REAL_*_FILE_NAME first. + + Wed Oct 19 15:55:15 1994 David J. MacKenzie + + * config.sub: Add licensing exception for Autoconf. + + Wed Oct 19 06:43:46 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.h (FUNCTION_BLOCK_PROFILER): Don't bother preserving + eax if -fpic, since it is a call clobbered register anyway. Fix -fpic + code so that it is correct. + + Tue Oct 18 18:00:23 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.h (FUNCTION_BLOCK_PROFILER, BLOCK_PROFILER): Move + macros here from osfrose, netbsd, and freebsd ports. Remove + assumptions that the assembler is gas. Rewrite and fix the + instructions produced with -fpic. + + * i386/osfrose.h (FUNCTION_BLOCK_PROFILER, BLOCK_PROFILER): Delete. + * i386/freebsd.h (FUNCTION_BLOCK_PROFILER, BLOCK_PROFILER): Delete. + * i386/netbsd-i386.h (FUNCTION_BLOCK_PROFILER, BLOCK_PROFILER): + Delete. + + Tue Oct 18 20:27:29 1994 Doug Evans (dje@cygnus.com) + + * sparc.h (FRAME_POINTER_REQUIRED): Require frame pointer if + non-leaf flat function. + * sparc.c (sparc_frame_info): Combine members gp_sp_offset and + fp_sp_offset into reg_offset. All uses changed. + (RETURN_ADDR_REGNUM): New macro. + (RETURN_ADDR_MASK, FRAME_POINTER_MASK): New macros. + (sparc_flat_compute_frame_info): Rename local mask to gmask. + Only ensure reg save area is 8 byte aligned if necessary. + (sparc_flat_save_restore): New arguments base_reg, offset, gmask, + and fmask. All callers changed. No longer use %g2 to save regs + in big stack frames. + (sparc_flat_output_function_prologue): Delete local tsize. + Reorder storing of previous frame pointer and return address reg to + make it easier for gdb to identify flat functions. Decrement %sp + twice when saving call-saved regs in big frames. + Count fp regs as 4 bytes in assembler comment. + (sparc_flat_output_function_epilogue): Likewise when restoring + call-saved regs. + + Tue Oct 18 19:33:55 1994 Mike Collison (collison@sw.stratus.com) + + * reload1.c (reload): Correctly compute group additional needs when + the return register cannot be used as a spill register. + + Tue Oct 18 16:17:26 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * mips.h (ASM_SPEC): Pass -mcpu= option to GNU as. + + Tue Oct 18 08:39:49 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * flow.c (propagate_block): Call mark_used_regs to show global regs + used by call. + * combine.c (can_combine_p): Don't combine into CALL_INSN where + DEST is a global reg. + + * c-decl.c (start_function): Save immediate_size_expand + and initialize it to zero in case nested function. + + * pa.c (non_hard_reg_operand): New function. + * pa.md (reload_{in,out}*): Replace general_operand with + non_hard_reg_operand. + + Fri Oct 14 18:35:30 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * gcc.c (default_compilers): Treat files with an extension of .c++ + as C++ code. + + Mon Oct 17 19:21:57 1994 David Edelsohn (edelsohn@npac.syr.edu) + + * configure (rs6000-ibm-aix4.1*): New configuration. + * rs6000/aix41.h: New file. + + Mon Oct 17 19:15:14 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * va-mips.h (va_arg): Add little endian mips3 support. + + * sparc.h (RETURN_IN_MEMORY): Return true for TCmode values. + + * README.IRIX5: Delete. + * install.texi: Update Irix 5 debugging info. + + * mips.c (function_prologue): Only emit line number when SDB_DEBUG. + + * configure: Delete new argument, --noguess. Default build from + host if host specified, otherwise guess build. Fix typo in + setting build from host. + + Mon Oct 17 15:54:56 1994 Per Bothner + + * calls.c (expand_call, emit_library_call, emit_library_call_value): + Allways adjust current_function_outgoing_args_size, even #ifndef + ACCUMULATE_OUTGOING_ARGS. (Useful for stack overflow checking.) + * function.c (current_function_outgoing_args_size): Update comment. + + Mon Oct 17 18:49:01 1994 Paul Eggert + + * cccp.c (rescan): Preserve newlines after macro names at the top level + since this is more likely to do the right thing with line numbers. + + Mon Oct 17 11:31:42 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reload1.c (gen_reload): Renamed from gen_input_reload. + (emit_reload_insns): Delete SECONDARY_MEM_NEEDED case for input + reloads that can't happen and doesn't work. + Fix errors in use of reload_outxx insns. + Simplify output reload code by using gen_reload. + * reload.h (gen_reload): Renamed from gen_input_reload. + + Mon Oct 17 09:26:57 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * unroll.c (copy_loop_body, case JUMP_INSN): Don't abort if invert_exp + fails. Instead, redirect the jump around an unconditional branch. + + Sun Oct 16 05:02:23 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * emit-rtl.c (add_insn_{before,after}): Don't abort because AFTER was + deleted when not optimizing. + + Fri Oct 14 19:26:28 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * pa.c (emit_move_sequence): Handle secondary reload when loading + a constant into SAR. + + Fri Oct 14 10:29:31 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * fixincludes: Fix X11/Intrinsic.h for RISCiX to remove ___type from + XtOffset. + Add all files that receive special attention to REQUIRED, so that + dependent copies are done if necessary. + + * getpwd.c: Always use getwd if HAVE_GETWD is defined. + * arm/xm-arm.h: Define HAVE_GETWD. + + * arm/x-riscix, arm/t-riscix: New files + * configure (arm-*-riscix*): Use them. + + Thu Oct 13 17:12:27 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * i960.md (call, call_internal, call_value, call_value_internal): + Use memory_operand not general_operand. + + * optabs.c (expand_fix): Correct typo with FIX/UNSIGNED_FIX + REG_NOTES. + + Thu Oct 13 10:44:32 1994 Ian Lance Taylor (ian@cygnus.com) + + * genattrtab.c (optimize_attrs): Don't do anything if + num_insn_ents is zero. + + Wed Oct 12 19:06:48 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * mips/mips.c (mips_expand_prologue): Handle types that need + constructing. Rename TYPE to PASSED_TYPE and use consistently. + + Wed Oct 12 11:32:05 1994 Ian Lance Taylor (ian@cygnus.com) + + * genattrtab.c (num_insn_ents): New static variable. + (remove_insn_ent): Decrement num_insn_ents. + (insert_insn_ent): Increment num_insn_ents. + (optimize_attrs): Use xmalloc to allocate all the attr_value_list + structures at once, rather than using alloca for each one. + + Wed Oct 12 09:17:34 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * optabs.c (??hf2_libfunc): Define like ??sf2_libfunc. + (emit_float_lib_cmp): Call HFmode library functions. + (init_optabs): Set names for HFmode comparison functions. + * expr.h (??hf2_libfunc): Add declarations, like ??sf2_libfunc. + + Tue Oct 11 19:20:48 1994 Douglas Rupp (drupp@cs.washington.edu) + + * winnt/ld.c (main): Pass -debug:full -debugtype:coff. + * winnt/t-winnt: Rework rules for ld. + * i386/config-nt.bat: Renamed from config/i386/config-winnt.bat. + Make specific for x86, not all winnt; change filenames. + * i386/config-nt.sed: Remove -g from CFLAGS. + Reflect changes to t-winnt and other minor changes. + * i386/x-winnt: Renamed from winnt/x-winnt. + * i386/config-nt.sed: Renamed from config/winnt/top.sed. + + Tue Oct 11 18:40:41 1994 Peter Schauer (Peter.Schauer@regent.e-technik.tu-muenchen.de) + + * rs6000.h (ASM_DECLARE_FUNCTION_NAME): Always put out .lglobl + for static functions. + + Mon Oct 10 19:19:51 1994 Alex T. Ramos (ramos@engr.latech.edu) + + * expr.c (convert_move): Add TImode conversions. + + Mon Oct 10 18:46:44 1994 Alex Dreyzen (alex@alex.jf.intel.com) + + * optabs.c (expand_float): Copy TEMP to TARGET when + making recursive call and adjusting. + + Mon Oct 10 07:10:25 1994 Michael Meissner (meissner@osf.org) + + * i386/linux.h (DEFAULT_PCC_STRUCT_RETURN): Do not define as 0 if + LINUX_ELF is defined. + (perform.h): Include perform.h to define asm statements to use for + libgcc1.a builds. + + * i386/linuxelf.h (DEFAULT_PCC_STRUCT_RETURN): Define as 1. + (RETURN_IN_MEMORY): Don't define. + + Sun Oct 9 11:49:20 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.md (movsf_mem): Add & constraint, so that the scratch + register does not clobber the destination address. + + Sun Oct 9 12:40:43 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * arm.md (reload_outdf): Don't call gen_addsi3 if the address is just + a register. + + Sat Oct 8 11:16:50 1994 Doug Evans (dje@cygnus.com) + + * objc/archive.c (__objc_free): New function. + (__objc_finish_read_root_object): Use it. + + Fri Oct 7 19:23:03 1994 J.T. Conklin (jtc@cygnus.com) + + * ginclude/stddef.h: Netware uses _SIZE_T_DEFINED_, _WCHAR_T_DEFINED_. + + Fri Oct 7 12:45:43 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.c (legitimate_address_p): Disable SUBREGs as either + the index or base register. + + Fri Oct 7 08:24:44 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * i386/gnu.h (CPP_PREDEFINES): Define __HURD__. + + * collect2.c (my_strerror): If HAVE_STRERROR defined, call strerror. + * xm-gnu.h (HAVE_STRERROR): Define. + + * function.c (preserve_temp_slots): If X cannot be a temp + slot, preserve all things whose address was taken at the + present level. + + * function.c (assign_stack_temp): Abort if SIZE == -1. + + * expr.c (safe_from_p): If EXP has a variable size, assume safe. + (preexpand_calls): Don't preexpand a call that returns a variable- + sized object. + + * emit-rtl.c (add_insn_{after,before}): Fix error in last change. + + Thu Oct 6 09:18:28 1994 Kresten Krab Thorup (krab@next.com) + + Adam Fedor (fedor@hopper.colorado.edu) + * objc/archive.c (__objc_finish_read_root_object): Delay freeing + of back-patch list. + + Andrew McCallum (mccallum@cs.rochester.edu) + * objc/objc.h (BOOL): Changed from char to unsigned char. + + Thu Oct 6 08:17:04 1994 Stan Cox (coxs@dg-rtp.dg.com) + + * m88k/m88k.c (emit_move_sequence): If operand1 is an invalid PIC + address, then legitimize it before doing anything else. + + Thu Oct 6 06:54:03 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (cse_insn): Don't call force_const_mem on (const (truncate)). + + * expr.c (store_expr): Don't clobber TEMP with address. + + * reorg.c (try_merge_delay_insns): Update THREAD if it is split. + + * function.c (struct temp_slot): New field addr_taken. + (assign_stack_temp): Initialize it. + (mark_temp_addr_taken): New function. + (preserve_temp_slots): Decrement level of things at same level + but whose address has been taken. + * expr.c (expand_expr, case ADDR_EXPR): Call mark_temp_addr_taken. + + Wed Oct 5 14:17:39 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * fold-const.c (fold, COMPONENT_REF): Don't die if the CONSTRUCTOR + doesn't initialize the field we want. + + Wed Oct 5 11:38:48 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.c (legitimize_pic_address): Changes to support + LABEL_REF references when using -fpic. + (output_pic_addr_const): Ditto. + (print_operand_address): Ditto. + + * i386/i386.md (movsi insn): Changes to support LABEL_REF + references when using -fpic. + (movsi_lea): Name insn supporting lea instruction so it shows up + more clearly when doing -dp. + + Wed Oct 5 06:56:36 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reorg.c (try_merge_delay_insns): Update THREAD if deleting first + insn in it. + + Wed Oct 5 01:19:14 1994 Roland McGrath + + * configure (i[345]86-*-gnu*): Set xm_file=i386/xm-gnu.h. + * config/i386/xm-gnu.h: New file. + * config/xm-gnu.h: New file. + * config/i386/gnu.h: Move #include out of here, into + config/xm-gnu.h. + + Tue Oct 4 23:19:28 1994 Michael Meissner + + * protoize.c (POSIX includes): If POSIX is defined, include + sys/wait.h to get WIFSIGNALED, WTERMSIG, WIFEXITED, and + WEXITSTATUS. + + Tue Oct 4 21:48:02 1994 Michael I Bushnell + + * config/i386/gnu.h: Include to get O_RDONLY definition. + * gcc.c (O_RDONLY): Define macro iff not already defined. + (read_specs): Second arg to open should be O_RDONLY, not constant 0. + + Tue Oct 4 19:06:38 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expr.c (do_jump_for_compare): Properly scan insns when + branch is at start of sequence. + + Tue Oct 4 16:53:54 1994 Ian Lance Taylor (ian@cygnus.com) + + * gcc.c, collect2.c, protoize.c (WIFSIGNALED): Define if not + already defined. + (WTERMSIG, WIFEXITED, WEXITSTATUS): Likewise. + * gcc.c (execute): Use them. + * collect2.c (do_wait): Likewise. + * protoize.c (gen_aux_info_file): Likewise. + + Tue Oct 4 16:38:06 1994 Michael Meissner + + * i386/i386.h (RETURN_IN_MEMORY): Define so that large types such + as complex double values get returned like structures do, and + don't overwrite %ebx. + + Tue Oct 4 15:58:21 1994 Jim Wilson (wilson@mole.gnu.ai.mit.edu) + + * lynx-ng.h, lynx.h (PREFERRED_DEBUGGING_INFO): Add undef before + define. + + Tue Oct 4 05:12:02 1994 Richard Stallman + + * config.sub: Translate -gnu/linux* to -linux*. + + Mon Oct 3 11:43:45 1994 Ian Lance Taylor (ian@cygnus.com) + + * config.sub: Add support for MIPS variants: mips64, mipsel, + mips64el, mips64orion, mips64orionel, mips3*. + + Sun Oct 2 18:26:34 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * function.c (push_function_context_to): Renamed from + push_function_context, adds argument to indicate that the new + function is not a nested function. + (push_function_context): Call it. + (pop_function_context{,_from}): Similarly. + + * tree.c (save_tree_status): Add argument to indicate that the new + function is not a nested function. + (restore_tree_status): Ditto. + + Sun Oct 2 18:05:37 1994 Doug Evans (dje@cygnus.com) + + * configure (i[34]86-*): Change to i[345]86-*. + (target_cpu_default): Treat i586 as an i486 (for now). + + Sun Oct 2 10:25:51 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * arm.md (movsf): If reloading, create a scratch from the target for + loading a constant into integer regs. + (movdf): Likewise. + + Support for variants that fault on unaligned addrs: + * arm.h (TARGET_SHORT_BY_BYTES): New macro. + (TARGET_SWITCHES): Recognize switches -m[no-]short-load-bytes. + (TARGET_DEFAULT): Only define if not already done so. + (PROMOTE_MODE): Promote HImode unsigned if TARGET_SHORT_BY_BYTES. + (SECONDARY_INPUT_RELOAD_CLASS): Need a scratch for reloading HImode if + TARGET_SHORT_BY_BYTES. + * arm.c (arm_reload_in_hi): New function. + * arm.md (zero_extendhisi2, extendhisi2): Expand to suitable byte + sequence when TARGET_SHORT_BYTES and loading a mem. + (movhi_bytes, extendhisi2_mem): New expands. + (movhi): Call movhi_bytes to load a short from memory if + TARGET_SHORT_BY_BYTES. + (all matchers loading a short from memory): Don't match if + TARGET_SHORT_BY_BYTES. + (matcher for movhi when TARGET_SHORT_BY_BYTES): New pattern to cover + remaining valid cases. + + Sun Oct 2 08:54:30 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reg-stack.c (subst_stack_regs): Check for NOTE to see if insn was + deleted. + + * reorg.c (fill_slots_from_thread): Update THREAD if deleting + its first insn. + + * reg-stack.c (delete_insn_for_stacker): Don't set INSN_DELETED_P + on NOTE_INSN_DELETED. + + Sat Oct 1 20:42:33 1994 Chip Salzenberg + + * sco4.h (CPP_PREDEFINES): Remove i386, unix. + (CPP_SPEC): Add them here, so that they're undefined if -ansi. + Also add _i386 and _unix, which are always defined. + * x-sco (CLIB): Add "-lmalloc". + (ALLOCA): Define as "-lPW". + * x-sco4 (CC, OLDCC, RCCFLAGS, CCLIBFLAGS, CLIB, ALLOCA): From x-sco. + (X_CFLAGS): Remove. + + Sat Oct 1 14:27:45 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.md (movsf_push386): Rename to movsf_push_nomove. + (movdf_normal): Prefer to use float registers rather than general + purpose registers. + + Sat Oct 1 07:01:10 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * c-decl.c (shadow_label): Emit an error if the label is already + declared at this label scope. + + Sat Oct 1 06:44:58 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * emit-rtl.c (add_insn_{before,after}): Abort if insertion point is + a deleted insn. + * jump.c (jump_optimize): When deleting a jump, properly set NEXT. + (duplicate_loop_exit_test): Don't insert NOTE_INSN_LOOP_VTOP + before deleted insn; insert first, then delete. + + * gcc.c: Install omitted hunk from last diff. + + Fri Sep 30 18:26:11 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * emit-rtl.c (add_insn_after): Abort if can't find AFTER and it + has no NEXT_INSN. + (add_insn_before): New function. + (emit_{insn,insns,jump_insn,call_insn,barrier,note}_before): Call it. + + Fri Sep 30 17:33:41 1994 Douglas Rupp (drupp@cs.washington.edu) + + * config.sub (windowsnt): Alias for winnt. + (winnt): New OS name. + * configure (extra_programs): New, like extra_parts. + (i[34]86-*-winnt3.1): New configuration. + * genattr.c (atoi): Remove declaration. + * getpwd.c: #ifdef WINNT, include direct.h. + * sdbout.c: Don't include syms.h for winnt. + * toplev.c: Don't include times.h for winnt. + (get_run_time): Just return zero for winnt. + (main): Don't print memory usage for OS/2 or winnt. + * cccp.c (main): Use DIR_SEPARATOR if defined. + Use "Include" environment variable instead of CPATH for winnt. + * gcc.c: Don't include sys/file.h for winnt; use process.h instead. + (concat): Now just concats two things; all callers changed. + (concat[346]): New functions. + (dir_separator_str): New variable. + (exec_prefixes, startfile_prefixes, include_prefixes): Renamed + from same names without plural; all users changed. + (find_a_file, process_command, do_spec_1): Use DIR_SEPARATOR. + (find_file, is_directory, main): Likewise. + (lookup_compiler): If OS/2, do case-independent search. + (fix_argv): New function on winnt. + (FIX_ARGV): New macro for some systems; use instead of argv. + * i386/unix.h: Treat ALMOST_STDC like __STDC__. + (AS2C): New macro. + * i386.c (output_387_binary_op): Use AS2C instead of AS2 with + null first arg. + * config/winnt/config-nt.bat, config/winnt/ld.c: New files. + * config/winnt/{[tx]-winnt, config/winnt/top.sed: New files. + * config/winnt/winnt.h, config/winnt/xm-winnt: New files. + * i386/winnt.h, i386/xm-winnt.h: New files. + + Thu Sep 29 19:53:14 1994 Jim Wilson (wilson@cygnus.com) + + * sparc.md (movdf+3): Handle overlapping registers in define_split. + + * gcc.c (default_compilers): Add %Z to all cpp specs. + (n_preprocessor_options, preprocessor_options): New variables. + (process_command): Handle -Wp option. + (do_spec_1): Handle %Z spec. + + * i960/i960-coff.h: New file. + * t-960bare: New file. + * config.sub (os): Accept coff as an OS. + * configure (i960-*-coff): New configuration. + + * expr.c (result_vector): Use INCOMING_REGNO when !savep instead + of when savep. + * sparc.md (call): Use struct value pattern is struct size is not + equal to zero instead of greater than zero. + (call+7, call+8): New patterns for untyped calls. + (untyped_call): Revise to emit explicit rtl for all operation. + Delete four old patterns that matched the unexpanded untyped_call + pattern. + (blockage): New pattern. + (flush_register_windows): Modify from 0 to 1. + (goto_handler_and_restore): Modify from 1 to 2. + (flush): Modify from 2 to 3. + * sparc.c (sparc_initialize_trampoline): FLUSH is now 3 not 2. + + * calls.c (emit_library_call): For FUNCTION_ARG_PASS_BY_REFERENCE, + pass address through force_operand before using it. + + * i960.c (i960_setup_incoming_varargs): Store parameter registers + at proper offset in argument block. + + Thu Sep 29 16:39:32 1994 Mike Stump + + * stmt.c (expand_return): We have to be careful of cleanups that can + be generated when expanding the return value, as they might otherwise + wipe out the return value. + + Thu Sep 29 13:35:24 1994 Mike Stump + + * expr.c (do_jump): Handle cleanups in TRUTH_ANDIF_EXPR and + TRUTH_ORIF_EXPR. + + Thu Sep 29 13:23:56 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * gcc.c (struct option_map): Sort in alphabetical order. + (translate_options): Ignore option once an error occurs. + Fix error with reversed 'a' and 'o'. + Give error if specified abbreviation is unambiguous. + + * c-typeck.c (convert_for_assignment): When converting object + to union, allow converting the constant zero into a pointer + member of the union. + + Wed Sep 28 19:33:01 1994 Alex T Ramos (ramos@engr.latech.edu) + + * machmode.def (PSImode): Widens to PDImode. + * expr.c (convert_move): Added handling of PDImode conversions. + + Wed Sep 28 19:24:17 1994 H.J. Lu (hjl@nynexst.com) + + * configure: Don't make objc-runtime if cross-compiling gcc. + * build-make (FIXINCLUDES): Set to Makefile.in. + + Wed Sep 28 19:18:19 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * function.c (trampoline_address): Add missing call to + round_trampoline. + + Wed Sep 28 18:34:13 1994 Michael Meissner (meissner@osf.org) + + * config/svr4.h (ESCAPES): Print \v in octal rather than as '\v', + since some older versions of gas didn't accept it. + + Wed Sep 28 14:29:20 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Comment out loop which handles symbolic links to + files. It appears to not work, and to be unnecessary. + + Tue Sep 27 19:27:56 1994 Matthias Pfaller (leo@marco.de) + + * ns32k.h (ENCODE_SECTION_INFO): Only calls may go through the + PLT. All address loads, even function address loads, have to + go through the GOT or function addresses will not be unique. + + Tue Sep 27 19:20:12 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (newline_fix, name_newline_fix): Don't treat \r + specially here; it only causes bugs. This undoes the + May 14 16:01:13 1990 change to newline_fix and name_newline_fix. + + Tue Sep 27 19:02:55 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * m88k.h (ASM_OUTPUT_SOURCE_LINE): Add missing #undef. + + Tue Sep 27 18:32:17 1994 William J. Eaton (wje@hoffman.rstnu.bcm.tmc.edu) + + * function.c (optimize_bit_field): Put any insns made by + change_address in front of INSN. + (expand_function_end): Don't pass DECL_INITIAL to setjmp_protect + if it is error_mark_node. + + * genoutput.c, reload.c (n_occurrences): Make arg int, not char. + * objc-act.c (warn_with_method): Likewise. + + * optabs.c (expand_fix): Call emit_library_call_value. + + Tue Sep 27 12:39:10 1994 Mike Stump (mrs@cygnus.com) + + * Makefile.in, libgcc2.c (L_eh): some support routines for C++. + + Mon Sep 26 06:45:20 1994 Michael Meissner (meissner@osf.org) + + * 386/i386.md (adddi3, subdi3): Rewrite to add a clobber of a + scratch variable, so that memory/memoroy adds and subtracts can be + done using just one scratch register. Also, don't require op1 to + be the same as op0. + + Fri Sep 23 19:03:09 1994 Roland McGrath + + * config/i386/gnu.h (LIB_SPEC): Remove macro. + + Fri Sep 23 16:11:26 1994 Michael Meissner (meissner@osf.org) + + * i386/lynx-ng.h (CALL_USED_REGISTERS): Copy definition from + i386/lynx.h that makes ebx be a call clobbered register, since + some system calls evidently trash it. + + Fri Sep 23 15:54:53 1994 Jim Wilson (wilson@cygnus.com) + + * configure (mips-*riscos*): Changed to mips-*-riscos*. + (mips-*-riscos*-*): Deleted. + + * cse.c (invalidate): New parameter FULL_MODE. All callers + changed. + (set_nonvarying_address_components): Modify initial comment. + (cse_insn): When call invalidate for dest, use the actual dest not + inner_dest. + + Thu Sep 22 18:56:19 1994 Torbjorn Granlund (tege@cygnus.com) + + * expmed.c (expand_divmod): Special case for signed CEIL_DIV_EXPR + when divisor is power of 2. + + Thu Sep 22 12:28:53 1994 Jason Merrill (jason@deneb.cygnus.com) + + * fixinc.svr4: Fix size_t, ptrdiff_t and wchar_t like fixincludes + does. Use extern inline rather than static inline in byteorder.h. + + Thu Sep 22 12:22:03 1994 Steve Dum (steve_dum@mentorg.com) + + * collect2.c (main): Discard the first executable once we've + exploited it. + + Thu Sep 22 11:38:34 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Tweaks for LynxOS 2.2.2: accept spaces after # when + removing #define void int in curses.h; change prototype of fnctl + in fcntl.h to match POSIX.1. + + Thu Sep 22 07:18:37 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * configure: Consistently put specified manufacturer names ahead + of entries with wildcard manufacturers. + + * calls.c (emit_call_1): Fix typo in last change. + + Wed Sep 21 21:32:56 1994 Chris Smith (csmith@convex.com) + + * config.guess: Add convex c3* and c4* guesses. + * configure: Don't run fixincludes on convex. + + Wed Sep 21 15:59:12 1994 Ashley Saulsbury (ans@sics.se) + + * alpha.h (ASM_FILE_START): Write .set volatile. + + Wed Sep 21 14:45:45 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * calls.c (emit_call_1): Properly add a CLOBBER for sp + to CALL_INSN_FUNCTION_USAGE. + + * c-typeck.c (mark_addressable): Give different error if trying + to put object with volatile fields into register; don't use DECL_NAME. + + Wed Sep 21 14:02:10 1994 Jim Wilson (wilson@cygnus.com) + + * reload1.c (eliminate_regs): Make test in LOAD_EXTEND_OP case + more precise. + + Wed Sep 21 11:34:12 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Don't try to remove empty directories until after + removing DONE files. + + Wed Sep 21 05:52:49 1994 Uwe Seimet (seimet@chemie.uni-kl.de) + + * m68k/atari.h (NO_{DOLLAR,DOT}_IN_LABEL): Define. + + Tue Sep 20 20:06:08 1994 Doug Evans (dje@cygnus.com) + + * final.c (asm_insn_count): Handle ASM_INPUTs too. + + Tue Sep 20 19:32:10 1994 Oliver Kellogg (okellogg@salyko.cube.net) + + * 1750a.h, 1750a.c, 1750a.md: New files, to use as1750. + * 1750a/m1750.inc: File deleted. + * 1750a/ms1750.inc: New file. + + Tue Sep 20 17:55:50 1994 Hallvard B Furuseth (hbf@durin.uio.no) + + * cccp.c (make_definition): Enable `-D' with macro arguments. + + Tue Sep 20 17:49:47 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cexp.y (HOST_WIDE_INT, HOST_BITS_PER_WIDE_INT): New macros. + (expression_value): Now HOST_WIDE_INT. + (parse_c_expression): Now returns HOST_WIDE_INT. + * cccp.c (eval_if_expression): Likewise. + (do_if, do_elif): Reflect new return value of functions. + + * alpha.c (mode_mask_operand): Always return a value. + + * function.c (pop_function_context): Clear reg_renumber. + + * gcc.c (process_command): Add new switch, -dumpmachine. + + Tue Sep 20 15:57:40 1994 Jim Wilson (wilson@cygnus.com) + + * sched.c (sched_analyze_insn): Parameter loop_note type changed + to rtx, and name changed to loop_notes. Code adding it to + REG_NOTES modified to account for type change. + (sched_analyze): Variable loop_note type changed to rtx, and name + changed to loop_notes. Store LOOP_* REG_DEAD notes in it instead + of LOOP_* NOTE_LINE_NUMBER. + (schedule_block): Pass last not insn to emit_note_before call. + + * iris5.h (ASM_OUTPUT_UNDEF_FUNCTION): Define. + (ASM_OUTPUT_EXTERNAL_LIBCALL): Define. + (ASM_DECLARE_FUNCTION_SIZE): Define. + * mips.c (mips_output_external): Use ASM_OUTPUT_UNDEF_FUNCTION. + (mips_output_external_libcall): New function. + (mips_asm_file_end): Handle ASM_OUTPUT_UNDEF_FUNCTION. + * README.IRIX5: Update. + + Tue Sep 20 14:39:37 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.h (output_move_memory): Add declaration. + (output_move_pushmem): Ditto. + + * i386/i386.c (output_move_pushmem): New function to handle + pushing bytes from memory onto the stack, possibily using + temporary registers. + (output_move_memory): New function to handle moving bytes from + memory to memory via temporary registers. + + * i386/i386.md (movsi insn): If -fpic and the value we are moving + is a constant pool address, emit a leal instruction instead of + movl. + (movsf_push): Allow pushes from memory. + (SF, DF, XF, DI pushes): Move most of the code to the common + function output_move_pushmem. + (SF, DF, XF, DI memory->memory moves): Move most of the code to + the common function output_move_memory. + (DI move patterns): Combine DI patterns into two, one for pushes, + and one for everything else, so that the combiner will combine a + load with a store into a memory->memory move. + (untyped_call): Replace non-working code with m68k version that + emits a regular call, then breaks the parallel moves into separate + moves, and then issue a blockage instruction. + (blockage): New unspec_volatile insn to block insns from being + moved across this point. + (untyped_return): Delete. + (update_return): Delete. + + * objc/sendmsg.c (get_imp): Allow __inline__ on x86 platforms. + + Tue Sep 20 12:21:12 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Handle the case of a symlink to root/* from a + subdirectory of another symlink to root/*. + + Mon Sep 19 20:30:21 1994 Jason Merrill (jason@deneb.cygnus.com) + + * fold-const.c (fold): Handle COMPONENT_REFs involving CONSTRUCTORs. + + Mon Sep 19 20:25:38 1994 Will Athanasiou (will@westford.ccur.com) + + * rs6000.md (load sf with update): Fix RTL typo. + + Mon Sep 19 08:46:46 1994 Charles M. Hannum (mycroft@duality.gnu.ai.mit.edu) + + * c-common.c (check_format_info): Enable checking of format + specifiers using the `q' (quad) length modifier. + (format_char_info): Add `qlen'. + (print_char_table, scan_char_table): Add appropriate entries for + qlen. + + Sat Sep 17 12:48:57 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * stmt.c (mark_seen_cases): Don't call fatal (or do anything + else) if case index out of range. Warning is given later. + + Fri Sep 16 19:22:46 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * global.c (global_alloc): Mark regs assigned to SCRATCH as used by + more than just local alloc. + + Thu Sep 15 14:36:59 1994 Michael Meissner + + * i386/i386.c (order_regs_for_local_alloc): Instead of using + flag_cse_follow_jumps and not leaf_function_p to determine whether + to allocate EDX, and ECX before EAX, use whether or not a DImode + variable was used in the compilation. DImode variables seem to + cause spill failures if EAX is allocated first, while smaller code + is generated if EAX is allocated first, assuming no spill failure. + + * i386/i386.md (SF, DF, XF, and DI moves and pushes): Eliminate + special patterns for TARGET_386 that allow direct pushes from + memory, and instead allow direct pushes from memory as the last + alternative in case no scratch registers could be allocated. + (movxf_mem): Remove inadvertent !TARGET_386 condition. + (addsi3): Allow generation of lea on 486, since the single + instruction lea is at least as fast as the mov and add it + replaces. + (zero extend patterns): Replace !TARGET_486 with TARGET_386. + (bit extracts): Ditto. + + * i386/osfrose.h (LONG_DOUBLE_TYPE_SIZE): Don't redefine to be 64 + unless NO_LONG_DOUBLE is defined. + + Thu Sep 15 13:46:05 1994 Jim Wilson (wilson@cygnus.com) + + * expmed.c (store_split_bit_field): Use number of bits in arg not + BITS_PER_WORD to adjust arg in BYTES_BIG_ENDIAN case. + + Thu Sep 15 09:19:12 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * optabs.c (expand_binop, multi-word shifts): Generate rtl + free of conflicts for shifts less than one word. + + Thu Sep 15 05:29:58 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * gcc.c: Rework last change so it's done like collect2.c. + + * cse.c (cse_around_loop): Don't invalidate SUBREG unless + it's a SUBREG of a REG. + + * sched.c (sched_analyze_insn): Don't set SCHED_GROUP_P for previous + INSN a USE unless it's a USE of a REG. + + Wed Sep 14 10:08:58 1994 Michael I Bushnell + + * gcc.c: Include in case `errno' is really a macro + as permitted by ANSI C. + + * getpwd.c (GUESSPATHLEN): If there is no definition of + MAXPATHLEN, then set GUESSPATHLEN to be 100. (It's used + as a starting point, not a limit, so this is harmless.) + + Tue Sep 13 15:02:19 1994 Michael Meissner + + * i386/i386.md (movxf_mem): Fix typo with memory/memory moves + of XFmode variables, where the store actually did a load, ie, the + source and destination operands were fixed. + (fixuns_trunc patterns): Revert to the old code. + (movdf_push486, movxf_push486, movdi_push486): If an address is + based on the stack pointer, account for the stack pointer changing + due to the intermediate pushes generated. + + Tue Sep 13 14:11:16 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * collect2.c (fatal_perror, fatal, error): Declare all args as char *. + + Tue Sep 13 12:40:39 1994 Jeffrey A. Law (snake.cs.utah.edu) + + * pa.c (emit_move_sequence): Handle secondary FP load/store + reloads of the form (subreg (mem (plus (reg) (disp)))). + (secondary_reload_class): A secondary register is needed to handle + out-of-range FP loads and stores. + * pa.md (reload_indf, reload_outdf): New expanders. + (reload_insf, reload_outsf): Likewise. + + Mon Sep 12 18:15:48 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * t-pa (ADA_CFLAGS): New override. + * pa/t-pa-hpux: New file. + * configure (hppa*-*-hpux*): Use t-pa-hpux instead of t-libc-ok. + + Mon Sep 12 14:52:17 1994 Jim Wilson (wilson@cygnus.com) + + * function.c (assign_parms): Set RTX_UNCHANGING_P on stack_parm + for const parameter before calling move_block_from_reg. + + Mon Sep 12 14:27:58 1994 Doug Evans (dje@cygnus.com) + + * config/fp-bit.c (FLO_union_type): Add packed attribute to `bits'. + + Sat Sep 10 09:50:41 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (invalidate_for_call): Properly set IN_TABLE. + + Sat Sep 10 06:46:24 1994 Bill Burton (billb@progress.com) + + * Added improved support for Sequent DYNIX/ptx 1.x and 2.x: + * fixinc.ptx: New file. + * i386/seq-sysv3.h (HAVE_ATEXIT): No longer defined. + * i386/seq2-sysv3.h: New file. + * configure (i[34]86-sequent-ptx[12]*): New configurations. + (i[34]86-sequent-sysv*, i[34]84-sequent-ptx): Deleted configurations. + * config.sub (ptx): New OS; use for Sequent. + + Fri Sep 9 21:48:48 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (rescan, handle_directive): Backslash no longer suppresses the + specialness of the following char unless -traditional. + (rescan): Remove backslash-newline only if at top level, since + backslash-newline-space can be encountered during macro processing. + (collect_expansion): Remove special hack for \# inside a #define; + it's not compatible with the C Standard. + + Thu Sep 9 17:36:03 1994 Jason Merrill (jason@deneb.cygnus.com) + + * Utilize OSF/1's limited .init support. + * alpha/alpha.h (HAS_INIT_SECTION): Define. + (LINK_SPEC): Add '-init __main'. + * alpha/osf12.h (LINK_SPEC): Ditto. + + * function.c (expand_main_function): Don't call __main if + HAS_INIT_SECTION is defined. + + Fri Sep 9 16:36:46 1994 Mike Stump (mrs@cygnus.com) + + * tree.c (decl_function_context): Don't treat C++ member + functions of classes declared in a function, as nested functions. + + Fri Sep 9 16:10:25 1994 Steve Chamberlain (sac@jonny.cygnus.com) + + * sh/sh.c (prepare_move_operands): Generate better DI constant + code. + (fake_shift): New function. + * sh/sh.md (ashlsi3_n, lshrsi3_n): Only recognise if fake_shift + enabled. + * sh/{lib1funcs.asm, ashlsi3.c, lshrsi3.c, ashrsi3.c} : New files. + * sh/t-sh : Build new files. + + Fri Sep 9 15:52:54 1994 Hallvard B Furuseth (h.b.furuseth@usit.uio.no) + + * cccp.c: Correct unprototyped pointer args from `0' to `NULL_PTR' + + Fri Sep 9 15:17:52 1994 Matthew Green (mrg@splode.mame.mu.oz.au) + + * configure (sparc-*-netbsd): New configuration. + * sparc/netbsd.h: New file. + + Fri Sep 9 15:15:48 1994 Jim Wilson (wilson@cygnus.com) + + * mips.md (truncdisi2): Change from define_expand to define_insn. + (truncdihi2, truncdiqi2): Likewise. + + * sparc.h (SQRTTF2_LIBCALL): Delete. + (INIT_TARGET_OPTABS): Define. + (INIT_SUBTARGET_OPTABS): Define. + + * stmt.c (check_for_full_enumeration_handling): Cast malloc result + to `unsigned char *' not `char *'. + + * dbxout.c (dbxout_symbol_location): Handle error_mark_node in + DECL_INITIAL for C++. + + * mips.md (memory): Add missing !r4600 to first define_function_unit. + + * sparc.md (negsi2): Use register_operand not general_operand for + output. + + Fri Sep 9 14:52:58 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * config/netbsd.h: Add #undef for everything we define; a few were + missing. + + * reload.c (find_reloads, case 'p'): Operand is BASE_REG_CLASS. + + Fri Sep 9 14:00:28 1994 Mike Collison (collison@world.std.com) + + * configure (dsp16xx-*): New configuration. + * config.sub (dsp16xx): New basic machine. + * dsp16xx.c, dsp16xx.md, dsp16xx.h, xm-dsp16xx.h: New files. + + Fri Sep 9 12:47:00 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.md (All SF, DF, XF, DI 486 push patterns): Merge the + memory and nonmemory push patterns together. + + Fri Sep 9 00:53:36 1994 Richard Stallman + + * config.sub: Accept i586 like i386. + Do not use SCO as a default for i386-*. + + Thu Sep 8 18:49:35 1994 Steve Chamberlain (sac@cygnus.com) + + * config/fp-bit.c (_fpmul_parts): Perform optimized + 64bit*64bit multiply correctly. + * sh/sh.c (synth_constant): Ensure DI mode constants get their + high part zeroed. + (add_constant): Entabled constants are only identical if their + sizes are the same. + + Thu Sep 8 14:40:31 1994 Jim Wilson (wilson@cygnus.com) + + * flow.c (mark_used_regs, case REG): Correct typo, use GET_MODE + not GET_CODE. + * sched.c (attach_deaths): Likewise. + + Tue Sep 6 23:33:41 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * tree.c (get_set_constructor_bits, get_set_constructor_words): + New functions. Extract bits or words from SET_TYPE CONSTRUCTOR. + * tree.h: Declare above new functions. + + Thu Sep 8 14:02:05 1994 Michael Meissner (meissner@osf.org) + + * 386/i386.h (TARGET_OPTIONS): New macro to define -mreg-alloc= + switch to allow users to override the register allocation order. + (OVERRIDE_OPTIONS): Call the function override_options. + (REG_ALLOC_ORDER): Define to allocate in the natural order, this + is needed for ORDER_REGS_FOR_LOCAL_ALLOC to work. + (ORDER_REGS_FOR_LOCAL_ALLOC): Define to call the function + order_regs_for_local_alloc. + (regclass_map): Move declaration to end of file. + (i386_compare_op0, i386_compare_op1): Ditto. + (CLASS_LIKELY_SPILLED_P): Define, return 1 for AD_REGS in addition + to all of the single register classes, since AD_REGS is only used + to allocate EAX:EDX. + (override_options, order_regs_for_local_alloc): Add declarations. + (hi_reg_name): Add declaration. + (qi_reg_name): Ditto. + (qi_high_reg_name): Ditto. + (i386_reg_alloc_order): Add declaration for TARGET_OPTIONS to use. + + * i386/i386.c (i386_compare_op0, i386_compare_op1): Initialize + with NULL_RTX. + (i386_reg_alloc_order): Provide global variable definition. + (regs_allocated): Static array to note whether a register is noted + via -mreg-alloc=. + (override_options): Provide checking for registers declared with + -mreg-alloc=. + (order_regs_for_local_alloc): If -mreg-alloc= was used, + allocate registers mentioned in order, and then allocate all other + registers in the normal register order. If -mreg-alloc= was + not used, allocate registers in natural order except for non-leaf + functions with CSE following jumps, allocate EAX after EDX and + ECX, to allow the function return to be CSE'd, and perl 4.036's + perly.y to be compiled without aborting due to not being able to + find a spill register. + (movsf, movdf, movdi): Rewrite all patterns to provide effecient + memory to memory moves, including pushes for i386 and i486. Fixes + problems in compiling motif+ without optimization. + (swapsf): Add, like swapdf and swapxf. + (fixuns_truncsfsi2, fixuns_truncdfsi2): Use general_operand + instead of register_operand for define_expand, since the operand + is copied to a new pseudo register as part of the expansion. + (fix_truncxfdi2, fix_truncdfdi2, fix_truncsfdi2): Rewrite to call + the more primitive generator functions instead of knowing how many + clobbers of match_scratchs they do. + + * Makefile.in (aux_output.o): Define TARGET_CPU_DEFAULT if + specified when compiling aux_output.o to allow the machine C file + access to this if it wants it. + + Thu Sep 8 07:15:29 1994 David Edelsohn (edelsohn@npac.syr.edu) + + * rs6000.md (movsi matcher): Merge TARGET_POWER and !TARGET_POWER + cases. Rationalize mnemonics. + (movhi and movqi matchers): Likewise. + (movsf matcher): Correct length attribute for stfs which no longer + includes frsp. + + Thu Sep 8 07:06:31 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * rs6000.h (REGISTER_MOVE_COST): Fix typo in last change. + + Wed Sep 7 19:31:52 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (handle_directive): In `#include ' directives, + remove backslash-newline properly. Don't allow any other newlines. + + Wed Sep 7 18:11:29 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * rs6000.h (REGISTER_MOVE_COST): Moving between special registers + is expensive. + + * combine.c (simplify_comparison): Convert comparison to unsigned + when stripping off a ZERO_EXTEND. + + * combine.c (simplify_set): Only convert IF_THEN_ELSE to logical + expression if mode of object being compared is result mode. + + Wed Sep 7 18:09:17 1994 David J. MacKenzie (djm@geech.gnu.ai.mit.edu) + + * configure: Ignore --help, --version, --program-prefix, + --program-suffix, --cache-file, --quiet, --silent. + + Wed Sep 7 13:29:50 1994 Doug Evans (dje@cygnus.com) + + * stmt.c (expand_asm_operands): Move test for misspelled registers + higher so all cases caught. + + Wed Sep 7 09:54:14 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * configure: Touch Makefile.ll before appending subdir stuff. + (Needed if there are no subdirs.) + + Wed Sep 7 11:19:18 1994 Kresten Krab Thorup (krab@akvavit.next.com) + + * objc/init.c (__objc_init_protocols): Remove assertion. + * objc/Object.m (conformsTo:): Make lookup allways happen in + the class object. + + Tue Sep 6 17:47:39 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * configure: Rename *-next-ns[23] to *-next-nextstep[23]. + * config.sub: Cleanup NeXT support to emit nextstep*. + + Tue Sep 6 18:38:02 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reload.c (find_reloads_address): Don't reorder the operands of a + PLUS when fixing up index. + + Tue Sep 6 18:24:50 1994 Matthias Pfaller (leo@marco.de) + + * ns32k.md (stackadjust/push peepholes): For the adjust/push/push + pattern one offset was wrong. + Don't use addr for register and and MEM refs. + + Tue Sep 6 11:24:06 1994 Steve Chamberlain (sac@jonny.cygnus.com) + + * sh/sh.c (push, pop): Generate REG_NOTES. + (synth_constant): Correct one of the patterns. + (output_file_start): Bump version number. + * sh/sh.h (EXIT_IGNORE_STACK): Now 1. + * sh/sh.md (adddi3, subdi3): Simplify. + (casesi_worker): Use TARGET_BIGTABLE. + + Mon Sep 5 12:29:15 1994 Ian Lance Taylor (ian@cygnus.com) + + * ginclude/math-68881.h: Change inline functions from static to + extern. + + * configure (i[34]86-*-sysv4*): If --with-stabs, set tm_file to + i386/sysv4gdb.h. + * config/i386/sysv4gdb.h: New file; sets PREFERRED_DEBUGGING_TYPE. + + Sun Sep 4 08:40:02 1994 Chris Smith (csmith@convex.com) + + * convex.h (VTABLE_USES_MASK, VINDEX_MAX, SET_DECL_VINDEX): + delete, no longer used. + (target_flags): delete cexp.c hack, no longer needed. + * convex.md (decr-and-set-cc0): fix HImode to use halfword + insns. + (cmpqi patterns): fix constraints not to use A regs + + Sat Sep 3 14:12:11 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.md (DImode move and push insns): Eliminate movdi + wrapper that made a DI temp register to do a memory to memory + move because it creates too much register pressure, especially + when not optimizing. On the 486, allocate and use 1-2 scratch + registers to push a DImode value. + + Fri Sep 2 15:11:59 1994 Jason Merrill (jason@deneb.cygnus.com) + + * c-decl.c (min_precision): Move from here. + * c-common.c: To here. + + Fri Sep 2 13:16:38 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * tree.h (maximum_field_alignment, set_alignment): New declarations. + + Fri Sep 2 14:25:36 1994 Ian Lance Taylor (ian@cygnus.com) + + * config/svr4.h (DBX_DEBUGGING_INFO, PREFERRED_DEBUGGING_TYPE, + DBX_BLOCKS_FUNCTION_RELATIVE, ASM_IDENTIFY_GCC, + ASM_IDENTIFY_GCC_AFTER_SOURCE, ASM_OUTPUT_SOURCE_LINE, + DBX_FUNCTION_FIRST): Define. This adds support for -gstabs for + SVR4 configurations. -gstabs requires gas and gdb. + * config/sparc/sol2.h (DBX_DEBUGGING_INFO, + DBX_BLOCKS_FUNCTION_RELATIVE, ASM_IDENTIFY_GCC, + ASM_IDENTIFY_GCC_AFTER_SOURCE, ASM_OUTPUT_SOURCE_LINE, + DBX_FUNCTION_FIRST): Don't define. Now defined by config/svr4.h. + (PREFERRED_DEBUGGING_TYPE): Undefine before defining. + * config/sparc/sysv4.h (DBX_DEBUGGING_INFO): Don't bother to + undefine before including svr4.h. + (ASM_OUTPUT_SOURCE_LINE): Undefine before including svr4.h. + + Thu Sep 1 22:02:02 1994 Michael Meissner (meissner@osf.org) + + * toplev.c (fatal_insn): Move most of the code from + fatal_insns_not_found here, and add an argument to give the error + message. + (fatal_insn_not_found): Call fatal_insn. + * rtl.h (fatal_insn, fatal_insn_not_found): Add prototypes. + * genextra.c (main): Don't declare fatal_insn_not_found in + insn-extract.c. + * reload1.c (reload): Call fatal_insn where appropriate to print + an error message instead of calling abort. + (spill_failure): Ditto. + (reload_as_needed): Ditto. + (allocate_reload_reg): Ditto. + (emit_reload_insns): Ditto. + + Thu Sep 1 19:34:26 1994 Jason Merrill (jason@deneb.cygnus.com) + + * tree.c (type_list_equal): If the types of the default arguments + differ, the lists do not match. + + Thu Sep 1 19:29:58 1994 Matthias Pfaller (leo@marco.de) + + * ns32k.md (stack-adjust/push peepholes): Addresses are + moved with "addr", not with "movd". + + Thu Sep 1 19:17:55 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (make_definition): Don't dump core when given an + unterminated string in a -D option. + + Thu Sep 1 19:13:35 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * c-typeck.c (convert_arguments): Give proper warnings when + converting COMPLEX_TYPE; widen check to include all integral types. + + Wed Aug 31 20:38:53 1994 Per Bothner (bothner@spiff.gnu.ai.mit.edu) + + * fixproto: Define FIX_HEADER (needed by Aug 19 change). + Use FIX_HEADER instead of $original_dir/fix-header (twice). + + Wed Aug 31 16:56:15 1994 Jason Merrill (jason@deneb.cygnus.com) + + * stmt.c (warn_if_unused_value): Extend special case for casted + MODIFY_EXPRs to apply to INIT_EXPRs as well. + + Wed Aug 31 16:30:09 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * stor-layout.c (set_alignment): New global. + (layout-type): Add support for SET_TYPE. + + * expmed.c (store_bit_field): Semi-revert Aug 25 change: + Make it apply only for BLKmode, not integral modes. + + * stmt.c (all_cases_count, mark_seen_cases): New functions. + (BITARRAY_TEST, BITARRAY_SET): New macros. Used (mainly by + Chill) to check all cases are covered (for enums and ranges). + (check_for_full_enumeration_handling): Re-write to use the + new functions, now that we have them. + + Wed Aug 31 19:19:29 1994 Richard Earnshaw (rwe@pegasus.esprit.ec.org) + + * combine.c (nonzero_bits, cases DIV, MOD, UDIV, UMOD): Declare + op0_maybe_minusp and op1_maybe_minusp as HOST_WIDE_INT. + + Wed Aug 31 18:54:54 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expmed.c (store_split_bit_field): Always adjust arg to + extract_fixed_bit_field in BYTES_BIG_ENDIAN case. + + Wed Aug 31 02:49:34 1994 Roland McGrath + + * config/i386/gnu.h (LIB_SPEC): New macro. + + Tue Aug 30 16:35:23 1994 Jason Merrill (jason@deneb.cygnus.com) + + * toplev.c (lang_options): Add -W{no-,}reorder. + + Tue Aug 30 13:55:58 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * combine.c (simplify_comparison, case GEU): Add missing break. + + Mon Aug 29 17:50:55 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * vax.md (extv, extzv): Don't use ROTL when field is outside + boundaries of a word. + + Mon Aug 29 11:43:18 1994 Kresten Krab Thorup (krab@akvavit.next.com) + + * objc/sendmsg.c (get_imp): Don't inline on 386. + + Sun Aug 28 18:56:03 1994 Andrew McCallum (mccallum@cs.rochester.edu) + + * objc/class.c (objc_get_meta_class): New function. + + Sat Aug 27 23:13:53 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.c (legitimate_address_p): If index register is either + the arg pointer or the stack pointer, and there is no scale + factor, swap with the base register. + + * i386/i386.h (REG_CLASS_CONTENTS): Don't allow the arg pointer + register as an index register, since the frame could be omitted, + and the stack pointer is not valid as an index. + + * i386/i386.md (mov*, movstrict*): Don't create pushes of memory + values when creating insns, let the combiner create a push of a + memory value if -m386. In particular, pushes of byte values was + broken because there is no pattern to recognize such a push. + + Fri Aug 26 16:03:09 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.h (MASK_*): Add masks for all of the switches. + (TARGET_*): Use appropriate MASK_* instead of a number. Add + -mdebug-addr switch to debug GO_IF_LEGITIMATE_ADDRESS, + -mno-wide-multiply to turn off widening multiplies, and -mno-move + to allow integer move insns to generate direct memory to memory + copies, which reload will fix up. Add TARGET_386 which is not of + TARGET_486. + (REG_ALLOC_ORDER): Go to the order used in 2.5.8, eax, edx, ecx, ... + Add a comment describing the tradeoffs. + (REG_OK*): Add strict and non-strict versions of the macros that + are always present, and REG_OK_STRICT chooses between the two + inner macros. + (GO_IF_LEGIMATE_ADDRESS): Move processing to legitimate_address_p + function. + (LEGITIMIZE_ADDRESS): Move processing to legitimize_address + function. + (function declarations): Add function declarations for all extern + functions in i386.c. + + * i386/i386.c (asm_add): Add support in case adding by 1 or -1 to + use inc/dec. + (various): Change TARGET_486 -> !TARGET_386. + (legitimate_address_p): Move GO_IF_LEGITIMATE_ADDRESS processing + here from i386.h. Combine OSF/rose support from osfrose.h through + the use of conditional macros. Only recognize addresses in + canonical formats, code adapted from the i960 port. Add tracing + if -mdebug-addr. + (legitimize_address): Move LEGITIMIZE_ADDRESS here from i386.h, + and add adaptations from the i960 port. + (convert_387_op): Remove unused function. + + * i386/i386.md (various): Remove cast to char * of output + functions, since i386.h now declares them all properly. Change + TARGET_486 tests to !TARGET_386 and !TARGET_486 to TARGET_386. + (movsi, movstricthi, movhi, movstrictqi, movqi, movdi): Add + define_expand wrappers to prevent memory<->memory moves from being + generated unless -mno-move is used. On 486's do not allow push of + memory insns to be generated unless -mno-move. + (movdi): For movdi patterns, add 2 (clobber (match_scratch...)) + declarations to allow memory<->memory moves with non-contigous + registers, so that reload don't abort if it can't make a DI + register. + (umulsidi3, mulsidi3): Don't allow pattern if -mno-wide-multiply. + (smultsi3_highpart, umultsi3_highpart): Add patterns to make + division by constants generate better code. + + * i386/osfrose.h (MASK_*): Use octal to define bitmasks, not hex, + for compatibility with i386.h. + (NO_IMPLICIT_EXTERN_C): Define. + (LONG_DOUBLE_TYPE_SIZE): Explicitly define to be 64 instead of + just #undef'ing it. + (GO_IF_LEGITIMATE_ADDRESS): Delete, merged with common i386 code. + (ASM_FILE_END): Print -fschedule-insns and -fschedule-insns2 in + ident string if those options are used. + (REAL_LD_FILE_NAME): Delete. + (ASM_OUTPUT_DOUBLE): Delete, use the common macros. + (ASM_OUTPUT_FLOAT): Ditto. + (ASM_OUTPUT_LONG_DOUBLE): Ditto. + + Thu Aug 25 17:15:18 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * expmed.c (store_bit_field): Always store into multi-word + bitfields starting with low addresses. (Old code was + incompatible with operand_subword_force on big-endian targets.) + + Thu Aug 25 18:31:20 1994 Antti Miettinen (amiettin@ntc.nokia.com) + + * m68k/lynx.h (CALL_USED_REGS): Add d2 and d3 as call-used. + + Thu Aug 25 11:30:44 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (record_jump_cond): Don't do anything if OP0 and OP1 + are already equivalent. + + * rtlanal.c (may_trap_p, case EXPR_LIST): New case. + + * c-common.c (shorten_compare): Don't issue warning if both + operands constants and the signedness doesn't affect the + comparison results. + + * configure: Refine handling and error-checking of positional args. + + * print-tree.c (print_node): Print more flags for types and decls. + + * c-typeck.c (type_lists_compatible_p): Treat transparent unions + just like unnamed ones. + + Wed Aug 24 19:34:52 1994 Charles Hannum (mycroft@duality.gnu.ai.mit.edu) + + * configure: Rearrange handling of NetBSD ports to use the standard + `cpu-vendor-os' format. + * config.sub: Recognize names of NetBSD ports that do not correspond + to a CPU name. + + Wed Aug 24 18:43:30 1994 Philippe De Muyter (phdm@info.ucl.ac.be) + + * print-tree.c (print_node_brief, print_node): Use assignment instead + of initialization for aggregate local variable REAL_VALUE_TYPE d. + + Wed Aug 24 18:28:52 1994 Ian Lance Taylor (ian@cygnus.com) + + * config/svr4.h (ASM_OUTPUT_SECTION_NAME): Define. + * config/sparc/sysv4.h (ASM_OUTPUT_SECTION_NAME): Output #alloc to + set SHF_ALLOC in section flags. + + Wed Aug 24 17:45:19 1994 Jim Wilson (wilson@sphagnum.cygnus.com) + + * c-parse.in (parmlist_2): Give error for function with only + ELLIPSIS as an argument. + + Wed Aug 24 17:36:22 1994 H.J. Lu (hjl@nynexst.com) + + * i386/linux.h (STARTFILE_SPEC): Add %{static:-static}. + + Wed Aug 24 14:34:37 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * calls.c (expand_call): Check for variable-sized return value + in proper place. + + * c-typeck.c (default_conversion): Don't substitute constant + value if array since will return address. + + * configure (LANG_MAKEFILE): Include lang/Makefile.in in list. + + * alpha.h (EXTRA_CONSTRAINT): Add new letter, `R'. + (ENCODE_SECTION_INFO): Don't check TREE_ASM_WRITTEN. + (PREDICATE_COSTS): Add call_operand. + * alpha.c (call_operand): New function. + (output_epilog): Don't set SYMBOL_REF_FLAG of current function. + * alpha.md (call): Rework to use macro version of jsr. + * osf2.h (LINK_SPEC): Don't define; should never have been. + + * c-typeck.c (push_init_level): Don't blow up if construct_type + is null (can happen with missing brace). + + Wed Aug 24 10:49:35 1994 Michael Meissner (meissner@osf.org) + + * i386/i386.h (REG_ALLOC_ORDER): Restore previous version which + allocates edx first, then ecx, eax, ... This is because perl + doesn't build when the order is eax, ecx, edx... + + Tue Aug 23 09:20:16 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * configure: Restore old behavior of positional arguments. + Add new argument, --noguess. + config.guess now guesses BUILD, not HOST; HOST defaults from BUILD. + Always compare canonical names, not user-specified names. + Numerous minor changes in the messages output to make the + configuration chosen clearer. + + Tue Aug 23 02:01:42 1994 Richard Stallman + + * config.sub: Move m68k-ccur handling to proper part of file. + Canonicalize cpu type pentium into i486. (Change it to i586 later.) + + Mon Aug 22 18:41:59 1994 Steve Chamberlain (sac@jonny.cygnus.com) + + * sh/sh.c (find_barrier): Calculate the size of larger than + SI moves correctly. + (general_movsrc_operand): Allow label_refs plus const. + (sh_function_arg_partial_nregs, sh_function_arg): Pass BLKmode + objects in partial regs. + * sh.h (TARGET_DEFAULT): Turn off BIGTABLE_BIT. + (EXTRA_CONSTRAINT_Q): Allow label_refs plus const. + (READONLY_DATA_SECTION_ASM_OP, EXTRA_SECTIONS, rdata_section): + Delete rdata section and refs. + * sh.md (dimode split): Don't allow a Q constraint source. + + Sun Aug 21 23:15:35 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * pa.h (FUNCTION_ARG): Use indirect calling conventions when + TARGET_LONG_CALLS is in effect. + + Sat Aug 20 13:31:34 1994 Jim Wilson (wilson@cygnus.com) + + * sched.c (sched_analyze_insn): Add new parameter loop_note. + If loop_note set, then serialize on this insn. + (sched_analyze): New variable loop_note. Pass to + sched_analyze_insn. Set it if we pass a NOTE_INSN_LOOP_BEG or + NOTE_INSN_LOOP_END. + (unlink_notes): Don't save away NOTE_INSN_LOOP_BEG or + NOTE_INSN_LOOP_END notes. + (schedule_block): Generalize code that looks for magic REG_DEAD + notes and converts them to notes. + + Sat Aug 20 12:47:21 1994 Michael Meissner (meissner@osf.org) + + * i386.h (REG_ALLOC_ORDER): Allocate eax first, then ecx, edx, and + then do the nromal allocation order for the remaining registers. + + Fri Aug 19 20:14:35 1994 Jim Wilson (wilson@cygnus.com) + + * tree.c (build_type_variant): Only return existing type if it + also has the same TYPE_NAME. + + * irix5.h (NO_IMPLICIT_EXTERN_C): Comment out. + + Fri Aug 19 16:41:43 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * fixproto: Use $FIX_HEADER macro instead of calling + fix-header directly in 2nd location. + + Fri Aug 19 17:34:19 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expr.c (emit_move_insn_1): Never make a no-conflict block. + + * tree.h (struct tree_type): New field transparent_union_flag. + (struct tree_decl): New field transparent_union. + ({DECL,TYPE}_TRANSPARENT_UNION): New macros. + * c-common.c (decl_attribute): Handle "transparent_union" attribute. + * function.c (assign_parms): If parm is transparent union, use + type of first field. + * calls.c (expand_call): Likewise. + * integrate.c (function_cannot_inline): Don't inline if any + parm is a transparent union. + + Fri Aug 19 12:01:11 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Canonicalize ${INPUT} to avoid automounter + problems. + + Fri Aug 19 11:31:24 1994 Kresten Krab Thorup (krab@akvavit.next.com) + + * objc-act.c (build_selector_translation_table): Reset + current_function_decl after hack_function_prototype build it. + (build_module_descriptor): Return constructor name from functions + decl_rtl. + + Thu Aug 18 17:23:18 1994 Per Bothner (bothner@spiff.gnu.ai.mit.edu) + + * README.FRESCO: New file. Notes about compiling the Fresco + toolkit with g++. + + Thu Aug 18 14:10:22 1994 Jim Wilson (wilson@cygnus.com) + + * combine.c (distribute_notes, case REG_UNUSED): Ignore notes when + from_insn != i3 only if the notes would remain as REG_UNUSED notes. + + Wed Aug 17 18:31:43 1994 Holger Teutsch (holger@hotbso.rhein-main.de) + + * clipper.h (CLIPPER_ARG_SIZE): Return size in bytes. + (FUNCTION_ARG_ADVANCE): Fix argument alignment processing. + + Wed Aug 17 18:03:54 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * fx80.md (casesi_2): Operand 0 is HImode; add SIGN_EXTEND + when adding to pc. + (casesi): Operand 0 is HImode. + (unnamed PC addition pattern): Add SIGN_EXTEND to add HImode + offset to SImode PC. + * m68k.md (tablejump): Add SIGN_EXTEND to HImode offset + so can add to SImode PC. + Likewise for matching pattern. + * cse.c (fold_rtx): When folding tablejump, allow LABEL_REF + to be in arg0; also allow other arg to be MINUS, not just be + equivalent to it. + + Mon Aug 15 19:19:11 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (index0): New function. + (trigraph_pcp): Use index0 instead of index, so that a null + byte doesn't suppress further trigraph preprocessing. + + * cccp.c (rescan, do_ident): Pass more accurate size request + to check_expand. + + * cccp.c (main): Don't dump core if given -pcp, -MD, or -MMD + without following arg. + + Mon Aug 15 17:56:38 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * stmt.c (expand_elseif): New function. + + Mon Aug 15 14:16:18 1994 Ian Lance Taylor (ian@cygnus.com) + + * configure: If the host is guessed, and the target name is a + prefix of the host name, then use the target name as the host + name. + + Mon Aug 15 13:35:24 1994 Stan Shebs (shebs@andros.cygnus.com) + + * m68k/m68k-coff.h: New file. + + Sun Aug 14 00:28:15 1994 Andrew McCallum (mccallum@vein.cs.rochester.edu) + + * objc/encoding.c (objc_sizeof_type): Assign from ROUND, + don't increment. Remove ; after while to fix infinite loop. + Add float and double cases. + (objc_alignof_type): Add float and double cases. + * objc/selector.c (): Use __objc_selector_names, not + __objc_selector_array. + (sel_types_match): New function. + (sel_get_typed_uid): Use sel_types_match. Change strcmp to !strcmp. + + Sun Aug 14 21:54:29 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * pa.h (ASM_OUTPUT_ALIGNED_COMMON, ASM_OUTPUT_ALIGNED_LOCAL): + Define. + (ASM_OUTPUT_COMMON, ASM_OUTPUT_LOCAL): Delete. + + * pa.c (hppa_expand_prologue): Avoid writing outside the current + stack boundary in code to handle large stack frames. + + Sun Aug 14 18:55:51 1994 Jim Wilson (wilson@cygnus.com) + + * unroll.c (loop_iterations): Use PREV_INSN not prev_nonnote_insn. + + * bsd-5.h (ASM_OUTPUT_NEWLINE): Delete. + (ASM_OUTPUT_ASCII): Define. + * mips-5.h, svr3-5.h, svr4-5.h: Likewise. + * mips.h (ASM_OUTPUT_NEWLINE): Delete. + (ASM_OUTPUT_ASCII): Don't use ASM_OUTPUT_NEWLINE. + + * va-mips.h (va_start): Add cast to __gnuc_va_list type. + + * flow.c (mark_used_regs): When adding REG_DEAD notes, check for + the case where a multiple register hard reg overlaps a register + set by the insn. + * sched.c (attach_deaths): Likewise. + * combine.c (distribute_notes, case REG_DEAD): Add another + find_reg_fusage call. + + * unroll.c (calculate_giv_inc): Handle constants loaded with IOR. + + Sun Aug 14 16:40:04 1994 Richard Stallman + + * cccp.c (skip_if_group): New arg op. All callers changed. + If output_conditionals is true, output text of failed conditionals. + (conditional_skip): New arg op. All callers changed. + (main): Handle -ifoutput option. + + Sun Aug 14 05:49:29 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * print-tree.c (print_node{,_brief}): Use REAL_VALUE_TO_DECIMAL + to print REAL_CST ifdef REAL_ARITHMETIC. + + * reload1.c (count_possible_groups) Pass CLASS as arg and only + try to find groups of that class. + + * configure: If config.guess fails and target specified, use as host. + Print a message when making a cross-compiler. + + Sat Aug 13 17:12:30 1994 Jim Wilson (wilson@cygnus.com) + + * configure (sparc-*-sunos4.0*): New configuration. + * t-sunos4: Rename file to t-sunos41. + * t-sunos40: New file. + + Sat Aug 13 13:50:22 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * reload1.c (emit_reload_insns): Handle a secondary input reload + which needs to use secondary memory too. + + Fri Aug 12 18:53:24 1994 Ian Lance Taylor (ian@cygnus.com) + + * mips/mips.c (override_options): If neither -mcpu= nor -mipsN was + used, and MIPS_CPU_DEFAULT is defined, set mips_cpu to + MIPS_CPU_DEFAULT and set mips_cpu_string to + MIPS_CPU_STRING_DEFAULT. + + Fri Aug 12 10:54:35 1994 Stan Cox (coxs@dg-rtp.dg.com) + + * m88k/dgux.h, m88k/dguxbcs.h (ASM_SPEC,CPP_SPEC): + Made -pipe work for -msvr4. Added -D*_TARGET definitions. + + * m88k.c (emit_bcnd): Improved code generated by changing cmp/bbx + instruction pair to single bcnd instruction + + Fri Aug 12 07:52:20 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (set_nonvarying_address_components): If BASE is CONST_INT, + add value to start and set BASE to const0_rtx. + (refers_to_mem_p): Don't do it here. + + * function.c (expand_function_start): Add redundant copy to + static_chain_incoming_rtx if SMALL_REGISTER_CLASS so inlining + works properly. + * integrate.c (expand_inline_function): Use single_set when + appropriate. + Delete insn that sets static_chain_incoming_rtx before its use. + (subst_constants): Treat virtual reg as constant. + + * flow.c (mark_used_regs): Only show changes size if one mode is + integral. + * stupid.c (stupid_mark_refs): Likewise. + * combine.c (simplify_rtx, case FLOAT_TRUNCATE): Remove + redundant float_truncate. + * rs6000.md (movsf): Don't truncate if not register; clean up. + + * c-decl.c (duplicate_decls): Suppress -Wredundant-decls warning + if we have already given an error. + + Thu Aug 11 18:44:25 1994 Jason Merrill (jason@deneb.cygnus.com) + + * stmt.c (expand_anon_union_decl): Fix up the alignment and mode + of the member VAR_DECLs. + + Thu Aug 11 13:36:14 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * tree.c (stabilize_reference): Handle COMPOUND_EXPR. + + * fix-header.c (write_rbrac): If NO_IMPLICIT_EXTERN_C is defined, + add extern "C" { ... } to added prototypes. (Needed for hpux.) + + Thu Aug 11 14:23:59 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (rescan): Fix botches with `-lint': the output buffer + pointer was not recached properly, leading to lost output. + Also, buffer overrun was possible. + + * cccp.c (dump_defn_1): Skip newlines and strings correctly. + + Thu Aug 11 14:13:17 1994 Niklas Hallqvist (niklas@appli.se) + + * configure (m68k-*-netbsd*): New target, like others. + + Thu Aug 11 14:09:23 1994 David Mosberger-Tang (davidm@piston.cs.arizona.edu) + + * alpha.h (FUNCTION_PROFILER): Load global pointer from $27, not $26. e + + Thu Aug 11 13:52:15 1994 Walter Misar (misar@rbg.informatik.th-darmstadt.de) + + * m68k/hp320.h (NO_DOT_IN_LABEL): Define if HPUX_ASM. + + Thu Aug 11 13:12:12 1994 David Mosberger-Tang (davidm@cs.arizona.edu) + + * alpha.h (BLOCK_PROFILER): Use $26 and $27 instead of $0 and $1. + + Thu Aug 11 13:09:36 1994 Antti Miettinen (amiettin@trshp.trs.ntc.nokia.com) + + * config/lynx.h (ASM_OUTPUT_SOURCE_LINE): Call assemble_name. + + Thu Aug 11 12:57:22 1994 Stephen L Moshier (moshier@world.std.com) + + * expr.c (expand_builtin): Relegate sin and cos to ffast-math. + + Thu Aug 11 12:45:20 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * flow.c (find_auto_inc): Ensure that all proposed changes to + insns are valid before commiting to the auto-inc. + + * calls.c (expand_call): Ensure we call force_operand on + structure_value_addr. + + * configure: Use config.guess to get default value for host, + not target. + + Thu Aug 11 12:43:24 1994 Robert Wilhelm (Robert.Wilhelm@physik.tu-muenchen.de) + + * Makefile.in (mostlyclean): Add missing -f. + + Tue Aug 9 02:02:07 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * pa.md (default set high): Do not accept function label arithmetic + as a valid operand. + (default lo_sum): Likewise. + * pa.c (hppa_legitimize_address): Do nothing with function label + arithmetic. + (emit_move_sequence): Split up function label arithmetic so that + function's address is loaded first, then constant part is added to + the function's address. + (is_function_label_plus_const): New function. + + Mon Aug 8 19:57:05 1994 Matthias Pfaller (leo@marco.de) + + * ns32k.md (all patterns that use ins/inss and ext/exts): + Disallow use of these instructions when -mnobitfield is + specified. + * ns32k.h (TARGET_BITFIELD): New macro. + (TARGET_SWITCHES): Support for TARGET_BITFIELD. + * ns32k/netbsd.h (TARGET_DEFAULT): Added -mnobitfield. + (CPP_PREDEFINES): Added -Dpc532. + (WCHAR_{TYPE, UNSIGNED, TYPE_SIZE}): Changed to match new definition + in NetBSD 1.0. + * ns32k.c (print_operand_address): A patch for 2.5.8 ended up at the + wrong place. Moved. + + Mon Aug 8 19:42:09 1994 Paul Eggert (eggert@twinsun.com) + + * cccp.c (create_definition): Warn about `#define a@', since a + diagnostic is now required (see ISO TC1's addition to + subclause 6.8). Also warn about `#define is-empty(x) (!x)'. + + Mon Aug 8 16:32:37 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * fix-header.c (write_rbrac): Set up to use fixed headers + if __USE_FIXED_HEADERS__ is defined. + + * reload1.c (emit_reload_insns): Always clear new_spill_reg_store. + + * reload.c (find_reloads): Force reload for paradoxical SUBREG + of MEM if BYTES_BIG_ENDIAN. + + * m68k/hp320.h (READONLY_DATA_SECTION): Remove definition. + + * function.c (expand_function_start): Only use + static_chain_incoming_rtx once if it is a REG and we + have SMALL_REGISTER_CLASSES. + + * local-alloc.c (find_free_reg): Fix typo in last change. + * rs6000.h (CLASS_CANNOT_CHANGE_SIZE): New macro. + + Sun Aug 7 08:54:42 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * regs.h (reg_changes_size): Add declaration. + * flow.c (reg_changes_size): New variable. + (allocate_for_life_analysis): Allocate and initialize it. + (mark_used_regs, case SUBREG): Set it. + * local-alloc.c (qty_changes_size): New variable. + (alloc_qty{,_for_scratch}, update_qty_class): Set it. + (local_alloc): Allocate it. + (find_free_reg): If CLASS_CANNOT_CHANGE_SIZE, avoid its registers + if qty_changes_size. + * global.c (find_reg) If CLASS_CANNOT_CHANGE_SIZE, avoid its + registers if reg_changes_size. + * stupid.c (regs_change_size): New variable. + (stupid_life_analysis): Alloc, init and pass it to stupid_free_reg. + (stupid_mark_regs): Set it. + (stupid_find_reg): New arg, CHANGES_SIZE; avoid regs + in CLASS_CANNOT_CHANGE_SIZE if defined and CHANGES_SIZE nonzero. + * reload.c (push_reload): Make test in LOAD_EXTEND_OP case more + precise; handle CLASS_CANNOT_CHANGE_SIZE. + (find_relods): When setting force_reloads, make LOAD_EXTEND_OP + case more precise. + * alpha.h (CLASS_CANNOT_CHANGE_SIZE): New macro. + + * reload1.c (eliminate_regs, case SUBREG): Add USE of pseudo + so we don't improperly delete an output reload. + + Fri Aug 5 15:08:39 1994 Jason Merrill (jason@deneb.cygnus.com) + + * expr.c (expand_expr, COND_EXPR case): Use truthvalue_conversion + to make the condition for running cleanups acceptable to + invert_truthvalue. + + Fri Aug 5 12:29:42 1994 Jim Wilson (wilson@cygnus.com) + + * expmed.c (expand_mult): Accept DImode for synth_mult only if + CONST_DOUBLE_HIGH is zero. Reject negative values for synth_mult + if the mode is larger than HOST_BITS_PER_INT. Don't do the + negate_variant if the mode is larger than HOST_BITS_PER_INT. + + Fri Aug 5 12:23:17 1994 Stephen L Moshier (moshier@world.std.com) + + * gbl-ctors.h (DO_GLOBAL_CTORS_BODY): Use long instead of + HOST_WIDE_INT. + + Fri Aug 5 12:18:18 1994 Kaveh R. Ghazi (ghazi@caip.rutgers.edu) + + * configure: In subdirectories, make link to include directory. + * Makefile.in (distclean): Delete it. + + Thu Aug 4 17:21:02 1994 Jason Merrill (jason@deneb.cygnus.com) + + * expr.c (defer_cleanups_to): Put back line which was mistakenly + removed. + + Wed Aug 3 21:37:31 1994 Doug Evans (dje@cygnus.com) + + * sparc.c (v9 sparc_builtin_saveregs): Save quadword fp regs on + 16 byte boundaries. Handle non-zero number of named fp args. + * va-sparc.h (v9 va_start): Pass an arg to __builtin_next_arg. + (v9 va_arg): Advance over float's. + + Wed Aug 3 11:10:32 1994 Ian Lance Taylor (ian@mole.gnu.ai.mit.edu) + + * fixincludes: Changes for glibc. In the main loop, don't fix + files which contain the string ``This file is part of the GNU C + Library''. Don't include in if + contains the string ``__need___va_list''. In , don't + change GNUC_VA_LIST to GNUC_DUMMY_VA_LIST. Don't add extern "C" + to if it contains the string ``__BEGIN_DECLS''. Don't + add multiple inclusion protection to or if + they contain the string ``#ifndef''. + + Tue Aug 2 18:38:46 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * cse.c (simplify_unary_operation): Clean up some mode and + size checks with CONST_DOUBLEs; TRUNCATE should do nothing. + + * combine.c (subst_prev_insn): Remove variable and all uses. + + Tue Aug 2 14:42:29 1994 Doug Evans (dje@canuck.cygnus.com) + + * sparc.h (V9_SWITCHES): Add -mmedlow, -mmedany. + (TARGET_OPTIONS): Delete. + (CONDITIONAL_REGISTER_USAGE): Don't unfix %g4 if -mmedany. + * sparc.c (sparc_code_model): Delete. + (sparc_override_options): Code model flags only useable with v9. + + * sparc.h (enum reg_class): New values EXTRA_FP_REGS, + GENERAL_OR_EXTRA_FP_REGS for the v9 case. + (REG_CLASS_NAMES): Likewise. + (REG_CLASS_CONTENTS): Likewise. + (REGNO_REG_CLASS): Handle EXTRA_FP_REGS. + (REG_CLASS_FROM_LETTER): Likewise, as `e'. + Treat `e' like `f' in v8 case. + (FP_REG_CLASS_P): New macro. + (PREFERRED_RELOAD_CLASS): Use it. + (SECONDARY_INPUT_RELOAD_CLASS, SECONDARY_OUTPUT_RELOAD_CLASS, + SECONDARY_MEMORY_NEEDED, CLASS_MAX_NREGS, REGISTER_MOVE_COST): + Likewise. + * sparc.md (all DF/TFmode patterns): Use `e' in contraint field + instead of `f'. + + Mon Aug 1 20:05:51 1994 Roland McGrath + + * config/i386/gnu.h: New file. + * configure (i[34]86-*-gnu*): Deal with this on its own, not like + i[34]86-*-mach*. Use i386/gnu.h and t-libc-ok; set gnu_ld and + gas, and disable fixincludes. + + Mon Aug 1 19:27:44 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * tree.c (permanent_allocation): When freeing to + momentary_function_firstobj, set momentary_firstobj to be + the next available location (i.e., momentary_function_firstobj). + + Mon Aug 1 18:52:40 1994 Chris Arthur (csa@gnu.ai.mit.edu) + + * stddef.h: Handle _BSD_WCHAR_T_ like _WCHAR_T_, since + at least BSD/386 1.1 uses the former instead of the latter. + If _BSD_RUNE_T_ is defined, then define rune_t when we define + wchar_t. Test definedness of _GCC_SIZE_T as well as + _GCC_SIZE_T_; likewise for _GCC_PTRDIFF_T and _GCC_WCHAR_T. + + Mon Aug 1 05:20:44 1994 Jeffrey A. Law (law@snake.cs.utah.edu) + + * pa-ghpux.h, pa-hpux.h (LINK_SPEC): Any -g argument implies + static linking. + + Sun Jul 31 17:19:37 1994 Jason Merrill (jason@deneb.cygnus.com) + + * integrate.c (expand_inline_function): Don't fall down trying to + pass things by invisible reference. + + Sun Jul 31 06:56:46 1994 Pat Rankin (rankin@eql.caltech.edu) + + * cccp.c (my_strerror): New function. + (error_from_errno, perror_with_name): Use it. + + Sat Jul 30 12:59:01 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * fold-const.c (fold_truthop): Apply masks to constants. + + * print-tree.c (print_node{,_brief}): Use correct printf code to + print INTEGER_CST if HOST_WIDE_INT is wider than int. + + * expmed.c ({store,extract}_bit_field): Don't use bitfield insn + if OP0 is register and bitfield spans it. + + * m88k.c (arith64_operand): Integer CONST_DOUBLE is not DImode. + * sparc.c (reg_or_0_operand): Likewise. + * ns32k.c, pa.c (print_operand): Likewise. + * fx80.h, gmicro.h, ns32/{genix,merlin}.h (PRINT_OPERAND): Likewise. + * m68k/crds.h, m68k/news.h, pyr.h (PRINT_OPERAND): Likewise. + + * alpha.h (CASE_VECTOR_PC_RELATIVE): Define. + (ASM_OUTPUT_ADDR_VEC_ELT): Abort. + (ASM_OUTPUT_ADDR_DIFF_ELT): Now what used to be previous definition. + * alpha.md (tablejump): Rework to look like normal add but verify + that label is for next insn and is tablejump; look for ADDR_DIFF_ELT. + * cse.c (fold_rtx, case MEM): Surround TRUNCATE for jump table + entry with a CONST. + (fold_rtx, case '1'): Handle operand 0 of a CONST. + (fold_rtx, case PLUS): Handle (const (minus (label_ref) (label_ref))). + + Fri Jul 29 19:27:17 1994 Lee Iverson (leei@ai.sri.com) + + * c-decl.c (finish_decl): Preserve initialializer if iterator. + + Fri Jul 29 19:07:23 1994 Hallvard B Furuseth (h.b.furuseth@usit.uio.no) + + * libgcc2.c: Add declaration of ctime. + * bc-emit.c (bc_sym_write): Change %d to %lu in printf calls. + * fix-header.c (write_{l,r}brac): Specify return type of int. + * tree.c (change_main_variant): Return type now void. + * varasm.c (bc_output_constructor): Return type now rtx. + + Fri Jul 29 18:33:48 1994 Ken Duda (kjd@cache.crc.ricoh.com) + + * c-typeck.c (build_unary_op, case *INCREMENT_EXPR): + Add size in bytes, not value of sizeof. + + Fri Jul 29 17:36:38 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * function.c (expand_function_start): Initialize VALUE_ADDRESS. + + * romp.md (tst?f): Use CONST0_RTX instead of incorrect call + to immed_real_const_1. + + * expr.c (move_block_to_reg): Do nothing if NREGS == 0. + + Fri Jul 29 17:17:18 1994 Tom Tromey (tromey@busco.lanl.gov) + + * cccp.c (special_symbol, do_xifdef): Don't access value.defn + of a T_CONST. + + Thu Jul 28 17:19:32 1994 Jason Merrill (jason@deneb.cygnus.com) + + * gbl-ctors.h (DO_GLOBAL_CTORS_BODY): Reverse order of execution + of constuctor lists. + * config/svr3.h (DO_GLOBAL_CTORS_BODY): Ditto. + + * libgcc2.c (__do_global_dtors): Reverse order of execution of + destructor lists. + + Thu Jul 28 19:56:30 1994 Jim Pendergraft (jimp@dg-rtp.dg.com) + + * dwarfout.c (output_decl, case FUNCTION_DECL): Corrected + and simplified code that determined when to generate + varargs or ANSI stdargs variable length parameter list + DWARF information. + + Thu Jul 28 19:38:57 1994 Andreas Schwab (schwab@issan.informatik.uni-dortmund.de) + + * m68k.md (extv, extzv): In patterns that will use movb and + movw, ensure size is 8 or 16. + + Thu Jul 28 19:28:31 1994 David Robinson (drtr@mail.ast.cam.ac.uk) + + * expr.c (expand_expr, case CONJ_EXPR): Use correct mode for + parts of a complex expression. + + * optabs.c (expand_binop, case MULT [complex]) Fix typo. + + Thu Jul 28 19:21:38 1994 Uwe Seimet (seimet@chemie.uni-kl.de) + + * am68k/atari.h (FUNCTION_VALUE): New override. + + Thu Jul 28 17:27:38 1994 Paul Eggert (eggert@twinsun.com) + + * Makefile.in (c-lex.o, distdir-start): + Depend on $(srcdir)/c-gperf.h, not c-gperf.h. + + Thu Jul 28 15:14:33 1994 Oliver Kellogg (okellogg@salyko.cube.net) + + * m1750.inc (DNR.M): Add missing macro. + + Thu Jul 28 13:02:56 1994 Kresten Krab Thorup (krab@akvavit) + + * objc/misc.c (__objc_xcalloc): Remove declaration of bzero. + + Thu Jul 28 07:29:52 1994 Markus Wild (mw@eunet.ch) + + * c-common.c (decl_attributes): Correct string check for "format" + to include unsigned and signed char. + + Thu Jul 28 07:11:36 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * reload1.c (compare_spill_regs): Simplify and return zero if + registers are the same. + + * c-decl.c (finish_struct): Don't look at alignment of error_mark_node. + + * combine.c (try_combine): Don't make a MULT if none of the insns + in our input had one. + + Wed Jul 27 19:06:53 1994 R Bowler (rbowler@cix.compulink.co.uk) + + * i370/mvs.h (ASM_OUTPUT_ASCII): Fix bug when first character + of string constant is single quote. + + Wed Jul 27 22:44:32 1994 Jason Merrill (jason@deneb.cygnus.com) + + * m68k/next.h: #undef PCC_STATIC_STRUCT_RETURN. + + * alpha/alpha.h: #define NO_IMPLICIT_EXTERN_C. + + Wed Jul 27 14:06:37 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expmed.c (expand_mult): Properly set ADD_TARGET for add_variant. + + * alpha.h (INITIAL_ELIMINATION_OFFSET): Properly compute offset + between AP and SP when get_frame_size and + current_function_pretend_args_size are not a multiple of 16 bytes. + + * expmed.c (expand_divmod): Don't make REG_NOTE if last insn's + destination isn't QUOTIENT. + + Tue Jul 26 19:45:54 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * expr.c (expand_expr, case ARRAY_REF): Don't fold L"foo"[2]. + + Tue Jul 26 14:10:52 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * config.sub: Refer to NeXT's operating system as nextstep. + + Tue Jul 26 13:50:37 1994 Jim Wilson (wilson@cygnus.com) + + * c-typeck.c (process_init_element): Do not call push_init_level + if the value is error_mark_node. + + * iris5.h (NO_IMPLICIT_EXTERN_C): Define. + + Mon Jul 25 00:20:36 1994 Chris Arthur (csa@gnu.ai.mit.edu) + + * configure (canon_target): add cases to recognize BSD/386 + specifically, so we can use a tm_file that will cause __bsdi__ + to get defined (since emacs, among other things, needs it). + + * config/i386/bsd386.h: New. Use 386bsd.h, and just override + CPP_PREDEFINES (add -Dbsdi) and WCHAR stuff. + + Sat Jul 23 16:30:12 1994 Kaveh R. Ghazi (ghazi@caip.rutgers.edu) + + * fixinc.svr4: Change i860 in #if to __i860__, as with other CPUs. + + Fri Jul 22 14:33:59 1994 Doug Evans (dje@cygnus.com) + + * h8300.md (andhi3, iorhi3, xorhi3): Change constraint on + operand 2 from `i' to `n'. + + Fri Jul 22 09:30:39 1994 DJ Delorie (dj@ctron.com) + + * configure.bat: move code to config/msdos/* (simplification) + + * config/msdos/configure.bat [new file]: moved most processing + here so that as things get more complicated with the language + breakouts, the top directory won't get too messy. Sed script + broken out to simplify processing and avoid quoting errors. + * config/msdos/top.sed [new file]: sed script to change Makefile.in + to Makefile in top directory (currently used for cp directory also) + sed commands changed to handle language breakout + + * gcc.c (pexecute): use spawn*() for djgpp to ensure that quotes + are properly preserved. Response file code left for 16-bit + compilers, which can't handle the long command lines that gcc + may generate. + + * config/i386/go32.h: define NO_IMPLICIT_EXTERN_C. + + Thu Jul 21 23:19:03 1994 Steve Chamberlain (sac@wombat.gnu.ai.mit.edu) + + * sh/sh.h (TARGET_SWITCHES, PACKSTRUCT_BIT, STRUCTURE_SIZE_BOUNDARY): + parse and handle new option. + (LEGITIMATE_CONSTANT_P): LABEL_REFs are no longer illegal. + (WCHAR_TYPE, WCHAR_TYPE_SIZE): New definitions. + (HANDLE_PRAGMA): Has return. + + * sh/sh.c (add_function, seen_function): Experimental code to + generate bsrs. + (handle_pragma): Return final char. + (expand_acall): Handle TARGET_BSR. + (general_movdst_operand, general_movsrc_operand): Allow ok + autoinc/dec. + (bsr_operand): New function. + (fixit): Need to fix LABEL_REFs. + + * sh/sh.md (addc): Simplify. + (adddi3, subdi3, negdi3): Use operand_subword. + (subc, negc): New pattern. + (shifts): Fix constraints. + + Thu Jul 21 17:59:43 1994 Jim Wilson (wilson@cygnus.com) + + * objc-act.c (build_module_descriptor): Don't set DECL_EXTERNAL on + current_function_decl. + + * combine.c (simplify_rtx): For (not (xor X C)) generate new rtx + instead of modifying old rtx. + + * c-decl.c (start_function): If old_decl is NULL, then set it to + the implicit decl if any. Delete superfluous test from warn missing + prototypes code. For warn missing declarations code, only warn if + previous decl is implicit. + + Thu Jul 21 17:47:05 1994 Paul Eggert (eggert@twinsun.com) + + * fold-const.c (fold): Don't fold X-X to 0 if X is floating point + and !flag_fast_math. + + Thu Jul 21 02:07:45 1994 Charles Levert (charles@comm.polymtl.ca) + + * Makefile.in (stmp-multilib): Rework to handle make -n. + (stmp-multilib-sub): New target. + + Tue Jul 19 23:14:42 1994 Larry Jones (larry.jones@sdrc.com) + + * configure (i[34]86-*-isc*): Treat isc4 like isc3. + Remove references to nonexistant files and add extra_parts + when needed. + (i[34]86-*-solaris2*): Remove reference to nonexistant + t-sco and use extra_parts instead. + (i[34]86-*-sysv*, i860-*-sysv3*, m68k-*-sysv3*, m68k-ncr-sysv*): + Replace t-svr3 with extra_parts. + + Tue Jul 19 20:31:34 1994 Doug Evans (dje@cygnus.com) + + * configure (find lang subdirs loop): Try to work around an + apparent bug in bash 1.12 on linux. + + * Makefile.in (clean): Remove multilib build dirs. + + * h8300.c (print_operand, default case): Handle SFmode regs. + + Mon Jul 18 22:02:53 1994 Jim Wilson (wilson@cygnus.com) + + * sparc.c (call_operand): Use symbolic_operand not CONSTANT_P. + (call_operand_address): Likewise. + * sparc.md (call*): Use symbolic_operand not immediate_operand. + Use 's' constraint not 'i' constraint. + + * toplev.c (rest_of_compilation): Clear DECL_ABSTRACT_ORIGIN if + clear DECL_INLINE. + + * global.c (find_reg): Store divide results in temporary variables. + + * gcc.c (process_command): When have -BstageN option, pass include + not stageN/../include to preprocessor. + + Mon Jul 18 21:58:27 1994 Torbjorn Granlund (tege@tiny.cygnus.com) + + * loop.c (move_movables): Aviod lossage when CALL_INSN_FUNCTION_USAGE + is NULL. + + Mon Jul 18 20:53:54 1994 Ian Lance Taylor (ian@cygnus.com) + + * fixincludes: Rework required loop to avoid crash on decstation. + Thu Jul 14 09:42:23 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/INSTALL gcc-2.6.1/INSTALL *** gcc-2.6.0/INSTALL Thu Jul 14 12:52:00 1994 --- gcc-2.6.1/INSTALL Sun Oct 30 08:08:48 1994 *************** *** 29,55 **** libraries which have bugs. ! 3. Specify the host and target machine configurations. You do this by ! running the file `configure' with appropriate arguments. ! The `configure' script searches subdirectories of the source ! directory for other compilers that are to be integrated into GNU ! CC. The GNU compiler for C++, called G++ is in a subdirectory ! named `cp'. `configure' inserts rules into `Makefile' to build ! all of those compilers. If you are building a compiler to produce code for the machine it ! runs on, specify the "configuration name" with the `--target' ! option; the host will default to be the same as the target. (If ! you are building a cross-compiler, see *Note Cross-Compiler::.) Here is an example: ! ./configure --target=sparc-sun-sunos4.1 ! ! If you run `configure' without specifying configuration arguments, ! `configure' tries to guess the type of host you are on, and uses ! that configuration type for both host and target. So you don't ! need to specify a configuration, for building a native compiler, ! unless `configure' cannot figure out what your configuration is. A configuration name may be canonical or it may be more or less --- 29,56 ---- libraries which have bugs. ! 3. Specify the host, build and target machine configurations. You do ! this by running the file `configure'. ! The "build" machine is the system which you are usinfg, the "host" ! machine is the system where you want to run the resulting compiler ! (normally the build machine), and the "target" machine is the ! system for which you want the compiler to generate code. If you are building a compiler to produce code for the machine it ! runs on (a native compiler), you normally do not need to specify ! any operands to `configure'; it will try to guess the type of ! machine you are on and use that as the build, host and target ! machines. So you don't need to specify a configuration when ! building a native compiler unless `configure' cannot figure out ! what your configuration is or guesses wrong. ! ! In those cases, specify the build machine's "configuration name" ! with the `--build' option; the host and target will default to be ! the same as the build machine. (If you are building a ! cross-compiler, see *Note Cross-Compiler::.) Here is an example: ! ./configure --build=sparc-sun-sunos4.1 A configuration name may be canonical or it may be more or less *************** *** 110,116 **** effect. ! On the systems listed above (except for the HP-PA and for ISC ! on the 386), if you use GAS, you should also use the GNU ! linker (and specify `--with-gnu-ld'). `--with-gnu-ld' --- 111,117 ---- effect. ! On the systems listed above (except for the HP-PA, for ISC on ! the 386, and for `mips-sgi-irix5.*'), if you use GAS, you ! should also use the GNU linker (and specify `--with-gnu-ld'). `--with-gnu-ld' *************** *** 147,150 **** --- 148,159 ---- debugging information does not. + `--with-stabs' is also meaningful on 386 systems running + SVR4. It selects use of stabs debugging information embedded + in ELF output. The C++ compiler currently (2.6.0) does not + support the DWARF debugging information normally used on 386 + SVR4 platforms; stabs provide a workable alternative. This + requires gas and gdb, as the normal SVR4 tools can not + generate or interpret stabs. + `--nfp' On certain systems, you must specify whether the machine has *************** *** 154,157 **** --- 163,172 ---- other systems where it could usefully make a difference. + The `configure' script searches subdirectories of the source + directory for other compilers that are to be integrated into GNU + CC. The GNU compiler for C++, called G++ is in a subdirectory + named `cp'. `configure' inserts rules into `Makefile' to build + all of those compilers. + Here we spell out what files will be set up by `configure'. Normally you need not be concerned with these files. *************** *** 203,215 **** exception: the directory `/usr/local/include' is searched for header files no matter where you install the compiler. To override ! this name, use thge `--local-prefix' option below. 5. Specify `--local-prefix=DIR' if you want the compiler to search ! directory `DIR/include' for header files *instead* of ! `/usr/local/include'. (This is for systems that have different ! conventions for where to put site-specific things.) ! Unless you have a convention other than `/usr/local' for ! site-specific files, it is a bad idea to specify `--local-prefix'. 6. Make sure the Bison parser generator is installed. (This is --- 218,237 ---- exception: the directory `/usr/local/include' is searched for header files no matter where you install the compiler. To override ! this name, use the `--local-prefix' option below. 5. Specify `--local-prefix=DIR' if you want the compiler to search ! directory `DIR/include' for locally installed header files ! *instead* of `/usr/local/include'. ! You should specify `--local-prefix' *only* if your site has a ! different convention (not `/usr/local') for where to put ! site-specific files. ! ! *Do not* specify `/usr' as the `--local-prefix'! The directory ! you use for `--local-prefix' *must not* contain any of the ! system's standard header files. If it did contain them, certain ! programs would be miscompiled (including GNU Emacs, on certain ! targets), because this would override and nullify the header file ! corrections made by the `fixincludes' script. 6. Make sure the Bison parser generator is installed. (This is *************** *** 263,273 **** the problem happens. - If you are building with a previous GNU C compiler, do not use - `CC=gcc' on the make command or by editing the Makefile. Instead, - use a full pathname to specify the compiler, such as - `CC=/usr/local/bin/gcc'. This is because make might execute the - `gcc' in the current directory before all of the compiler - components have been built. - 9. If you are building a cross-compiler, stop here. *Note Cross-Compiler::. --- 285,288 ---- *************** *** 437,444 **** Here are the possible CPU types: ! 1750a, a29k, alpha, arm, cN, clipper, elxsi, h8300, hppa1.0, ! hppa1.1, i370, i386, i486, i860, i960, m68000, m68k, m88k, mips, ! ns32k, pyramid, romp, rs6000, sh, sparc, sparclite, sparc64, vax, ! we32k. Here are the recognized company names. As you can see, customary --- 452,459 ---- Here are the possible CPU types: ! 1750a, a29k, alpha, arm, cN, clipper, dsp16xx, elxsi, h8300, ! hppa1.0, hppa1.1, i370, i386, i486, i860, i960, m68000, m68k, m88k, ! mips, ns32k, pyramid, romp, rs6000, sh, sparc, sparclite, sparc64, ! vax, we32k. Here are the recognized company names. As you can see, customary *************** *** 459,464 **** 386bsd, aix, acis, amigados, aos, aout, bosx, bsd, clix, ctix, cxux, dgux, dynix, ebmon, elf, esix, freebsd, hms, genix, gnu, ! hiux, hpux, iris, irix, isc, linux, luna, lynxos, mach, minix, ! msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose, riscix, riscos, rtu, sco, solaris, sunos, sym, sysv, ultrix, unicos, uniplus, unos, vms, vxworks, xenix. --- 474,479 ---- 386bsd, aix, acis, amigados, aos, aout, bosx, bsd, clix, ctix, cxux, dgux, dynix, ebmon, elf, esix, freebsd, hms, genix, gnu, ! gnu/linux, hiux, hpux, iris, irix, isc, luna, lynxos, mach, minix, ! msdos, mvs, netbsd, newsos, nindy, ns, osf, osfrose, ptx, riscix, riscos, rtu, sco, solaris, sunos, sym, sysv, ultrix, unicos, uniplus, unos, vms, vxworks, xenix. *************** *** 500,505 **** Thus, if you specify `m68k-local', configuration uses files ! `local.md', `local.h', `local.c', `xm-local.h', `t-local', and ! `x-local', all in the directory `config/m68k'. Here is a list of configurations that have special treatment or --- 515,520 ---- Thus, if you specify `m68k-local', configuration uses files ! `m68k.md', `local.h', `m68k.c', `xm-local.h', `t-local', and `x-local', ! all in the directory `config/m68k'. Here is a list of configurations that have special treatment or *************** *** 507,517 **** `1750a-*-*' ! MIL-STD-1750A processors. This port is preliminary. You should ignore a fatal error during the building of libgcc (libgcc is not yet implemented for the 1750A.) ! The Tektronix MIL-STD-1750A Assembler requires the file ! `m1750.inc', which is found in the directory `config/1750a'. GNU CC produced the same sections as the Fairchild F9450 C --- 522,539 ---- `1750a-*-*' ! MIL-STD-1750A processors. + Starting with GCC 2.6.1, the MIL-STD-1750A cross configuration no + longer supports the Tektronix Assembler, but instead produces + output for `as1750', an assembler/linker available under the GNU + Public License for the 1750A. Contact *okellogg@salyko.cube.net* + for more details on obtaining `as1750'. A similarly licensed + simulator for the 1750A is available from same address. + You should ignore a fatal error during the building of libgcc (libgcc is not yet implemented for the 1750A.) ! The `as1750' assembler requires the file `ms1750.inc', which is ! found in the directory `config/1750a'. GNU CC produced the same sections as the Fairchild F9450 C *************** *** 656,659 **** --- 678,684 ---- compiling GNU C. Please contact `mrs@cygnus.com' for more details. + `dsp16xx' + A port to the AT&T DSP1610 family of processors. + `h8300-*-*' The calling convention and structure layout has changed in release *************** *** 720,726 **** have a higher-quality port for this machine soon. ! `i386-*-linux' Bash-1.12 has a bug that causes configure to fail. The symptom is ! that the c++ subdirectory, cp, is not configured. Bash-1.14 and later work fine. --- 745,751 ---- have a higher-quality port for this machine soon. ! `i386-*-gnu/linux' Bash-1.12 has a bug that causes configure to fail. The symptom is ! that the c++ subdirectory, `cp', is not configured. Bash-1.14 and later work fine. *************** *** 734,739 **** `i386-*-isc' ! It may be good idea to link with GNU malloc instead of the malloc ! that comes with the system. `i386-*-esix' --- 759,767 ---- `i386-*-isc' ! It may be a good idea to link with GNU malloc instead of the ! malloc that comes with the system. ! ! In ISC version 4.1, `sed' core dumps when building `deduced.h'. ! Use the version of `sed' from version 4.0. `i386-*-esix' *************** *** 745,749 **** binutils version 2.2 or later. ! `i386-sequent' Go to the Berkeley universe before compiling. In addition, you probably need to create a file named `string.h' containing just --- 773,777 ---- binutils version 2.2 or later. ! `i386-sequent-bsd' Go to the Berkeley universe before compiling. In addition, you probably need to create a file named `string.h' containing just *************** *** 750,753 **** --- 778,787 ---- one line: `#include '. + `i386-sequent-ptx1*' + Sequent DYNIX/ptx 1.x. + + `i386-sequent-ptx2*' + Sequent DYNIX/ptx 2.x. + `i386-sun-sunos4' You may find that you need another version of GNU CC to begin *************** *** 856,860 **** HP 9000 series 300 or 400 running HP-UX. HP-UX version 8.0 has a bug in the assembler that prevents compilation of GNU CC. To fix ! it, get patch PHCO_0800 from HP. In addition, if you wish to use gas `--with-gnu-as' you must use --- 890,894 ---- HP 9000 series 300 or 400 running HP-UX. HP-UX version 8.0 has a bug in the assembler that prevents compilation of GNU CC. To fix ! it, get patch PHCO_4484 from HP. In addition, if you wish to use gas `--with-gnu-as' you must use *************** *** 888,896 **** `m88k-*-dgux' ! Motorola m88k running DG/UX. To build native or cross compilers on ! DG/UX, you must first change to the 88open BCS software development ! environment. This is done by issuing this command: ! ! eval `sde-target m88kbcs` `m88k-tektronix-sysv3' --- 922,937 ---- `m88k-*-dgux' ! Motorola m88k running DG/UX. To build 88open BCS native or cross ! compilers on DG/UX, specify the configuration name as ! `m88k-*-dguxbcs' and build in the 88open BCS software development ! environment. To build ELF native or cross compilers on DG/UX, ! specify `m88k-*-dgux' and build in the DG/UX ELF development ! environment. You set the software development environment by ! issuing `sde-target' command and specifying either `m88kbcs' or ! `m88kdguxelf' as the operand. ! ! If you do not specify a configuration name, `configure' guesses the ! configuration based on the current software development ! environment. `m88k-tektronix-sysv3' *************** *** 992,997 **** reordering--perhaps GNU CC itself was miscompiled as a result. ! See the file `README.IRIX5' for information on how to make ! debugging work. `mips-sony-sysv' --- 1033,1039 ---- reordering--perhaps GNU CC itself was miscompiled as a result. ! To enable debugging under Irix 5, you must use GNU as 2.5 or later, ! and use the -with-gnu-as configure option when configuring gcc. ! GNU as is distributed as part of the binutils package. `mips-sony-sysv' *************** *** 1137,1141 **** directory with the `--srcdir' option, like this: ! ../gcc/configure --srcdir=../gcc sun3 The directory you specify with `--srcdir' need not be the same as --- 1179,1183 ---- directory with the `--srcdir' option, like this: ! ../gcc/configure --srcdir=../gcc OTHER OPTIONS The directory you specify with `--srcdir' need not be the same as *************** *** 1164,1169 **** description needs to be updated to take advantage of it. ! * Cross-compilation between machines of different word sizes has not ! really been addressed yet. Since GNU CC generates assembler code, you probably need a --- 1206,1211 ---- description needs to be updated to take advantage of it. ! * Cross-compilation between machines of different word sizes is ! somewhat problematic and sometimes does not work. Since GNU CC generates assembler code, you probably need a *************** *** 1202,1212 **** To build GNU CC as a cross-compiler, you start out by running ! `configure'. You must specify two different configurations, the host ! and the target. Use the `--host=HOST' option for the host and ! `--target=TARGET' to specify the target type. For example, here is how ! to configure for a cross-compiler that runs on a hypothetical Intel 386 ! system and produces code for an HP 68030 system running BSD: ! ./configure --target=m68k-hp-bsd4.3 --host=i386-bozotheclone-bsd4.3 Tools and Libraries for a Cross-Compiler --- 1244,1254 ---- To build GNU CC as a cross-compiler, you start out by running ! `configure'. Use the `--target=TARGET' to specify the target type. If ! `configure' was unable to correctly identify the system you are running ! on, also specify the `--build=BUILD' option. For example, here is how ! to configure for a cross-compiler that produces code for an HP 68030 ! system running BSD on a system that `configure' can correctly identify: ! ./configure --target=m68k-hp-bsd4.3 Tools and Libraries for a Cross-Compiler diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/Makefile.in gcc-2.6.1/Makefile.in *** gcc-2.6.0/Makefile.in Wed Jul 13 18:47:13 1994 --- gcc-2.6.1/Makefile.in Fri Oct 28 19:00:38 1994 *************** *** 506,510 **** _fixtfdi _fixunstfdi _floatditf \ __gcc_bcmp _varargs _eprintf _op_new _op_vnew _new_handler _op_delete \ ! _op_vdel _bb _shtab _clear_cache _trampoline __main _exit _ctors # Header files that are made available under the same name --- 506,511 ---- _fixtfdi _fixunstfdi _floatditf \ __gcc_bcmp _varargs _eprintf _op_new _op_vnew _new_handler _op_delete \ ! _op_vdel _bb _shtab _clear_cache _trampoline __main _exit _ctors _eh \ ! _pure # Header files that are made available under the same name *************** *** 859,893 **** dir=`echo $$i | sed -e 's/;.*$$//'`; \ flags=`echo $$i | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`; \ - rm -f $${dir}/libgcc.a $(LIBGCC2); \ $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \ AR="$(AR)" AR_FLAGS="$(AR_FLAGS)" \ HOST_PREFIX="$(HOST_PREFIX)" HOST_PREFIX_1="$(HOST_PREFIX_1)" \ ! LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS) $${flags}" $(LIBGCC2); \ ! if [ $$? -eq 0 ] ; then true; else exit 1; fi; \ ! if [ x$(LIBGCC1) != xlibgcc1-asm.a ]; \ ! then true; \ ! else (rm -f $(LIBGCC1); \ ! $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \ ! AR="$(AR)" AR_FLAGS="$(AR_FLAGS)" \ ! HOST_PREFIX="$(HOST_PREFIX)" \ ! HOST_PREFIX_1="$(HOST_PREFIX_1)" \ ! LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS) $${flags}" $(LIBGCC1) ) \ ! fi; \ ! if [ $$? -eq 0 ] ; then true; else exit 1; fi; \ ! rm -rf tmpcopy; \ ! mkdir tmpcopy; \ ! if [ x$(LIBGCC1) != x ]; \ ! then (cd tmpcopy; $(AR) x ../$(LIBGCC1)); \ ! else true; \ ! fi; \ ! (cd tmpcopy; $(AR) x ../$(LIBGCC2)); \ ! (cd tmpcopy; $(AR) $(AR_FLAGS) ../tmplibgcc.a *.o); \ ! rm -rf libgcc2.a tmpcopy; \ ! if $(RANLIB_TEST) ; then $(RANLIB) tmplibgcc.a; else true; fi; \ ! if [ -d $${dir} ]; then true; else mkdir $${dir}; fi; \ ! mv tmplibgcc.a $${dir}/libgcc.a; \ done touch stmp-multilib objc-runtime: libobjc.a --- 860,905 ---- dir=`echo $$i | sed -e 's/;.*$$//'`; \ flags=`echo $$i | sed -e 's/^[^;]*;//' -e 's/@/ -/g'`; \ $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \ AR="$(AR)" AR_FLAGS="$(AR_FLAGS)" \ + RANLIB="$(RANLIB)" RANLIB_TEST="$(RANLIB_TEST)" \ HOST_PREFIX="$(HOST_PREFIX)" HOST_PREFIX_1="$(HOST_PREFIX_1)" \ ! LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS) $${flags}" \ ! LIBGCC1="$(LIBGCC1)" LIBGCC2="$(LIBGCC2)" \ ! dir="$${dir}" stmp-multilib-sub; \ done touch stmp-multilib + # Subroutine of stmp-multilib so make -n works. + stmp-multilib-sub: + rm -f $(dir)/libgcc.a $(LIBGCC2) + $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \ + AR="$(AR)" AR_FLAGS="$(AR_FLAGS)" \ + HOST_PREFIX="$(HOST_PREFIX)" HOST_PREFIX_1="$(HOST_PREFIX_1)" \ + LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS)" $(LIBGCC2) + if [ x$(LIBGCC1) != xlibgcc1-asm.a ]; \ + then true; \ + else rm -f $(LIBGCC1); \ + fi + if [ x$(LIBGCC1) != xlibgcc1-asm.a ]; \ + then true; \ + else \ + $(MAKE) GCC_FOR_TARGET="$(GCC_FOR_TARGET)" \ + AR="$(AR)" AR_FLAGS="$(AR_FLAGS)" \ + HOST_PREFIX="$(HOST_PREFIX)" HOST_PREFIX_1="$(HOST_PREFIX_1)" \ + LIBGCC2_CFLAGS="$(LIBGCC2_CFLAGS)" $(LIBGCC1); \ + fi + rm -rf tmplibgcc.a tmpcopy + mkdir tmpcopy + if [ x$(LIBGCC1) != x ]; \ + then (cd tmpcopy; $(AR) x ../$(LIBGCC1)); \ + else true; \ + fi + (cd tmpcopy; $(AR) x ../$(LIBGCC2)) + (cd tmpcopy; $(AR) $(AR_FLAGS) ../tmplibgcc.a *.o) + rm -rf libgcc2.a tmpcopy + if $(RANLIB_TEST) ; then $(RANLIB) tmplibgcc.a; else true; fi + if [ -d $(dir) ]; then true; else mkdir $(dir); fi + mv tmplibgcc.a $(dir)/libgcc.a + objc-runtime: libobjc.a *************** *** 955,959 **** c-lang.o : c-lang.c $(CONFIG_H) $(TREE_H) c-lex.o : c-lex.c $(CONFIG_H) $(TREE_H) c-lex.h c-tree.h c-parse.h \ ! input.h flags.h c-gperf.h c-aux-info.o : c-aux-info.c $(CONFIG_H) $(TREE_H) c-tree.h flags.h c-convert.o : c-convert.c $(CONFIG_H) $(TREE_H) flags.h --- 967,971 ---- c-lang.o : c-lang.c $(CONFIG_H) $(TREE_H) c-lex.o : c-lex.c $(CONFIG_H) $(TREE_H) c-lex.h c-tree.h c-parse.h \ ! input.h flags.h $(srcdir)/c-gperf.h c-aux-info.o : c-aux-info.c $(CONFIG_H) $(TREE_H) c-tree.h flags.h c-convert.o : c-convert.c $(CONFIG_H) $(TREE_H) flags.h *************** *** 1115,1118 **** --- 1127,1132 ---- $(RTL_H) regs.h hard-reg-set.h real.h insn-config.h conditions.h \ insn-flags.h output.h insn-attr.h insn-codes.h + $(CC) -c $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ + $(MAYBE_TARGET_DEFAULT) aux-output.c # Build auxiliary files that support ecoff format. *************** *** 1761,1765 **** -rm -f tmp-float.h tmp-gcc.xtar.gz -rm -f tmp-foo1 tmp-foo2 tmp-proto.* tmp-unproto.1 tmp-SYSCALLS.s ! -rm tmp-c-parse.y tmp-objc-parse.y tmp-gperf.h # Delete the stamp files. -rm -f stamp-* tmp-* --- 1775,1779 ---- -rm -f tmp-float.h tmp-gcc.xtar.gz -rm -f tmp-foo1 tmp-foo2 tmp-proto.* tmp-unproto.1 tmp-SYSCALLS.s ! -rm -f tmp-c-parse.y tmp-objc-parse.y tmp-gperf.h # Delete the stamp files. -rm -f stamp-* tmp-* *************** *** 1802,1806 **** --- 1816,1826 ---- -rm -rf stmp-* include objc-headers -rm -f */stmp-* + # Delete files used by the "multilib" facility (including libgcc subdirs). -rm -f multilib.h tmpmultilib* + -if [ "x$(MULTILIB_DIRNAMES)" != x ] ; then \ + rm -rf $(MULTILIB_DIRNAMES); \ + else if [ "x$(MULTILIB_OPTIONS)" != x ] ; then \ + rm -rf `echo $(MULTILIB_OPTIONS) | sed -e 's/\// /g'`; \ + fi ; fi # Delete all files that users would normally create *************** *** 1811,1815 **** -rm -f Makefile *.oaux -rm -fr stage1 stage2 stage3 stage4 ! -rm -f */stage1 */stage2 */stage3 */stage4 -rm -f objc-parse.output -rm -f c-parse.output --- 1831,1835 ---- -rm -f Makefile *.oaux -rm -fr stage1 stage2 stage3 stage4 ! -rm -f */stage1 */stage2 */stage3 */stage4 */include -rm -f objc-parse.output -rm -f c-parse.output *************** *** 2103,2107 **** # This target exists to do the initial work before the language specific # stuff gets done. ! distdir-start: doc $(srcdir)/INSTALL c-parse.y c-gperf.h objc-parse.y \ c-parse.c objc-parse.c cexp.c @if grep -s "for version ${mainversion}" gcc.texi > /dev/null; \ --- 2123,2127 ---- # This target exists to do the initial work before the language specific # stuff gets done. ! distdir-start: doc $(srcdir)/INSTALL c-parse.y $(srcdir)/c-gperf.h objc-parse.y \ c-parse.c objc-parse.c cexp.c @if grep -s "for version ${mainversion}" gcc.texi > /dev/null; \ *************** *** 2287,2291 **** -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage1/$$dir ] ; then true ; else mkdir stage1/$$dir ; fi \ done -mv $(STAGESTUFF) stage1 --- 2307,2311 ---- -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage1/$$dir ] ; then true ; else mkdir stage1/$$dir ; fi ; \ done -mv $(STAGESTUFF) stage1 *************** *** 2299,2303 **** -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage2/$$dir ] ; then true ; else mkdir stage2/$$dir ; fi \ done -mv $(STAGESTUFF) stage2 --- 2319,2323 ---- -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage2/$$dir ] ; then true ; else mkdir stage2/$$dir ; fi ; \ done -mv $(STAGESTUFF) stage2 *************** *** 2311,2315 **** -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage3/$$dir ] ; then true ; else mkdir stage3/$$dir ; fi \ done -mv $(STAGESTUFF) stage3 --- 2331,2335 ---- -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage3/$$dir ] ; then true ; else mkdir stage3/$$dir ; fi ; \ done -mv $(STAGESTUFF) stage3 *************** *** 2323,2327 **** -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage4/$$dir ] ; then true ; else mkdir stage4/$$dir ; fi \ done -mv $(STAGESTUFF) stage4 --- 2343,2347 ---- -for dir in . $(SUBDIRS) ; \ do \ ! if [ -d stage4/$$dir ] ; then true ; else mkdir stage4/$$dir ; fi ; \ done -mv $(STAGESTUFF) stage4 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/NEWS gcc-2.6.1/NEWS *** gcc-2.6.0/NEWS Wed Jul 13 17:26:58 1994 --- gcc-2.6.1/NEWS Mon Oct 31 18:02:51 1994 *************** *** 1,2 **** --- 1,36 ---- + Noteworthy changes in GCC version 2.6.1: + + Numerous (mostly minor) bugs have been fixed. + + The following new configurations are supported: + + GNU on x86 (instead of treating it like MACH) + NetBSD on Sparc and Motorola 68k + AIX 4.1 on RS/6000 and PowerPC systems + Sequent DYNUX/ptx 1.x and 2.x. + Both COFF and ELF configurations on AViiON without using /bin/gcc + Windows/NT on x86 architecture; preliminary + AT&T DSP1610 digital signal processor chips + i960 systems on bare boards using COFF + PDP11; target only and not extensively tested + + The -pg option is now supported for Alpha under OSF/1 V3.0 or later. + + Files with an extension of ".c++" are treated as C++ code. + + The -Xlinker and -Wl arguments are now passed to the linker in the + position they were specified on the command line. This makes it + possible, for example, to pass flags to the linker about specific + object files. + + The use of positional arguments to the configure script is no longer + recommended. Use --target= to specify the target; see the GCC manual. + + The 386 now supports two new switches: -mreg-alloc= changes + the default register allocation order used by the compiler, and + -mno-wide-multiply disables the use of the mul/imul instructions that + produce 64 bit results in EAX:EDX from 32 bit operands to do long long + multiplies and 32-bit division by constants. + Noteworthy changes in GCC version 2.6.0: diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/README gcc-2.6.1/README *** gcc-2.6.0/README Thu Jul 14 22:15:23 1994 --- gcc-2.6.1/README Tue Nov 1 21:33:12 1994 *************** *** 1,3 **** ! This directory contains the version 2.6.0 release of the GNU C compiler. It includes all of the support for compiling C++ and Objective C, including a run-time library for Objective C. --- 1,3 ---- ! This directory contains the version 2.6.1 release of the GNU C compiler. It includes all of the support for compiling C++ and Objective C, including a run-time library for Objective C. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/README.ACORN gcc-2.6.1/README.ACORN *** gcc-2.6.0/README.ACORN Thu Dec 23 17:54:31 1993 --- gcc-2.6.1/README.ACORN Thu Aug 11 13:55:23 1994 *************** *** 14,19 **** 3) From Granada Microcare. - 4) From the Newcastle Mail server. - Users of versions of RISC iX prior 1.2 should contact Acorn Customer Services; the assembler available on the net will not work with these versions due to --- 14,17 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/README.DWARF gcc-2.6.1/README.DWARF *** gcc-2.6.0/README.DWARF Thu Jun 23 19:09:01 1994 --- gcc-2.6.1/README.DWARF Mon Jul 18 00:35:10 1994 *************** *** 1,6 **** Notes on the GNU Implementation of DWARF Debugging Information -------------------------------------------------------------- ! Last Updated: Sun Jun 19 11:24:31 PDT 1994 by rfg@netcom.com ! ----------------------------------------------------- This file describes special and unique aspects of the GNU implementation --- 1,6 ---- Notes on the GNU Implementation of DWARF Debugging Information -------------------------------------------------------------- ! Last Updated: Sun Jul 17 08:17:42 PDT 1994 by rfg@netcom.com ! ------------------------------------------------------------ This file describes special and unique aspects of the GNU implementation *************** *** 19,24 **** which are known to cause interoperability problems (e.g. with SVR4 SDB). ! To obtain a copy of the DWARF version 1 specification from Data General's ! FTP server, use the following procedure: --------------------------------------------------------------------------- --- 19,24 ---- which are known to cause interoperability problems (e.g. with SVR4 SDB). ! To obtain a copy of the DWARF Version 1 and/or DWARF Version 2 specification ! from Data General's FTP server, use the following procedure: --------------------------------------------------------------------------- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/README.FRESCO gcc-2.6.1/README.FRESCO *** gcc-2.6.0/README.FRESCO --- gcc-2.6.1/README.FRESCO Thu Aug 18 17:22:10 1994 *************** *** 0 **** --- 1,220 ---- + Compiling Fresco with g++ 2.6 + ----------------------------- + + Fresco is an evolving interface and toolkit for object-oriented + graphics. A preliminary version (written in C++) was released + with x11r6. + + G++ 2.5.x had various bugs preventing Fresco from compiling properly. + We believe these have all been fixed in g++ 2.6. However, there + are still a few portability problems in Fresco itself. These should + be fixed in the next release of Fresco. + + The following patches should help in working around the problems. + I used these patches when I built Fresco, but I don't have time + right now to verify them, or to check that they would apply cleanly. + Perhaps someone could verify these patches against gcc 2.6 and + the latest Fresco and clean it up? + + The most obvious problem is that Fresco defines false and true as constants. + However, these are noe reserved words in ANSI C++. Since g++ has + implemented false, true, and bool, it complains about a syntax error. + + The first patch below to workInProgress/Fresco/include/Ox/base.h should + fix that. It also enables use of long long. + + I ran into the same "true/false" problem in some other file, + but I can find it now. (It was not in the library proper.) + + The second patch is to contrib/programs/dish/main.cxx. + The first part of it is probably SunOS4-specific. + It was somewhat puzzling, but it looks like the %p format conversion + specifier in either sscanf or sprintf doesn't work properly, so I had to + use (the less strictly correct) %x specifier. + + The other part is also Sun-specific. The original code assumes + it can call _main, but g++ does not provide that. Instead, I changed + the code to use a static destructor. The fix in the next Fresco + release will probably be different. + + Please try these patches, and let me know how they work. + + --Per Bothner + Cygnus Support bothner@cygnus.com + + *** /cygint/x11r6/workInProgress/Fresco/include/Ox/base.h Fri Apr 1 13:49:59 1994 + --- ./base.h Thu May 19 21:02:24 1994 + *************** + *** 39,58 **** + #ifndef ox_Boolean + #define ox_Boolean + + ! typedef unsigned char Boolean; + ! + ! static const unsigned char false = 0; + ! static const unsigned char true = 1; + + #ifndef TRUE + #define TRUE true + #endif + - + #ifndef FALSE + #define FALSE false + #endif + + ! #endif + + #ifndef ox_octet + #define ox_octet + --- 39,68 ---- + #ifndef ox_Boolean + #define ox_Boolean + + ! /* Note that 'bool', 'false', and 'true' are now reserved words in + ! ANSI/ISO C++, though few compilers implement them. */ + ! #ifndef __GNUC__ + ! #ifndef false + ! #define false 0 + ! #endif + ! #ifndef true + ! #define true 1 + ! #endif + ! #ifndef bool + ! #define bool unsigned char + ! #endif + ! #endif + + + /* Note: Avoid obsolete identifiers Boolean/TRUE/FALSE. */ + #ifndef TRUE + #define TRUE true + #endif + #ifndef FALSE + #define FALSE false + #endif + + typedef bool Boolean; + + ! #endif /*!ox_Boolean*/ + + #ifndef ox_octet + #define ox_octet + *************** + *** 85,91 **** + #else + typedef long Long; + typedef unsigned long ULong; + ! #if defined(sgi) + /* compiler supports long long */ + typedef long long LongLong; + typedef unsigned long long ULongLong; + --- 95,101 ---- + #else + typedef long Long; + typedef unsigned long ULong; + ! #if defined(sgi) || defined (__GNUC__) + /* compiler supports long long */ + typedef long long LongLong; + typedef unsigned long long ULongLong; + + *** main.cxx.orig Mon Apr 11 16:25:30 1994 + --- main.cxx.new Sat May 14 12:48:09 1994 + *************** + *** 251,264 **** + if (strcmp(s, "0") == 0) { + obj = nil; + } else { + ! b = sscanf(s, "_dish_%p", &obj) == 1; + } + return b; + } + + char* Dish::object_to_string(BaseObjectRef obj, char* result) { + if (is_not_nil(obj)) { + ! sprintf(result, "_dish_%p", obj); + } else { + sprintf(result, "0"); + } + --- 251,268 ---- + if (strcmp(s, "0") == 0) { + obj = nil; + } else { + ! long val; + ! b = sscanf(s, "_dish_%lx", &val) == 1; + ! if (b) + ! obj = (BaseObjectRef)(void*)val; + } + return b; + } + + char* Dish::object_to_string(BaseObjectRef obj, char* result) { + if (is_not_nil(obj)) { + ! long val = (long)obj; + ! sprintf(result, "_dish_%lx", val); + } else { + sprintf(result, "0"); + } + *************** + *** 1087,1110 **** + } + } + + ! /* + ! * Called by main() defined in tcl lib. + ! */ + + #if defined(sun) && !defined(SVR4) + extern "C" { + void _main(); + void on_exit(void (*)(), caddr_t); + } + #endif + + int Tcl_AppInit(Tcl_Interp* interp) { + #if defined(sun) && !defined(SVR4) + _main(); + on_exit(&Dish::cleanup, NULL); + #else + atexit(&Dish::cleanup); + #endif + Dish* dish = new Dish(interp); + dish->add_commands(interp); + dish->add_variables(interp); + --- 1091,1129 ---- + } + } + + ! #if !defined(DISH_CLEANUP_USE_DESTRUCTOR) && defined(__GNUC__) + ! /* This assumes that the tcl library's main() has also been + ! compiled with gcc, or else the destructors won't get run properly. */ + ! #define DISH_CLEANUP_USE_DESTRUCTOR 1 + ! #endif + + + #if DISH_CLEANUP_USE_DESTRUCTOR + + struct DishCleanup { + + ~DishCleanup() { Dish::cleanup(); } + + }; + + static DishCleanup DishCleanupObject; + + #else /* !DISH_CLEANUP_USE_DESTRUCTOR */ + #if defined(sun) && !defined(SVR4) + extern "C" { + void _main(); + void on_exit(void (*)(), caddr_t); + } + #endif + + #endif /* !DISH_CLEANUP_USE_DESTRUCTOR */ + + + + /* + + * Called by main() defined in tcl lib. + + */ + + int Tcl_AppInit(Tcl_Interp* interp) { + + #if !DISH_CLEANUP_USE_DESTRUCTOR + #if defined(sun) && !defined(SVR4) + _main(); + on_exit(&Dish::cleanup, NULL); + #else + atexit(&Dish::cleanup); + #endif + + #endif /* !DISH_CLEANUP_USE_DESTRUCTOR */ + Dish* dish = new Dish(interp); + dish->add_commands(interp); + dish->add_variables(interp); Only in gcc-2.6.0: README.IRIX5 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/alloca.c gcc-2.6.1/alloca.c *** gcc-2.6.0/alloca.c Thu Jul 14 22:16:42 1994 --- gcc-2.6.1/alloca.c Tue Nov 1 21:34:38 1994 *************** *** 23,31 **** #ifdef HAVE_CONFIG_H - #if defined (emacs) || defined (CONFIG_BROKETS) #include - #else - #include "config.h" - #endif #endif --- 23,27 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/bc-emit.c gcc-2.6.1/bc-emit.c *** gcc-2.6.0/bc-emit.c Tue Jun 14 18:04:49 1994 --- gcc-2.6.1/bc-emit.c Fri Jul 29 19:03:09 1994 *************** *** 146,150 **** fprintf (file, "\n\t.comm "); prsym (file, s->name); ! fprintf (file, ", %d\n", s->val); } } --- 146,150 ---- fprintf (file, "\n\t.comm "); prsym (file, s->name); ! fprintf (file, ", %lu\n", s->val); } } *************** *** 153,157 **** fprintf (file, "\n\t.lcomm "); prsym (file, s->name); ! fprintf (file, ", %d\n", s->val); } } --- 153,157 ---- fprintf (file, "\n\t.lcomm "); prsym (file, s->name); ! fprintf (file, ", %lu\n", s->val); } } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/build-make gcc-2.6.1/build-make *** gcc-2.6.0/build-make Sat Dec 19 17:51:53 1992 --- gcc-2.6.1/build-make Wed Sep 28 19:22:58 1994 *************** *** 20,23 **** --- 20,27 ---- HOST_OBSTACK=$(OBSTACK) + # To build the native compiler with the cross compiler, the headers + # for the target are already fixed. And /usr/include is for host, not + # target. + FIXINCLUDES=Makefile.in # Cause installation using install-build. We do nothing here. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/c-common.c gcc-2.6.1/c-common.c *** gcc-2.6.0/c-common.c Wed Jul 6 05:06:51 1994 --- gcc-2.6.1/c-common.c Mon Sep 19 08:54:10 1994 *************** *** 254,257 **** --- 254,270 ---- warning_with_decl (decl, "`const' attribute ignored"); } + else if (TREE_VALUE (a) == get_identifier ("transparent_union")) + { + if (TREE_CODE (decl) == PARM_DECL + && TREE_CODE (type) == UNION_TYPE + && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type))) + DECL_TRANSPARENT_UNION (decl) = 1; + else if (TREE_CODE (decl) == TYPE_DECL + && TREE_CODE (type) == UNION_TYPE + && TYPE_MODE (type) == DECL_MODE (TYPE_FIELDS (type))) + TYPE_TRANSPARENT_UNION (type) = 1; + else + warning_with_decl (decl, "`transparent_union' attribute ignored"); + } else if (TREE_CODE (name) != TREE_LIST) { *************** *** 471,477 **** --- 484,492 ---- #define T_I &integer_type_node #define T_L &long_integer_type_node + #define T_LL &long_long_integer_type_node #define T_S &short_integer_type_node #define T_UI &unsigned_type_node #define T_UL &long_unsigned_type_node + #define T_ULL &long_long_unsigned_type_node #define T_US &short_unsigned_type_node #define T_F &float_type_node *************** *** 494,497 **** --- 509,515 ---- If NULL, then this modifier is not allowed. */ tree *llen; + /* Type of argument if length modifier `q' is used. + If NULL, then this modifier is not allowed. */ + tree *qlen; /* Type of argument if length modifier `L' is used. If NULL, then this modifier is not allowed. */ *************** *** 502,518 **** static format_char_info print_char_table[] = { ! { "di", 0, T_I, T_I, T_L, NULL, "-wp0 +" }, ! { "oxX", 0, T_UI, T_UI, T_UL, NULL, "-wp0#" }, ! { "u", 0, T_UI, T_UI, T_UL, NULL, "-wp0" }, /* Two GNU extensions. */ ! { "Z", 0, T_ST, NULL, NULL, NULL, "-wp0" }, ! { "m", 0, T_UI, T_UI, T_UL, NULL, "-wp" }, ! { "feEgG", 0, T_D, NULL, NULL, T_LD, "-wp0 +#" }, ! { "c", 0, T_I, NULL, T_W, NULL, "-w" }, ! { "C", 0, T_W, NULL, NULL, NULL, "-w" }, ! { "s", 1, T_C, NULL, T_W, NULL, "-wp" }, ! { "S", 1, T_W, NULL, NULL, NULL, "-wp" }, ! { "p", 1, T_V, NULL, NULL, NULL, "-w" }, ! { "n", 1, T_I, T_S, T_L, NULL, "" }, { NULL } }; --- 520,536 ---- static format_char_info print_char_table[] = { ! { "di", 0, T_I, T_I, T_L, T_LL, NULL, "-wp0 +" }, ! { "oxX", 0, T_UI, T_UI, T_UL, T_ULL, NULL, "-wp0#" }, ! { "u", 0, T_UI, T_UI, T_UL, T_ULL, NULL, "-wp0" }, /* Two GNU extensions. */ ! { "Z", 0, T_ST, NULL, NULL, NULL, NULL, "-wp0" }, ! { "m", 0, T_UI, T_UI, T_UL, NULL, NULL, "-wp" }, ! { "feEgG", 0, T_D, NULL, NULL, NULL, T_LD, "-wp0 +#" }, ! { "c", 0, T_I, NULL, T_W, NULL, NULL, "-w" }, ! { "C", 0, T_W, NULL, NULL, NULL, NULL, "-w" }, ! { "s", 1, T_C, NULL, T_W, NULL, NULL, "-wp" }, ! { "S", 1, T_W, NULL, NULL, NULL, NULL, "-wp" }, ! { "p", 1, T_V, NULL, NULL, NULL, NULL, "-w" }, ! { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" }, { NULL } }; *************** *** 519,531 **** static format_char_info scan_char_table[] = { ! { "di", 1, T_I, T_S, T_L, NULL, "*" }, ! { "ouxX", 1, T_UI, T_US, T_UL, NULL, "*" }, ! { "efgEG", 1, T_F, NULL, T_D, T_LD, "*" }, ! { "sc", 1, T_C, NULL, T_W, NULL, "*a" }, ! { "[", 1, T_C, NULL, NULL, NULL, "*a" }, ! { "C", 1, T_W, NULL, NULL, NULL, "*" }, ! { "S", 1, T_W, NULL, NULL, NULL, "*" }, ! { "p", 2, T_V, NULL, NULL, NULL, "*" }, ! { "n", 1, T_I, T_S, T_L, NULL, "" }, { NULL } }; --- 537,549 ---- static format_char_info scan_char_table[] = { ! { "di", 1, T_I, T_S, T_L, T_LL, NULL, "*" }, ! { "ouxX", 1, T_UI, T_US, T_UL, T_ULL, NULL, "*" }, ! { "efgEG", 1, T_F, NULL, T_D, NULL, T_LD, "*" }, ! { "sc", 1, T_C, NULL, T_W, NULL, NULL, "*a" }, ! { "[", 1, T_C, NULL, NULL, NULL, NULL, "*a" }, ! { "C", 1, T_W, NULL, NULL, NULL, NULL, "*" }, ! { "S", 1, T_W, NULL, NULL, NULL, NULL, "*" }, ! { "p", 2, T_V, NULL, NULL, NULL, NULL, "*" }, ! { "n", 1, T_I, T_S, T_L, T_LL, NULL, "" }, { NULL } }; *************** *** 873,877 **** } } ! if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'L') length_char = *format_chars++; else --- 891,896 ---- } } ! if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'q' || ! *format_chars == 'L') length_char = *format_chars++; else *************** *** 982,985 **** --- 1001,1005 ---- case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break; case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break; + case 'q': wanted_type = fci->qlen ? *(fci->qlen) : 0; break; case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break; } *************** *** 1334,1337 **** --- 1354,1388 ---- } + /* Return the minimum number of bits needed to represent VALUE in a + signed or unsigned type, UNSIGNEDP says which. */ + + int + min_precision (value, unsignedp) + tree value; + int unsignedp; + { + int log; + + /* If the value is negative, compute its negative minus 1. The latter + adjustment is because the absolute value of the largest negative value + is one larger than the largest positive value. This is equivalent to + a bit-wise negation, so use that operation instead. */ + + if (tree_int_cst_sgn (value) < 0) + value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value)); + + /* Return the number of bits needed, taking into account the fact + that we need one more bit for a signed than unsigned type. */ + + if (integer_zerop (value)) + log = 0; + else if (TREE_INT_CST_HIGH (value) != 0) + log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value)); + else + log = floor_log2 (TREE_INT_CST_LOW (value)); + + return log + 1 + ! unsignedp; + } + /* Print an error message for invalid operands to arith operation CODE. NOP_EXPR is used as a special case (see truthvalue_conversion). */ *************** *** 1445,1451 **** /* If first arg is constant, swap the args (changing operation ! so value is preserved), for canonicalization. */ ! if (TREE_CONSTANT (primop0)) { register tree tem = primop0; --- 1496,1504 ---- /* If first arg is constant, swap the args (changing operation ! so value is preserved), for canonicalization. Don't do this if ! the second arg is 0. */ ! if (TREE_CONSTANT (primop0) ! && ! integer_zerop (primop1) && ! real_zerop (primop1)) { register tree tem = primop0; *************** *** 1686,1690 **** { case GE_EXPR: ! if (extra_warnings) warning ("unsigned value >= 0 is always 1"); value = integer_one_node; --- 1739,1750 ---- { case GE_EXPR: ! /* All unsigned values are >= 0, so we warn if extra warnings ! are requested. However, if OP0 is a constant that is ! >= 0, the signedness of the comparison isn't an issue, ! so suppress the warning. */ ! if (extra_warnings ! && ! (TREE_CODE (primop0) == INTEGER_CST ! && ! TREE_OVERFLOW (convert (signed_type (type), ! primop0)))) warning ("unsigned value >= 0 is always 1"); value = integer_one_node; *************** *** 1692,1696 **** case LT_EXPR: ! if (extra_warnings) warning ("unsigned value < 0 is always 0"); value = integer_zero_node; --- 1752,1759 ---- case LT_EXPR: ! if (extra_warnings ! && ! (TREE_CODE (primop0) == INTEGER_CST ! && ! TREE_OVERFLOW (convert (signed_type (type), ! primop0)))) warning ("unsigned value < 0 is always 0"); value = integer_zero_node; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/c-decl.c gcc-2.6.1/c-decl.c *** gcc-2.6.0/c-decl.c Tue Jul 12 21:33:48 1994 --- gcc-2.6.1/c-decl.c Tue Oct 18 15:40:10 1994 *************** *** 1304,1307 **** --- 1304,1308 ---- tree oldtype = TREE_TYPE (olddecl); tree newtype = TREE_TYPE (newdecl); + char *errmsg = 0; if (TREE_CODE (newtype) == ERROR_MARK *************** *** 1529,1533 **** else { ! char *errmsg = redeclaration_error_message (newdecl, olddecl); if (errmsg) { --- 1530,1534 ---- else { ! errmsg = redeclaration_error_message (newdecl, olddecl); if (errmsg) { *************** *** 1626,1630 **** /* Optionally warn about more than one declaration for the same name. */ ! if (warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0 /* Dont warn about a function declaration followed by a definition. */ --- 1627,1631 ---- /* Optionally warn about more than one declaration for the same name. */ ! if (errmsg == 0 && warn_redundant_decls && DECL_SOURCE_LINE (olddecl) != 0 /* Dont warn about a function declaration followed by a definition. */ *************** *** 2440,2443 **** --- 2441,2459 ---- if (decl != 0) { + register tree dup; + + /* Check to make sure that the label hasn't already been declared + at this label scope */ + for (dup = named_labels; dup; dup = TREE_CHAIN (dup)) + if (TREE_VALUE (dup) == decl) + { + error ("duplicate label declaration `%s'", + IDENTIFIER_POINTER (name)); + error_with_decl (TREE_VALUE (dup), + "this is a previous declaration"); + /* Just use the previous declaration. */ + return lookup_label (name); + } + shadowed_labels = tree_cons (NULL_TREE, decl, shadowed_labels); IDENTIFIER_LABEL_VALUE (name) = decl = 0; *************** *** 3674,3678 **** /* This test used to include TREE_STATIC, but this won't be set for function level initializers. */ ! if (TREE_READONLY (decl)) { preserve_initializer (); --- 3690,3694 ---- /* This test used to include TREE_STATIC, but this won't be set for function level initializers. */ ! if (TREE_READONLY (decl) || ITERATOR_P (decl)) { preserve_initializer (); *************** *** 5419,5423 **** } } ! else { int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT --- 5435,5439 ---- } } ! else if (TREE_TYPE (x) != error_mark_node) { int min_align = (DECL_PACKED (x) ? BITS_PER_UNIT *************** *** 5647,5681 **** } - /* Return the minimum number of bits needed to represent VALUE in a - signed or unsigned type, UNSIGNEDP says which. */ - - static int - min_precision (value, unsignedp) - tree value; - int unsignedp; - { - int log; - - /* If the value is negative, compute its negative minus 1. The latter - adjustment is because the absolute value of the largest negative value - is one larger than the largest positive value. This is equivalent to - a bit-wise negation, so use that operation instead. */ - - if (tree_int_cst_sgn (value) < 0) - value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value)); - - /* Return the number of bits needed, taking into account the fact - that we need one more bit for a signed than unsigned type. */ - - if (integer_zerop (value)) - log = 0; - else if (TREE_INT_CST_HIGH (value) != 0) - log = HOST_BITS_PER_WIDE_INT + floor_log2 (TREE_INT_CST_HIGH (value)); - else - log = floor_log2 (TREE_INT_CST_LOW (value)); - - return log + 1 + ! unsignedp; - } - /* After processing and defining all the values of an enumeration type, install their decls in the enumeration type and finish it off. --- 5663,5666 ---- *************** *** 5869,5872 **** --- 5854,5858 ---- tree decl1, old_decl; tree restype; + int old_immediate_size_expand = immediate_size_expand; current_function_returns_value = 0; /* Assume, until we see it does. */ *************** *** 5878,5881 **** --- 5864,5870 ---- shadowed_labels = 0; + /* Don't expand any sizes in the return type of the function. */ + immediate_size_expand = 0; + decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1); *************** *** 5923,5926 **** --- 5912,5920 ---- } + /* If there is no explicit declaration, look for any out-of-scope implicit + declarations. */ + if (old_decl == 0) + old_decl = IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1)); + /* Optionally warn of old-fashioned def with no previous prototype. */ if (warn_strict_prototypes *************** *** 5938,5942 **** else if (warn_missing_prototypes && old_decl != 0 && TREE_USED (old_decl) ! && !(old_decl != 0 && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) != 0)) warning_with_decl (decl1, "`%s' was used with no prototype before its definition"); --- 5932,5936 ---- else if (warn_missing_prototypes && old_decl != 0 && TREE_USED (old_decl) ! && TYPE_ARG_TYPES (TREE_TYPE (old_decl)) == 0) warning_with_decl (decl1, "`%s' was used with no prototype before its definition"); *************** *** 5950,5954 **** if the function has already been used. */ else if (warn_missing_declarations ! && old_decl != 0 && TREE_USED (old_decl)) warning_with_decl (decl1, "`%s' was used with no declaration before its definition"); --- 5944,5949 ---- if the function has already been used. */ else if (warn_missing_declarations ! && old_decl != 0 && TREE_USED (old_decl) ! && old_decl == IDENTIFIER_IMPLICIT_DECL (DECL_NAME (decl1))) warning_with_decl (decl1, "`%s' was used with no declaration before its definition"); *************** *** 6006,6009 **** --- 6001,6006 ---- if (TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (current_function_decl))) TREE_ADDRESSABLE (current_function_decl) = 1; + + immediate_size_expand = old_immediate_size_expand; return 1; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/c-parse.in gcc-2.6.1/c-parse.in *** gcc-2.6.0/c-parse.in Mon Jul 11 18:14:27 1994 --- gcc-2.6.1/c-parse.in Wed Aug 24 17:44:37 1994 *************** *** 2063,2068 **** | ELLIPSIS { $$ = get_parm_info (0); ! if (pedantic) ! pedwarn ("ANSI C requires a named argument before `...'"); } | parms --- 2063,2073 ---- | ELLIPSIS { $$ = get_parm_info (0); ! /* Gcc used to allow this as an extension. However, it does ! not work for all targets, and thus has been disabled. ! Also, since func (...) and func () are indistinguishable, ! it caused problems with the code in expand_builtin which ! tries to verify that BUILT_IN_NEXT_ARG is being used ! correctly. */ ! error ("ANSI C requires a named argument before `...'"); } | parms diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/c-typeck.c gcc-2.6.1/c-typeck.c *** gcc-2.6.0/c-typeck.c Fri Jul 1 17:41:21 1994 --- gcc-2.6.1/c-typeck.c Fri Oct 28 19:22:15 1994 *************** *** 656,660 **** and wait (union wait *) to be compatible. */ if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE ! && TYPE_NAME (TREE_VALUE (args1)) == 0 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)), --- 656,661 ---- and wait (union wait *) to be compatible. */ if (TREE_CODE (TREE_VALUE (args1)) == UNION_TYPE ! && (TYPE_NAME (TREE_VALUE (args1)) == 0 ! || TYPE_TRANSPARENT_UNION (TREE_VALUE (args1))) && TREE_CODE (TYPE_SIZE (TREE_VALUE (args1))) == INTEGER_CST && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args1)), *************** *** 670,674 **** } else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE ! && TYPE_NAME (TREE_VALUE (args2)) == 0 && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)), --- 671,676 ---- } else if (TREE_CODE (TREE_VALUE (args2)) == UNION_TYPE ! && (TYPE_NAME (TREE_VALUE (args2)) == 0 ! || TYPE_TRANSPARENT_UNION (TREE_VALUE (args2))) && TREE_CODE (TYPE_SIZE (TREE_VALUE (args2))) == INTEGER_CST && tree_int_cst_equal (TYPE_SIZE (TREE_VALUE (args2)), *************** *** 991,996 **** if (TREE_CODE (exp) == CONST_DECL) exp = DECL_INITIAL (exp); ! /* Replace a nonvolatile const static variable with its value. */ ! else if (optimize && TREE_CODE (exp) == VAR_DECL) { exp = decl_constant_value (exp); --- 993,1001 ---- if (TREE_CODE (exp) == CONST_DECL) exp = DECL_INITIAL (exp); ! ! /* Replace a nonvolatile const static variable with its value unless ! it is an array, in which case we must be sure that taking the ! address of the array produces consistent results. */ ! else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) { exp = decl_constant_value (exp); *************** *** 1631,1652 **** else { - #if 0 /* This turns out not to win--there's no way to write a prototype - for a function whose arg type is a union with no tag. */ - /* Nameless union automatically casts the types it contains. */ - if (TREE_CODE (type) == UNION_TYPE && TYPE_NAME (type) == 0) - { - tree field; - - for (field = TYPE_FIELDS (type); field; - field = TREE_CHAIN (field)) - if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), - TYPE_MAIN_VARIANT (TREE_TYPE (val)))) - break; - - if (field) - val = build1 (CONVERT_EXPR, type, val); - } - #endif - /* Optionally warn about conversions that differ from the default conversions. */ --- 1636,1639 ---- *************** *** 1655,1665 **** int formal_prec = TYPE_PRECISION (type); ! if (TREE_CODE (type) != REAL_TYPE && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1); else if (TREE_CODE (type) == REAL_TYPE ! && TREE_CODE (TREE_TYPE (val)) != REAL_TYPE) warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1); else if (TREE_CODE (type) == REAL_TYPE && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) { --- 1642,1661 ---- int formal_prec = TYPE_PRECISION (type); ! if (INTEGRAL_TYPE_P (type) && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) warn_for_assignment ("%s as integer rather than floating due to prototype", (char *) 0, name, parmnum + 1); + else if (TREE_CODE (type) == COMPLEX_TYPE + && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) + warn_for_assignment ("%s as complex rather than floating due to prototype", (char *) 0, name, parmnum + 1); else if (TREE_CODE (type) == REAL_TYPE ! && INTEGRAL_TYPE_P (TREE_TYPE (val))) warn_for_assignment ("%s as floating rather than integer due to prototype", (char *) 0, name, parmnum + 1); else if (TREE_CODE (type) == REAL_TYPE + && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) + warn_for_assignment ("%s as floating rather than complex due to prototype", (char *) 0, name, parmnum + 1); + /* ??? At some point, messages should be written about + conversions between complex types, but that's too messy + to do now. */ + else if (TREE_CODE (type) == REAL_TYPE && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) { *************** *** 1670,1677 **** } /* Detect integer changing in width or signedness. */ ! else if ((TREE_CODE (type) == INTEGER_TYPE ! || TREE_CODE (type) == ENUMERAL_TYPE) ! && (TREE_CODE (TREE_TYPE (val)) == INTEGER_TYPE ! || TREE_CODE (TREE_TYPE (val)) == ENUMERAL_TYPE)) { tree would_have_been = default_conversion (val); --- 1666,1671 ---- } /* Detect integer changing in width or signedness. */ ! else if (INTEGRAL_TYPE_P (type) ! && INTEGRAL_TYPE_P (TREE_TYPE (val))) { tree would_have_been = default_conversion (val); *************** *** 2799,2803 **** || code == POSTINCREMENT_EXPR) ? "increment" : "decrement")); ! inc = c_sizeof_nowarn (TREE_TYPE (result_type)); } else --- 2793,2797 ---- || code == POSTINCREMENT_EXPR) ? "increment" : "decrement")); ! inc = c_size_in_bytes (TREE_TYPE (result_type)); } else *************** *** 3212,3215 **** --- 3206,3221 ---- return 0; } + + /* If we are making this addressable due to its having + volatile components, give a different error message. Also + handle the case of an unnamed parameter by not trying + to give the name. */ + + else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x))) + { + error ("cannot put object with volatile field into register"); + return 0; + } + pedwarn ("address of register variable `%s' requested", IDENTIFIER_POINTER (DECL_NAME (x))); *************** *** 3869,3876 **** if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE) ! && ! (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE ! || coder == COMPLEX_TYPE)) return convert_and_check (type, rhs); /* Conversion to a union from its member types. */ else if (codel == UNION_TYPE) --- 3875,3882 ---- if ((codel == INTEGER_TYPE || codel == REAL_TYPE || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE) ! && (coder == INTEGER_TYPE || coder == REAL_TYPE || coder == ENUMERAL_TYPE ! || coder == COMPLEX_TYPE)) return convert_and_check (type, rhs); + /* Conversion to a union from its member types. */ else if (codel == UNION_TYPE) *************** *** 3877,3880 **** --- 3883,3887 ---- { tree memb_types; + for (memb_types = TYPE_FIELDS (type); memb_types; memb_types = TREE_CHAIN (memb_types)) *************** *** 3887,3890 **** --- 3894,3898 ---- return build1 (NOP_EXPR, type, rhs); } + else if (coder == POINTER_TYPE && TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE) *************** *** 3896,3900 **** /* Any non-function converts to a [const][volatile] void * and vice versa; otherwise, targets must be the same. ! Meanwhile, the lhs target must have all the qualifiers of the rhs. */ if (TYPE_MAIN_VARIANT (ttl) == void_type_node || TYPE_MAIN_VARIANT (ttr) == void_type_node --- 3904,3909 ---- /* Any non-function converts to a [const][volatile] void * and vice versa; otherwise, targets must be the same. ! Meanwhile, the lhs target must have all the qualifiers of ! the rhs. */ if (TYPE_MAIN_VARIANT (ttl) == void_type_node || TYPE_MAIN_VARIANT (ttr) == void_type_node *************** *** 3901,3906 **** || comp_target_types (memb_type, rhstype)) { ! /* Const and volatile mean something different for function types, ! so the usual warnings are not appropriate. */ if (TREE_CODE (ttr) != FUNCTION_TYPE || TREE_CODE (ttl) != FUNCTION_TYPE) --- 3910,3915 ---- || comp_target_types (memb_type, rhstype)) { ! /* Const and volatile mean something different for function ! types, so the usual warnings are not appropriate. */ if (TREE_CODE (ttr) != FUNCTION_TYPE || TREE_CODE (ttl) != FUNCTION_TYPE) *************** *** 3908,3929 **** if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr)) warn_for_assignment ("%s discards `const' from pointer target type", ! get_spelling (errtype), funname, parmnum); if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr)) warn_for_assignment ("%s discards `volatile' from pointer target type", ! get_spelling (errtype), funname, parmnum); } else { ! /* Because const and volatile on functions are restrictions ! that say the function will not do certain things, ! it is okay to use a const or volatile function ! where an ordinary one is wanted, but not vice-versa. */ if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr)) warn_for_assignment ("%s makes `const *' function pointer from non-const", ! get_spelling (errtype), funname, parmnum); if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr)) warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile", ! get_spelling (errtype), funname, parmnum); } if (pedantic && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl))) --- 3917,3944 ---- if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr)) warn_for_assignment ("%s discards `const' from pointer target type", ! get_spelling (errtype), funname, ! parmnum); if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr)) warn_for_assignment ("%s discards `volatile' from pointer target type", ! get_spelling (errtype), funname, ! parmnum); } else { ! /* Because const and volatile on functions are ! restrictions that say the function will not do ! certain things, it is okay to use a const or volatile ! function where an ordinary one is wanted, but not ! vice-versa. */ if (TYPE_READONLY (ttl) && ! TYPE_READONLY (ttr)) warn_for_assignment ("%s makes `const *' function pointer from non-const", ! get_spelling (errtype), funname, ! parmnum); if (TYPE_VOLATILE (ttl) && ! TYPE_VOLATILE (ttr)) warn_for_assignment ("%s makes `volatile *' function pointer from non-volatile", ! get_spelling (errtype), funname, ! parmnum); } + if (pedantic && !(fundecl != 0 && DECL_IN_SYSTEM_HEADER (fundecl))) *************** *** 3932,3937 **** --- 3947,3960 ---- } } + + /* Can convert integer zero to any pointer type. */ + else if (TREE_CODE (TREE_TYPE (memb_types)) == POINTER_TYPE + && (integer_zerop (rhs) + || (TREE_CODE (rhs) == NOP_EXPR + && integer_zerop (TREE_OPERAND (rhs, 0))))) + return build1 (NOP_EXPR, type, null_pointer_node); } } + /* Conversions among pointers */ else if (codel == POINTER_TYPE && coder == POINTER_TYPE) *************** *** 5156,5161 **** /* Structure elements may require alignment. Do this now if necessary for the subaggregate. */ ! if (constructor_incremental && TREE_CODE (constructor_type) == RECORD_TYPE ! && constructor_fields) { /* Advance to offset of this element. */ --- 5179,5184 ---- /* Structure elements may require alignment. Do this now if necessary for the subaggregate. */ ! if (constructor_incremental && constructor_type != 0 ! && TREE_CODE (constructor_type) == RECORD_TYPE && constructor_fields) { /* Advance to offset of this element. */ *************** *** 6021,6024 **** --- 6044,6048 ---- and we don't have an element of its type, push into it. */ else if (value != 0 && !constructor_no_implicit + && value != error_mark_node && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE *************** *** 6084,6087 **** --- 6108,6112 ---- and we don't have an element of its type, push into it. */ else if (value != 0 && !constructor_no_implicit + && value != error_mark_node && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != fieldtype && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE *************** *** 6127,6130 **** --- 6152,6156 ---- and we don't have an element of its type, push into it. */ else if (value != 0 && !constructor_no_implicit + && value != error_mark_node && TYPE_MAIN_VARIANT (TREE_TYPE (value)) != elttype && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE *************** *** 6142,6145 **** --- 6168,6175 ---- break; } + + /* In the case of [LO .. HI] = VALUE, only evaluate VALUE once. */ + if (constructor_range_end) + value = save_expr (value); /* Now output the actual element. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/calls.c gcc-2.6.1/calls.c *** gcc-2.6.0/calls.c Wed Jul 13 07:03:16 1994 --- gcc-2.6.1/calls.c Mon Oct 17 19:03:19 1994 *************** *** 444,448 **** if (!already_popped) CALL_INSN_FUNCTION_USAGE (call_insn) = ! gen_rtx (EXPR_LIST, CLOBBER, stack_pointer_rtx, CALL_INSN_FUNCTION_USAGE (call_insn)); stack_size -= RETURN_POPS_ARGS (funtype, stack_size); --- 444,449 ---- if (!already_popped) CALL_INSN_FUNCTION_USAGE (call_insn) = ! gen_rtx (EXPR_LIST, VOIDmode, ! gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx), CALL_INSN_FUNCTION_USAGE (call_insn)); stack_size -= RETURN_POPS_ARGS (funtype, stack_size); *************** *** 668,674 **** struct_value_size = int_size_in_bytes (TREE_TYPE (exp)); - if (struct_value_size < 0) - abort (); - if (target && GET_CODE (target) == MEM) structure_value_addr = XEXP (target, 0); --- 669,672 ---- *************** *** 681,684 **** --- 679,685 ---- we would have no way of knowing when to free it. */ + if (struct_value_size < 0) + abort (); + structure_value_addr = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0); *************** *** 902,914 **** if (structure_value_addr && struct_value_rtx == 0) { #ifdef ACCUMULATE_OUTGOING_ARGS ! /* If the stack will be adjusted, make sure the structure address ! does not refer to virtual_outgoing_args_rtx. */ ! rtx temp = (stack_arg_under_construction ! ? copy_addr_to_reg (structure_value_addr) ! : force_reg (Pmode, structure_value_addr)); ! #else ! rtx temp = force_reg (Pmode, structure_value_addr); #endif actparms --- 903,918 ---- if (structure_value_addr && struct_value_rtx == 0) { + /* If structure_value_addr is a REG other than + virtual_outgoing_args_rtx, we can use always use it. If it + is not a REG, we must always copy it into a register. + If it is virtual_outgoing_args_rtx, we must copy it to another + register in some cases. */ + rtx temp = (GET_CODE (structure_value_addr) != REG #ifdef ACCUMULATE_OUTGOING_ARGS ! || (stack_arg_under_construction ! && structure_value_addr == virtual_outgoing_args_rtx) #endif + ? copy_addr_to_reg (structure_value_addr) + : structure_value_addr); actparms *************** *** 980,983 **** --- 984,993 ---- args[i].tree_value = integer_zero_node, type = integer_type_node; + /* If TYPE is a transparent union, pass things the way we would + pass the first field of the union. We have already verified that + the modes are the same. */ + if (TYPE_TRANSPARENT_UNION (type)) + type = TREE_TYPE (TYPE_FIELDS (type)); + /* Decide where to pass this arg. *************** *** 1344,1348 **** argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0); } ! else if (must_preallocate) { /* Note that we must go through the motions of allocating an argument --- 1354,1358 ---- argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0); } ! else { /* Note that we must go through the motions of allocating an argument *************** *** 1350,1439 **** in the area reserved for register arguments, which may be part of the stack frame. */ int needed = args_size.constant; - #ifdef ACCUMULATE_OUTGOING_ARGS /* Store the maximum argument space used. It will be pushed by the ! prologue. - Since the stack pointer will never be pushed, it is possible for - the evaluation of a parm to clobber something we have already - written to the stack. Since most function calls on RISC machines - do not use the stack, this is uncommon, but must work correctly. - - Therefore, we save any area of the stack that was already written - and that we are using. Here we set up to do this by making a new - stack usage map from the old one. The actual save will be done - by store_one_arg. - - Another approach might be to try to reorder the argument - evaluations to avoid this conflicting stack usage. */ - if (needed > current_function_outgoing_args_size) current_function_outgoing_args_size = needed; #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) ! /* Since we will be writing into the entire argument area, the ! map must be allocated for its entire size, not just the part that ! is the responsibility of the caller. */ ! needed += reg_parm_stack_space; #endif #ifdef ARGS_GROW_DOWNWARD ! highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, ! needed + 1); #else ! highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed); #endif ! stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use); ! ! if (initial_highest_arg_in_use) ! bcopy (initial_stack_usage_map, stack_usage_map, ! initial_highest_arg_in_use); ! if (initial_highest_arg_in_use != highest_outgoing_arg_in_use) ! bzero (&stack_usage_map[initial_highest_arg_in_use], ! highest_outgoing_arg_in_use - initial_highest_arg_in_use); ! needed = 0; ! /* The address of the outgoing argument list must not be copied to a ! register here, because argblock would be left pointing to the ! wrong place after the call to allocate_dynamic_stack_space below. */ - argblock = virtual_outgoing_args_rtx; - #else /* not ACCUMULATE_OUTGOING_ARGS */ ! if (inhibit_defer_pop == 0) ! { ! /* Try to reuse some or all of the pending_stack_adjust ! to get this space. Maybe we can avoid any pushing. */ ! if (needed > pending_stack_adjust) { ! needed -= pending_stack_adjust; ! pending_stack_adjust = 0; } else ! { ! pending_stack_adjust -= needed; ! needed = 0; ! } ! } ! /* Special case this because overhead of `push_block' in this ! case is non-trivial. */ ! if (needed == 0) ! argblock = virtual_outgoing_args_rtx; ! else ! argblock = push_block (GEN_INT (needed), 0, 0); ! /* We only really need to call `copy_to_reg' in the case where push ! insns are going to be used to pass ARGBLOCK to a function ! call in ARGS. In that case, the stack pointer changes value ! from the allocation point to the call point, and hence ! the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well. ! But might as well always do it. */ ! argblock = copy_to_reg (argblock); #endif /* not ACCUMULATE_OUTGOING_ARGS */ } - #ifdef ACCUMULATE_OUTGOING_ARGS /* The save/restore code in store_one_arg handles all cases except one: --- 1360,1454 ---- in the area reserved for register arguments, which may be part of the stack frame. */ + int needed = args_size.constant; /* Store the maximum argument space used. It will be pushed by the ! prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow checking). */ if (needed > current_function_outgoing_args_size) current_function_outgoing_args_size = needed; + if (must_preallocate) + { + #ifdef ACCUMULATE_OUTGOING_ARGS + /* Since the stack pointer will never be pushed, it is possible for + the evaluation of a parm to clobber something we have already + written to the stack. Since most function calls on RISC machines + do not use the stack, this is uncommon, but must work correctly. + + Therefore, we save any area of the stack that was already written + and that we are using. Here we set up to do this by making a new + stack usage map from the old one. The actual save will be done + by store_one_arg. + + Another approach might be to try to reorder the argument + evaluations to avoid this conflicting stack usage. */ + #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE) ! /* Since we will be writing into the entire argument area, the ! map must be allocated for its entire size, not just the part that ! is the responsibility of the caller. */ ! needed += reg_parm_stack_space; #endif #ifdef ARGS_GROW_DOWNWARD ! highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, ! needed + 1); #else ! highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, ! needed); #endif ! stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use); ! if (initial_highest_arg_in_use) ! bcopy (initial_stack_usage_map, stack_usage_map, ! initial_highest_arg_in_use); ! ! if (initial_highest_arg_in_use != highest_outgoing_arg_in_use) ! bzero (&stack_usage_map[initial_highest_arg_in_use], ! highest_outgoing_arg_in_use - initial_highest_arg_in_use); ! needed = 0; ! ! /* The address of the outgoing argument list must not be copied to a ! register here, because argblock would be left pointing to the ! wrong place after the call to allocate_dynamic_stack_space below. ! */ ! argblock = virtual_outgoing_args_rtx; #else /* not ACCUMULATE_OUTGOING_ARGS */ ! if (inhibit_defer_pop == 0) { ! /* Try to reuse some or all of the pending_stack_adjust ! to get this space. Maybe we can avoid any pushing. */ ! if (needed > pending_stack_adjust) ! { ! needed -= pending_stack_adjust; ! pending_stack_adjust = 0; ! } ! else ! { ! pending_stack_adjust -= needed; ! needed = 0; ! } } + /* Special case this because overhead of `push_block' in this + case is non-trivial. */ + if (needed == 0) + argblock = virtual_outgoing_args_rtx; else ! argblock = push_block (GEN_INT (needed), 0, 0); ! /* We only really need to call `copy_to_reg' in the case where push ! insns are going to be used to pass ARGBLOCK to a function ! call in ARGS. In that case, the stack pointer changes value ! from the allocation point to the call point, and hence ! the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well. ! But might as well always do it. */ ! argblock = copy_to_reg (argblock); #endif /* not ACCUMULATE_OUTGOING_ARGS */ + } } #ifdef ACCUMULATE_OUTGOING_ARGS /* The save/restore code in store_one_arg handles all cases except one: *************** *** 2194,2198 **** rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0); emit_move_insn (slot, val); ! val = XEXP (slot, 0); mode = Pmode; } --- 2209,2213 ---- rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0); emit_move_insn (slot, val); ! val = force_operand (XEXP (slot, 0), NULL_RTX); mode = Pmode; } *************** *** 2267,2273 **** #endif - #ifdef ACCUMULATE_OUTGOING_ARGS if (args_size.constant > current_function_outgoing_args_size) current_function_outgoing_args_size = args_size.constant; args_size.constant = 0; #endif --- 2282,2289 ---- #endif if (args_size.constant > current_function_outgoing_args_size) current_function_outgoing_args_size = args_size.constant; + + #ifdef ACCUMULATE_OUTGOING_ARGS args_size.constant = 0; #endif *************** *** 2614,2620 **** #endif - #ifdef ACCUMULATE_OUTGOING_ARGS if (args_size.constant > current_function_outgoing_args_size) current_function_outgoing_args_size = args_size.constant; args_size.constant = 0; #endif --- 2630,2637 ---- #endif if (args_size.constant > current_function_outgoing_args_size) current_function_outgoing_args_size = args_size.constant; + + #ifdef ACCUMULATE_OUTGOING_ARGS args_size.constant = 0; #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cccp.c gcc-2.6.1/cccp.c *** gcc-2.6.0/cccp.c Mon Jul 11 15:07:09 1994 --- gcc-2.6.1/cccp.c Tue Oct 25 18:37:44 1994 *************** *** 94,98 **** #ifdef VMS #include - #include /* This defines sys_errlist/sys_nerr properly */ #include #define O_RDONLY 0 /* Open arg for Read/Only */ --- 94,97 ---- *************** *** 187,190 **** --- 186,191 ---- extern char *version_string; extern struct tm *localtime (); + #ifndef VMS + #ifndef HAVE_STRERROR extern int sys_nerr; #if defined(bsd4_4) || defined(__NetBSD__) *************** *** 193,197 **** --- 194,205 ---- extern char *sys_errlist[]; #endif + #else /* HAVE_STERRROR */ + char *strerror (); + #endif + #else /* VMS */ + char *strerror (int,...); + #endif extern int parse_escape (); + extern HOST_WIDE_INT parse_c_expression (); #ifndef errno *************** *** 277,281 **** static int compare_defs (); static int compare_token_lists (); ! static int eval_if_expression (); static int discard_comments (); static int change_newlines (); --- 285,289 ---- static int compare_defs (); static int compare_token_lists (); ! static HOST_WIDE_INT eval_if_expression (); static int discard_comments (); static int change_newlines (); *************** *** 389,392 **** --- 397,405 ---- static int no_line_commands; + /* Nonzero means output the text in failing conditionals, + inside #failed ... #endfailed. */ + + static int output_conditionals; + /* dump_only means inhibit output of the preprocessed text and instead output the definitions of all user-defined *************** *** 1124,1128 **** p = argv[0] + strlen (argv[0]); ! while (p != argv[0] && p[-1] != '/') --p; progname = p; --- 1137,1146 ---- p = argv[0] + strlen (argv[0]); ! while (p != argv[0] && p[-1] != '/' ! #ifdef DIR_SEPARATOR ! && p[-1] != DIR_SEPARATOR ! #endif ! ) ! --p; progname = p; *************** *** 1196,1199 **** --- 1214,1220 ---- include_prefix = argv[++i]; } + if (!strcmp (argv[i], "-ifoutput")) { + output_conditionals = 1; + } if (!strcmp (argv[i], "-isystem")) { struct file_name_list *dirtmp; *************** *** 1323,1327 **** pedantic_errors = 1; } else if (!strcmp (argv[i], "-pcp")) { ! char *pcp_fname = argv[++i]; pcp_outfile = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0') --- 1344,1351 ---- pedantic_errors = 1; } else if (!strcmp (argv[i], "-pcp")) { ! char *pcp_fname; ! if (i + 1 == argc) ! fatal ("Filename missing after -pcp option"); ! pcp_fname = argv[++i]; pcp_outfile = ((pcp_fname[0] != '-' || pcp_fname[1] != '\0') *************** *** 1430,1433 **** --- 1454,1459 ---- if (!strcmp (argv[i], "-MD") || !strcmp (argv[i], "-MMD")) { + if (i + 1 == argc) + fatal ("Filename missing after %s option", argv[i]); i++; deps_file = argv[i]; *************** *** 1607,1611 **** --- 1633,1641 ---- but that seems pointless: it comes before them, so it overrides them anyway. */ + #ifdef WINNT + p = (char *) getenv ("Include"); + #else p = (char *) getenv ("CPATH"); + #endif if (p != 0 && ! no_standard_includes) path_include (p); *************** *** 1959,1963 **** /* Discard all directory prefixes from filename. */ ! if ((q = rindex (in_fname, '/')) != NULL) ++q; else --- 1989,1997 ---- /* Discard all directory prefixes from filename. */ ! if ((q = rindex (in_fname, '/')) != NULL ! #ifdef DIR_SEPARATOR ! && (q = rindex (in_fname, DIR_SEPARATOR)) != NULL ! #endif ! ) ++q; else *************** *** 2176,2179 **** --- 2210,2240 ---- } + /* Return the address of the first character in S that equals C. + S is an array of length N, possibly containing '\0's, and followed by '\0'. + Return 0 if there is no such character. Assume that C itself is not '\0'. + If we knew we could use memchr, we could just invoke memchr (S, C, N), + but unfortunately memchr isn't autoconfigured yet. */ + + static U_CHAR * + index0 (s, c, n) + U_CHAR *s; + int c; + int n; + { + for (;;) { + char *q = index (s, c); + if (q) + return (U_CHAR *) q; + else { + int l = strlen (s); + if (l == n) + return 0; + l++; + s += l; + n -= l; + } + } + } + /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF before main CCCP processing. Name `pcp' is also in honor of the *************** *** 2189,2197 **** FILE_BUF *buf; { ! register U_CHAR c, *fptr, *bptr, *sptr; int len; fptr = bptr = sptr = buf->buf; ! while ((sptr = (U_CHAR *) index (sptr, '?')) != NULL) { if (*++sptr != '?') continue; --- 2250,2259 ---- FILE_BUF *buf; { ! register U_CHAR c, *fptr, *bptr, *sptr, *lptr; int len; fptr = bptr = sptr = buf->buf; ! lptr = fptr + buf->length; ! while ((sptr = (U_CHAR *) index0 (sptr, '?', lptr - sptr)) != NULL) { if (*++sptr != '?') continue; *************** *** 2262,2284 **** { register U_CHAR *p = bp; - register int count = 0; /* First count the backslash-newline pairs here. */ ! while (1) { ! if (p[0] == '\\') { ! if (p[1] == '\n') ! p += 2, count++; ! else if (p[1] == '\r' && p[2] == '\n') ! p += 3, count++; ! else ! break; ! } else ! break; ! } /* What follows the backslash-newlines is not embarrassing. */ ! if (count == 0 || (*p != '/' && *p != '*')) return; --- 2324,2336 ---- { register U_CHAR *p = bp; /* First count the backslash-newline pairs here. */ ! while (p[0] == '\\' && p[1] == '\n') ! p += 2; /* What follows the backslash-newlines is not embarrassing. */ ! if (*p != '/' && *p != '*') return; *************** *** 2291,2295 **** /* Now write the same number of pairs after the embarrassing chars. */ ! while (count-- > 0) { *bp++ = '\\'; *bp++ = '\n'; --- 2343,2347 ---- /* Now write the same number of pairs after the embarrassing chars. */ ! while (bp < p) { *bp++ = '\\'; *bp++ = '\n'; *************** *** 2305,2326 **** { register U_CHAR *p = bp; - register int count = 0; /* First count the backslash-newline pairs here. */ ! while (1) { ! if (p[0] == '\\') { ! if (p[1] == '\n') ! p += 2, count++; ! else if (p[1] == '\r' && p[2] == '\n') ! p += 3, count++; ! else ! break; ! } else ! break; ! } /* What follows the backslash-newlines is not embarrassing. */ ! if (count == 0 || !is_idchar[*p]) return; --- 2357,2368 ---- { register U_CHAR *p = bp; /* First count the backslash-newline pairs here. */ ! while (p[0] == '\\' && p[1] == '\n') ! p += 2; /* What follows the backslash-newlines is not embarrassing. */ ! if (!is_idchar[*p]) return; *************** *** 2333,2337 **** /* Now write the same number of pairs after the embarrassing chars. */ ! while (count-- > 0) { *bp++ = '\\'; *bp++ = '\n'; --- 2375,2379 ---- /* Now write the same number of pairs after the embarrassing chars. */ ! while (bp < p) { *bp++ = '\\'; *bp++ = '\n'; *************** *** 2496,2500 **** if (no_output && instack[indepth].fname != 0) ! skip_if_group (&instack[indepth], 1); obp = op->bufp; --- 2538,2542 ---- if (no_output && instack[indepth].fname != 0) ! skip_if_group (&instack[indepth], 1, NULL); obp = op->bufp; *************** *** 2514,2522 **** switch (c) { case '\\': ! if (ibp >= limit) ! break; ! if (*ibp == '\n') { ! /* Always merge lines ending with backslash-newline, ! even in middle of identifier. */ ++ibp; ++ip->lineno; --- 2556,2563 ---- switch (c) { case '\\': ! if (*ibp == '\n' && !ip->macro) { ! /* At the top level, always merge lines ending with backslash-newline, ! even in middle of identifier. But do not merge lines in a macro, ! since backslash might be followed by a newline-space marker. */ ++ibp; ++ip->lineno; *************** *** 2524,2527 **** --- 2565,2571 ---- break; } + /* If ANSI, backslash is just another character outside a string. */ + if (!traditional) + goto randomchar; /* Otherwise, backslash suppresses specialness of following char, so copy it here to prevent the switch from seeing it. *************** *** 2529,2533 **** if (ident_length > 0) goto specialchar; ! *obp++ = *ibp++; break; --- 2573,2578 ---- if (ident_length > 0) goto specialchar; ! if (ibp < limit) ! *obp++ = *ibp++; break; *************** *** 2609,2613 **** what we do with ordinary text is skip it. Discard everything until next # directive. */ ! skip_if_group (&instack[indepth], 1); RECACHE; beg_of_line = ibp; --- 2654,2658 ---- what we do with ordinary text is skip it. Discard everything until next # directive. */ ! skip_if_group (&instack[indepth], 1, 0); RECACHE; beg_of_line = ibp; *************** *** 2633,2637 **** next # directive. */ if (no_output && instack[indepth].fname) ! skip_if_group (&instack[indepth], 1); obp = op->bufp; RECACHE; --- 2678,2682 ---- next # directive. */ if (no_output && instack[indepth].fname) ! skip_if_group (&instack[indepth], 1, 0); obp = op->bufp; RECACHE; *************** *** 2791,2794 **** --- 2836,2842 ---- if (lintcmd != NULL) { + op->bufp = obp; + check_expand (op, cmdlen + arglen + 14); + obp = op->bufp; /* I believe it is always safe to emit this newline: */ obp[-1] = '\n'; *************** *** 2805,2812 **** /* OK, now bring us back to the state we were in before we entered ! this branch. We need #line b/c the newline for the pragma ! could fuck things up. */ output_line_command (ip, op, 0, same_file); ! *(obp++) = ' '; /* just in case, if comments are copied thru */ *(obp++) = '/'; } --- 2853,2862 ---- /* OK, now bring us back to the state we were in before we entered ! this branch. We need #line because the #pragma's newline always ! messes up the line count. */ ! op->bufp = obp; output_line_command (ip, op, 0, same_file); ! check_expand (op, limit - ibp + 2); ! obp = op->bufp; *(obp++) = '/'; } *************** *** 2885,2891 **** } c = *ibp++; ! /* ".." terminates a preprocessing number. This is useless for C ! code but useful for preprocessing other things. */ ! if (!isalnum (c) && (c != '.' || *ibp == '.') && c != '_') { --ibp; break; --- 2935,2939 ---- } c = *ibp++; ! if (!is_idchar[c] && c != '.') { --ibp; break; *************** *** 2989,2993 **** op->bufp = obp; output_line_command (ip, op, 1, same_file); ! check_expand (op, ip->length - (ip->bufp - ip->buf)); obp = op->bufp; } --- 3037,3041 ---- op->bufp = obp; output_line_command (ip, op, 1, same_file); ! check_expand (op, limit - ibp); obp = op->bufp; } *************** *** 3227,3233 **** /* This is now known to be a macro call. Discard the macro name from the output, ! along with any following whitespace just copied. */ obp = op->buf + obufp_before_macroname; ! op->lineno = op_lineno_before_macroname; /* Prevent accidental token-pasting with a character --- 3275,3289 ---- /* This is now known to be a macro call. Discard the macro name from the output, ! along with any following whitespace just copied, ! but preserve newlines at the top level since this ! is more likely to do the right thing with line numbers. */ obp = op->buf + obufp_before_macroname; ! if (ip->macro != 0) ! op->lineno = op_lineno_before_macroname; ! else { ! int newlines = op->lineno - op_lineno_before_macroname; ! while (0 < newlines--) ! *obp++ = '\n'; ! } /* Prevent accidental token-pasting with a character *************** *** 3530,3535 **** ip->lineno++; copy_command = 1; ! } ! bp++; } break; --- 3586,3592 ---- ip->lineno++; copy_command = 1; ! bp++; ! } else if (traditional) ! bp++; } break; *************** *** 3556,3560 **** if (!kt->angle_brackets) break; ! while (*bp && *bp != '>') bp++; break; --- 3613,3624 ---- if (!kt->angle_brackets) break; ! while (bp < limit && *bp != '>' && *bp != '\n') { ! if (*bp == '\\' && bp[1] == '\n') { ! ip->lineno++; ! copy_command = 1; ! bp++; ! } ! bp++; ! } break; *************** *** 3784,3788 **** static struct tm *timebuf; if (!timebuf) { ! time_t t = time (0); timebuf = localtime (&t); } --- 3848,3852 ---- static struct tm *timebuf; if (!timebuf) { ! time_t t = time ((time_t *)0); timebuf = localtime (&t); } *************** *** 3926,3930 **** if (hp = lookup (ip->bufp, -1, -1)) { if (pcp_outfile && pcp_inside_if ! && hp->value.defn->predefined) /* Output a precondition for this macro use. */ fprintf (pcp_outfile, "#define %s\n", hp->name); --- 3990,3995 ---- if (hp = lookup (ip->bufp, -1, -1)) { if (pcp_outfile && pcp_inside_if ! && (hp->type == T_CONST ! || (hp->type == T_MACRO && hp->value.defn->predefined))) /* Output a precondition for this macro use. */ fprintf (pcp_outfile, "#define %s\n", hp->name); *************** *** 5361,5367 **** /* Simple expansion or empty definition. */ ! /* Skip spaces and tabs if any. */ ! while (bp < limit && (*bp == ' ' || *bp == '\t')) ! ++bp; /* Now everything from bp before limit is the definition. */ defn = collect_expansion (bp, limit, -1, NULL_PTR); --- 5426,5454 ---- /* Simple expansion or empty definition. */ ! if (bp < limit) ! { ! switch (*bp) ! { ! case '\t': case ' ': ! /* Skip spaces and tabs. */ ! while (++bp < limit && (*bp == ' ' || *bp == '\t')) ! continue; ! break; ! ! case '!': case '"': case '#': case '%': case '&': case '\'': ! case ')': case '*': case '+': case ',': case '-': case '.': ! case '/': case ':': case ';': case '<': case '=': case '>': ! case '?': case '[': case '\\': case ']': case '^': case '{': ! case '|': case '}': case '~': ! warning ("missing white space after `#define %.*s'", ! sym_length, symname); ! break; ! ! default: ! pedwarn ("missing white space after `#define %.*s'", ! sym_length, symname); ! break; ! } ! } /* Now everything from bp before limit is the definition. */ defn = collect_expansion (bp, limit, -1, NULL_PTR); *************** *** 5660,5673 **** break; - /* Special hack: if a \# is written in the #define - include a # in the definition. This is useless for C code - but useful for preprocessing other things. */ - case '\\': ! /* \# quotes a # even outside of strings. */ ! if (p < limit && *p == '#' && !expected_delimiter) { ! exp_p--; ! *exp_p++ = *p++; ! } else if (p < limit && expected_delimiter) { /* In a string, backslash goes through and makes next char ordinary. */ --- 5747,5752 ---- break; case '\\': ! if (p < limit && expected_delimiter) { /* In a string, backslash goes through and makes next char ordinary. */ *************** *** 6538,6542 **** /* Output directive name. */ ! check_expand (op, 8); bcopy ("#ident ", (char *) op->bufp, 7); op->bufp += 7; --- 6617,6621 ---- /* Output directive name. */ ! check_expand (op, 7); bcopy ("#ident ", (char *) op->bufp, 7); op->bufp += 7; *************** *** 6648,6656 **** struct directive *keyword; { ! int value; FILE_BUF *ip = &instack[indepth]; value = eval_if_expression (buf, limit - buf); ! conditional_skip (ip, value == 0, T_IF, NULL_PTR); return 0; } --- 6727,6735 ---- struct directive *keyword; { ! HOST_WIDE_INT value; FILE_BUF *ip = &instack[indepth]; value = eval_if_expression (buf, limit - buf); ! conditional_skip (ip, value == 0, T_IF, NULL_PTR, op); return 0; } *************** *** 6667,6671 **** struct directive *keyword; { ! int value; FILE_BUF *ip = &instack[indepth]; --- 6746,6750 ---- struct directive *keyword; { ! HOST_WIDE_INT value; FILE_BUF *ip = &instack[indepth]; *************** *** 6686,6694 **** if (if_stack->if_succeeded) ! skip_if_group (ip, 0); else { value = eval_if_expression (buf, limit - buf); if (value == 0) ! skip_if_group (ip, 0); else { ++if_stack->if_succeeded; /* continue processing input */ --- 6765,6773 ---- if (if_stack->if_succeeded) ! skip_if_group (ip, 0, op); else { value = eval_if_expression (buf, limit - buf); if (value == 0) ! skip_if_group (ip, 0, op); else { ++if_stack->if_succeeded; /* continue processing input */ *************** *** 6703,6707 **** * then parse the result as a C expression and return the value as an int. */ ! static int eval_if_expression (buf, length) U_CHAR *buf; --- 6782,6786 ---- * then parse the result as a C expression and return the value as an int. */ ! static HOST_WIDE_INT eval_if_expression (buf, length) U_CHAR *buf; *************** *** 6710,6716 **** FILE_BUF temp_obuf; HASHNODE *save_defined; ! int value; ! save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, 0, -1); pcp_inside_if = 1; temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1); --- 6789,6795 ---- FILE_BUF temp_obuf; HASHNODE *save_defined; ! HOST_WIDE_INT value; ! save_defined = install ("defined", -1, T_SPEC_DEFINED, 0, NULL_PTR, -1); pcp_inside_if = 1; temp_obuf = expand_to_temp_buffer (buf, buf + length, 0, 1); *************** *** 6791,6795 **** if (pcp_outfile) { /* Output a precondition for this macro. */ ! if (hp && hp->value.defn->predefined) fprintf (pcp_outfile, "#define %s\n", hp->name); else { --- 6870,6876 ---- if (pcp_outfile) { /* Output a precondition for this macro. */ ! if (hp && ! (hp->type == T_CONST ! || (hp->type == T_MACRO && hp->value.defn->predefined))) fprintf (pcp_outfile, "#define %s\n", hp->name); else { *************** *** 6810,6814 **** } ! conditional_skip (ip, skip, T_IF, control_macro); return 0; } --- 6891,6895 ---- } ! conditional_skip (ip, skip, T_IF, control_macro, op); return 0; } *************** *** 6820,6824 **** static void ! conditional_skip (ip, skip, type, control_macro) FILE_BUF *ip; int skip; --- 6901,6905 ---- static void ! conditional_skip (ip, skip, type, control_macro, op) FILE_BUF *ip; int skip; *************** *** 6825,6828 **** --- 6906,6910 ---- enum node_type type; U_CHAR *control_macro; + FILE_BUF *op; { IF_STACK_FRAME *temp; *************** *** 6838,6842 **** if (skip != 0) { ! skip_if_group (ip, 0); return; } else { --- 6920,6924 ---- if (skip != 0) { ! skip_if_group (ip, 0, op); return; } else { *************** *** 6852,6858 **** */ static void ! skip_if_group (ip, any) FILE_BUF *ip; int any; { register U_CHAR *bp = ip->bufp, *cp; --- 6934,6941 ---- */ static void ! skip_if_group (ip, any, op) FILE_BUF *ip; int any; + FILE_BUF *op; { register U_CHAR *bp = ip->bufp, *cp; *************** *** 6863,6866 **** --- 6946,6968 ---- register int ident_length; U_CHAR *ident, *after_ident; + /* Save info about where the group starts. */ + U_CHAR *beg_of_group = bp; + int beg_lineno = ip->lineno; + + if (output_conditionals && op != 0) { + char *ptr = "#failed\n"; + int len = strlen (ptr); + + if (op->bufp > op->buf && op->bufp[-1] != '\n') + { + *op->bufp++ = '\n'; + op->lineno++; + } + check_expand (op, len); + bcopy (ptr, (char *) op->bufp, len); + op->bufp += len; + op->lineno++; + output_line_command (ip, op, 1, 0); + } while (bp < endb) { *************** *** 7014,7018 **** /* If we are asked to return on next directive, do so now. */ if (any) ! return; switch (kt->type) { --- 7116,7120 ---- /* If we are asked to return on next directive, do so now. */ if (any) ! goto done; switch (kt->type) { *************** *** 7037,7041 **** } else if (if_stack == save_if_stack) ! return; /* found what we came for */ if (kt->type != T_ENDIF) { --- 7139,7143 ---- } else if (if_stack == save_if_stack) ! goto done; /* found what we came for */ if (kt->type != T_ENDIF) { *************** *** 7059,7062 **** --- 7161,7165 ---- } } + ip->bufp = bp; /* after this returns, rescan will exit because ip->bufp *************** *** 7063,7066 **** --- 7166,7190 ---- now points to the end of the buffer. rescan is responsible for the error message also. */ + + done: + if (output_conditionals && op != 0) { + char *ptr = "#endfailed\n"; + int len = strlen (ptr); + + if (op->bufp > op->buf && op->bufp[-1] != '\n') + { + *op->bufp++ = '\n'; + op->lineno++; + } + check_expand (op, beg_of_line - beg_of_group); + bcopy ((char *) beg_of_group, (char *) op->bufp, + beg_of_line - beg_of_group); + op->bufp += beg_of_line - beg_of_group; + op->lineno += ip->lineno - beg_lineno; + check_expand (op, len); + bcopy (ptr, (char *) op->bufp, len); + op->bufp += len; + op->lineno++; + } } *************** *** 7105,7109 **** if (if_stack->if_succeeded) ! skip_if_group (ip, 0); else { ++if_stack->if_succeeded; /* continue processing input */ --- 7229,7233 ---- if (if_stack->if_succeeded) ! skip_if_group (ip, 0, op); else { ++if_stack->if_succeeded; /* continue processing input */ *************** *** 8385,8388 **** --- 8509,8545 ---- /* + * my_strerror - return the descriptive text associated with an `errno' code. + */ + + char * + my_strerror (errnum) + int errnum; + { + char *result; + + #ifndef VMS + #ifndef HAVE_STRERROR + result = (char *) ((errnum < sys_nerr) ? sys_errlist[errnum] : 0); + #else + result = strerror (errnum); + #endif + #else /* VMS */ + /* VAXCRTL's strerror() takes an optional second argument, which only + matters when the first argument is EVMSERR. However, it's simplest + just to pass it unconditionally. `vaxc$errno' is declared in + , and maintained by the library in parallel with `errno'. + We assume that caller's `errnum' either matches the last setting of + `errno' by the library or else does not have the value `EVMSERR'. */ + + result = strerror (errnum, vaxc$errno); + #endif + + if (!result) + result = "undocumented I/O error"; + + return result; + } + + /* * error - print error message and increment count of errors. */ *************** *** 8431,8438 **** fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno); ! if (errno < sys_nerr) ! fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]); ! else ! fprintf (stderr, "%s: undocumented I/O error\n", name); errors++; --- 8588,8592 ---- fprintf (stderr, "%s:%d: ", ip->nominal_fname, ip->lineno); ! fprintf (stderr, "%s: %s\n", name, my_strerror (errno)); errors++; *************** *** 8930,8942 **** while (p < limit) { ! if (*p != '\n') ! putc (*p, of); ! else if (*p == '\"' || *p =='\'') { U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR, NULL_PTR, NULL_PTR); fwrite (p, p1 - p, 1, of); ! p = p1 - 1; } - p++; } } --- 9084,9097 ---- while (p < limit) { ! if (*p == '\"' || *p =='\'') { U_CHAR *p1 = skip_quoted_string (p, limit, 0, NULL_PTR, NULL_PTR, NULL_PTR); fwrite (p, p1 - p, 1, of); ! p = p1; ! } else { ! if (*p != '\n') ! putc (*p, of); ! p++; } } } *************** *** 9013,9039 **** FILE_BUF *outp; { ! install ("__LINE__", -1, T_SPECLINE, 0, 0, -1); ! install ("__DATE__", -1, T_DATE, 0, 0, -1); ! install ("__FILE__", -1, T_FILE, 0, 0, -1); ! install ("__BASE_FILE__", -1, T_BASE_FILE, 0, 0, -1); ! install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, 0, -1); ! install ("__VERSION__", -1, T_VERSION, 0, 0, -1); #ifndef NO_BUILTIN_SIZE_TYPE ! install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, 0, -1); #endif #ifndef NO_BUILTIN_PTRDIFF_TYPE ! install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, 0, -1); #endif ! install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, 0, -1); ! install ("__USER_LABEL_PREFIX__", -1, T_USER_LABEL_PREFIX_TYPE, 0, 0, -1); ! install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, 0, -1); ! install ("__TIME__", -1, T_TIME, 0, 0, -1); if (!traditional) ! install ("__STDC__", -1, T_CONST, STDC_VALUE, 0, -1); if (objc) ! install ("__OBJC__", -1, T_CONST, 1, 0, -1); /* This is supplied using a -D by the compiler driver so that it is present only when truly compiling with GNU C. */ ! /* install ("__GNUC__", -1, T_CONST, 2, 0, -1); */ if (debug_output) --- 9168,9194 ---- FILE_BUF *outp; { ! install ("__LINE__", -1, T_SPECLINE, 0, NULL_PTR, -1); ! install ("__DATE__", -1, T_DATE, 0, NULL_PTR, -1); ! install ("__FILE__", -1, T_FILE, 0, NULL_PTR, -1); ! install ("__BASE_FILE__", -1, T_BASE_FILE, 0, NULL_PTR, -1); ! install ("__INCLUDE_LEVEL__", -1, T_INCLUDE_LEVEL, 0, NULL_PTR, -1); ! install ("__VERSION__", -1, T_VERSION, 0, NULL_PTR, -1); #ifndef NO_BUILTIN_SIZE_TYPE ! install ("__SIZE_TYPE__", -1, T_SIZE_TYPE, 0, NULL_PTR, -1); #endif #ifndef NO_BUILTIN_PTRDIFF_TYPE ! install ("__PTRDIFF_TYPE__ ", -1, T_PTRDIFF_TYPE, 0, NULL_PTR, -1); #endif ! install ("__WCHAR_TYPE__", -1, T_WCHAR_TYPE, 0, NULL_PTR, -1); ! install ("__USER_LABEL_PREFIX__",-1,T_USER_LABEL_PREFIX_TYPE,0,NULL_PTR, -1); ! install ("__REGISTER_PREFIX__", -1, T_REGISTER_PREFIX_TYPE, 0, NULL_PTR, -1); ! install ("__TIME__", -1, T_TIME, 0, NULL_PTR, -1); if (!traditional) ! install ("__STDC__", -1, T_CONST, STDC_VALUE, NULL_PTR, -1); if (objc) ! install ("__OBJC__", -1, T_CONST, 1, NULL_PTR, -1); /* This is supplied using a -D by the compiler driver so that it is present only when truly compiling with GNU C. */ ! /* install ("__GNUC__", -1, T_CONST, 2, NULL_PTR, -1); */ if (debug_output) *************** *** 9120,9123 **** --- 9275,9284 ---- while (is_idchar[*++p]) ; + if (*p == '(') { + while (is_idchar[*++p] || *p == ',' || is_hor_space[*p]) + ; + if (*p++ != ')') + p = str; /* Error */ + } if (*p == 0) { buf = (U_CHAR *) alloca (p - buf + 4); *************** *** 9138,9142 **** q = &buf[p - str]; while (*p) { ! if (*p == '\\' && p[1] == '\n') p += 2; /* Change newline chars into newline-markers. */ --- 9299,9314 ---- q = &buf[p - str]; while (*p) { ! if (*p == '\"' || *p == '\'') { ! int unterminated = 0; ! U_CHAR *p1 = skip_quoted_string (p, p + strlen (p), 0, ! NULL_PTR, NULL_PTR, &unterminated); ! if (unterminated) ! return; ! while (p != p1) ! if (*p == '\\' && p[1] == '\n') ! p += 2; ! else ! *q++ = *p++; ! } else if (*p == '\\' && p[1] == '\n') p += 2; /* Change newline chars into newline-markers. */ *************** *** 9168,9172 **** /* Pass NULL instead of OP, since this is a "predefined" macro. */ ! do_define (buf, buf + strlen (buf), NULL, kt); --indepth; } --- 9340,9344 ---- /* Pass NULL instead of OP, since this is a "predefined" macro. */ ! do_define (buf, buf + strlen (buf), NULL_PTR, kt); --indepth; } *************** *** 9393,9400 **** { fprintf (stderr, "%s: ", progname); ! if (errno < sys_nerr) ! fprintf (stderr, "%s: %s\n", name, sys_errlist[errno]); ! else ! fprintf (stderr, "%s: undocumented I/O error\n", name); errors++; } --- 9565,9569 ---- { fprintf (stderr, "%s: ", progname); ! fprintf (stderr, "%s: %s\n", name, my_strerror (errno)); errors++; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cexp.y gcc-2.6.1/cexp.y *** gcc-2.6.0/cexp.y Wed Oct 6 13:47:31 1993 --- gcc-2.6.1/cexp.y Tue Sep 20 19:02:25 1994 *************** *** 1,4 **** /* Parse C expressions for CCCP. ! Copyright (C) 1987, 1992 Free Software Foundation. This program is free software; you can redistribute it and/or modify it --- 1,4 ---- /* Parse C expressions for CCCP. ! Copyright (C) 1987, 1992, 1994 Free Software Foundation. This program is free software; you can redistribute it and/or modify it *************** *** 60,63 **** --- 60,77 ---- #endif + /* Find the largest host integer type and set its size and type. */ + + #ifndef HOST_BITS_PER_WIDE_INT + + #if HOST_BITS_PER_LONG > HOST_BITS_PER_INT + #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG + #define HOST_WIDE_INT long + #else + #define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT + #define HOST_WIDE_INT int + #endif + + #endif + #ifndef NULL_PTR #define NULL_PTR ((GENERIC_PTR)0) *************** *** 66,70 **** int yylex (); void yyerror (); ! int expression_value; static jmp_buf parse_return_error; --- 80,84 ---- int yylex (); void yyerror (); ! HOST_WIDE_INT expression_value; static jmp_buf parse_return_error; *************** *** 906,910 **** this function is called. */ ! int parse_c_expression (string) char *string; --- 920,924 ---- this function is called. */ ! HOST_WIDE_INT parse_c_expression (string) char *string; *************** *** 955,959 **** break; buf[n] = '\0'; ! printf ("parser returned %d\n", parse_c_expression (buf)); } --- 969,973 ---- break; buf[n] = '\0'; ! printf ("parser returned %ld\n", parse_c_expression (buf)); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/collect2.c gcc-2.6.1/collect2.c *** gcc-2.6.0/collect2.c Mon Jul 11 15:08:16 1994 --- gcc-2.6.1/collect2.c Thu Oct 20 18:05:46 1994 *************** *** 80,83 **** --- 80,96 ---- #endif + #ifndef WIFSIGNALED + #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f) + #endif + #ifndef WTERMSIG + #define WTERMSIG(S) ((S) & 0x7f) + #endif + #ifndef WIFEXITED + #define WIFEXITED(S) (((S) & 0xff) == 0) + #endif + #ifndef WEXITSTATUS + #define WEXITSTATUS(S) (((S) & 0xff00) >> 8) + #endif + /* On MSDOS, write temp files in current dir because there's no place else we can expect to use. */ *************** *** 293,298 **** int e; { - static char buffer[30]; if (!e) return ""; --- 306,316 ---- int e; { + #ifdef HAVE_STRERROR + return strerror (e); + + #else + + static char buffer[30]; if (!e) return ""; *************** *** 303,306 **** --- 321,325 ---- sprintf (buffer, "Unknown error %d", e); return buffer; + #endif } *************** *** 328,332 **** static void fatal_perror (string, arg1, arg2, arg3) ! char *string; { int e = errno; --- 347,351 ---- static void fatal_perror (string, arg1, arg2, arg3) ! char *string, *arg1, *arg2, *arg3; { int e = errno; *************** *** 342,346 **** static void fatal (string, arg1, arg2, arg3) ! char *string; { fprintf (stderr, "collect2: "); --- 361,365 ---- static void fatal (string, arg1, arg2, arg3) ! char *string, *arg1, *arg2, *arg3; { fprintf (stderr, "collect2: "); *************** *** 354,358 **** static void error (string, arg1, arg2, arg3, arg4) ! char *string; { fprintf (stderr, "collect2: "); --- 373,377 ---- static void error (string, arg1, arg2, arg3, arg4) ! char *string, *arg1, *arg2, *arg3, *arg4; { fprintf (stderr, "collect2: "); *************** *** 940,943 **** --- 959,967 ---- /* Try to discover a valid linker/nm/strip to use. */ + /* Maybe we know the right file to use (if not cross). */ + #ifdef REAL_LD_FILE_NAME + ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME); + if (ld_file_name == 0) + #endif #if 0 /* Search the (target-specific) compiler dirs for `gld'. */ *************** *** 955,963 **** if (ld_file_name == 0) ld_file_name = find_a_file (&path, full_real_ld_suffix); - /* Maybe we know the right file to use (if not cross). */ - #ifdef REAL_LD_FILE_NAME - if (ld_file_name == 0) - ld_file_name = find_a_file (&path, REAL_LD_FILE_NAME); - #endif /* Search the compiler directories for `ld'. We have protection against recursive calls in find_a_file. */ --- 979,982 ---- *************** *** 981,984 **** --- 1000,1007 ---- } + #ifdef REAL_NM_FILE_NAME + nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME); + if (nm_file_name == 0) + #endif nm_file_name = find_a_file (&cpath, gnm_suffix); if (nm_file_name == 0) *************** *** 986,996 **** if (nm_file_name == 0) nm_file_name = find_a_file (&cpath, nm_suffix); - #ifdef REAL_NM_FILE_NAME if (nm_file_name == 0) - nm_file_name = find_a_file (&path, REAL_NM_FILE_NAME); - #endif - if (nm_file_name == 0) nm_file_name = find_a_file (&path, full_nm_suffix); strip_file_name = find_a_file (&cpath, gstrip_suffix); if (strip_file_name == 0) --- 1009,1019 ---- if (nm_file_name == 0) nm_file_name = find_a_file (&cpath, nm_suffix); if (nm_file_name == 0) nm_file_name = find_a_file (&path, full_nm_suffix); + #ifdef REAL_STRIP_FILE_NAME + strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME); + if (strip_file_name == 0) + #endif strip_file_name = find_a_file (&cpath, gstrip_suffix); if (strip_file_name == 0) *************** *** 998,1005 **** if (strip_file_name == 0) strip_file_name = find_a_file (&cpath, strip_suffix); - #ifdef REAL_STRIP_FILE_NAME - if (strip_file_name == 0) - strip_file_name = find_a_file (&path, REAL_STRIP_FILE_NAME); - #endif if (strip_file_name == 0) strip_file_name = find_a_file (&path, full_strip_suffix); --- 1021,1024 ---- *************** *** 1057,1060 **** --- 1076,1080 ---- if (arg[0] == '-') + { switch (arg[1]) { *************** *** 1094,1098 **** break; } ! else if (first_file && (p = rindex (arg, '.')) != (char *)0 --- 1114,1118 ---- break; } ! } else if (first_file && (p = rindex (arg, '.')) != (char *)0 *************** *** 1202,1205 **** --- 1222,1226 ---- } + maybe_unlink(output_file); outf = fopen (c_file, "w"); if (outf == (FILE *)0) *************** *** 1246,1254 **** if (status) { ! int sig = status & 0x7F; ! int ret; ! ! if (sig != -1 && sig != 0) { #ifdef NO_SYS_SIGLIST error ("%s terminated with signal %d %s", --- 1267,1273 ---- if (status) { ! if (WIFSIGNALED (status)) { + int sig = WTERMSIG (status); #ifdef NO_SYS_SIGLIST error ("%s terminated with signal %d %s", *************** *** 1267,1275 **** } ! ret = ((status & 0xFF00) >> 8); ! if (ret != -1 && ret != 0) { ! error ("%s returned %d exit status", prog, ret); ! my_exit (ret); } } --- 1286,1297 ---- } ! if (WIFEXITED (status)) { ! int ret = WEXITSTATUS (status); ! if (ret != 0) ! { ! error ("%s returned %d exit status", prog, ret); ! my_exit (ret); ! } } } *************** *** 1351,1357 **** char *name; { ! struct id *newid = (struct id *) xcalloc (sizeof (*newid) + strlen (name), 1); static long sequence_number = 0; - newid->sequence = ++sequence_number; strcpy (newid->name, name); --- 1373,1380 ---- char *name; { ! struct id *newid ! = (struct id *) xcalloc (sizeof (struct id) + strlen (name), 1); ! struct id *p; static long sequence_number = 0; strcpy (newid->name, name); *************** *** 1361,1364 **** --- 1384,1400 ---- head_ptr->first = newid; + /* Check for duplicate symbols. */ + for (p = head_ptr->first; + strcmp (name, p->name) != 0; + p = p->next) + ; + if (p != newid) + { + head_ptr->last->next = 0; + free (newid); + return; + } + + newid->sequence = ++sequence_number; head_ptr->last = newid; head_ptr->number++; *************** *** 1546,1549 **** --- 1582,1586 ---- end++) continue; + *end = '\0'; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/combine.c gcc-2.6.1/combine.c *** gcc-2.6.0/combine.c Tue Jul 12 13:17:44 1994 --- gcc-2.6.1/combine.c Tue Oct 18 19:08:56 1994 *************** *** 171,179 **** static rtx subst_insn; - /* If nonzero, this is the insn that should be presumed to be - immediately in front of `subst_insn'. */ - - static rtx subst_prev_insn; - /* This is the lowest CUID that `subst' is currently dealing with. get_last_value will not return a value if the register was set at or --- 171,174 ---- *************** *** 881,885 **** || GET_CODE (src) == CALL /* Don't eliminate a function call argument. */ ! || (GET_CODE (i3) == CALL_INSN && find_reg_fusage (i3, USE, dest)) /* Don't substitute into an incremented register. */ || FIND_REG_INC_NOTE (i3, dest) --- 876,884 ---- || GET_CODE (src) == CALL /* Don't eliminate a function call argument. */ ! || (GET_CODE (i3) == CALL_INSN ! && (find_reg_fusage (i3, USE, dest) ! || (GET_CODE (dest) == REG ! && REGNO (dest) < FIRST_PSEUDO_REGISTER ! && global_regs[REGNO (dest)]))) /* Don't substitute into an incremented register. */ || FIND_REG_INC_NOTE (i3, dest) *************** *** 1204,1207 **** --- 1203,1208 ---- /* Notes that we substituted I3 into I2 instead of the normal case. */ int i3_subst_into_i2 = 0; + /* Notes that I1, I2 or I3 is a MULT operation. */ + int have_mult = 0; int maxreg; *************** *** 1239,1243 **** temp = i1, i1 = i2, i2 = temp; - subst_prev_insn = 0; added_links_insn = 0; --- 1240,1243 ---- *************** *** 1355,1361 **** as I2 will not cause a problem. */ ! subst_prev_insn = i1 ! = gen_rtx (INSN, VOIDmode, INSN_UID (i2), 0, i2, ! XVECEXP (PATTERN (i2), 0, 1), -1, 0, 0); SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0)); --- 1355,1360 ---- as I2 will not cause a problem. */ ! i1 = gen_rtx (INSN, VOIDmode, INSN_UID (i2), 0, i2, ! XVECEXP (PATTERN (i2), 0, 1), -1, 0, 0); SUBST (PATTERN (i2), XVECEXP (PATTERN (i2), 0, 0)); *************** *** 1393,1396 **** --- 1392,1404 ---- } + /* See if any of the insns is a MULT operation. Unless one is, we will + reject a combination that is, since it must be slower. Be conservative + here. */ + if (GET_CODE (i2src) == MULT + || (i1 != 0 && GET_CODE (i1src) == MULT) + || (GET_CODE (PATTERN (i3)) == SET + && GET_CODE (SET_SRC (PATTERN (i3))) == MULT)) + have_mult = 1; + /* If I3 has an inc, then give up if I1 or I2 uses the reg that is inc'd. We used to do this EXCEPT in one case: I3 has a post-inc in an *************** *** 1602,1606 **** || max_reg_num () != maxreg /* Fail if we couldn't do something and have a CLOBBER. */ ! || GET_CODE (newpat) == CLOBBER) { undo_all (); --- 1610,1618 ---- || max_reg_num () != maxreg /* Fail if we couldn't do something and have a CLOBBER. */ ! || GET_CODE (newpat) == CLOBBER ! /* Fail if this new pattern is a MULT and we didn't have one before ! at the outer level. */ ! || (GET_CODE (newpat) == SET && GET_CODE (SET_SRC (newpat)) == MULT ! && ! have_mult)) { undo_all (); *************** *** 1805,1815 **** { rtx newdest = i2dest; /* Get NEWDEST as a register in the proper mode. We have already validated that we can do this. */ ! if (GET_MODE (i2dest) != GET_MODE (*split) ! && GET_MODE (*split) != VOIDmode) { ! newdest = gen_rtx (REG, GET_MODE (*split), REGNO (i2dest)); if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER) --- 1817,1828 ---- { rtx newdest = i2dest; + enum rtx_code split_code = GET_CODE (*split); + enum machine_mode split_mode = GET_MODE (*split); /* Get NEWDEST as a register in the proper mode. We have already validated that we can do this. */ ! if (GET_MODE (i2dest) != split_mode && split_mode != VOIDmode) { ! newdest = gen_rtx (REG, split_mode, REGNO (i2dest)); if (REGNO (i2dest) >= FIRST_PSEUDO_REGISTER) *************** *** 1820,1827 **** an ASHIFT. This can occur if it was inside a PLUS and hence appeared to be a memory address. This is a kludge. */ ! if (GET_CODE (*split) == MULT && GET_CODE (XEXP (*split, 1)) == CONST_INT && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0) ! SUBST (*split, gen_rtx_combine (ASHIFT, GET_MODE (*split), XEXP (*split, 0), GEN_INT (i))); --- 1833,1840 ---- an ASHIFT. This can occur if it was inside a PLUS and hence appeared to be a memory address. This is a kludge. */ ! if (split_code == MULT && GET_CODE (XEXP (*split, 1)) == CONST_INT && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0) ! SUBST (*split, gen_rtx_combine (ASHIFT, split_mode, XEXP (*split, 0), GEN_INT (i))); *************** *** 1829,1835 **** /* If *SPLIT is a paradoxical SUBREG, when we split it, it should be written as a ZERO_EXTEND. */ ! if (GET_CODE (*split) == SUBREG ! && GET_CODE (SUBREG_REG (*split)) == MEM) ! SUBST (*split, gen_rtx_combine (ZERO_EXTEND, GET_MODE (*split), XEXP (*split, 0))); #endif --- 1842,1847 ---- /* If *SPLIT is a paradoxical SUBREG, when we split it, it should be written as a ZERO_EXTEND. */ ! if (split_code == SUBREG && GET_CODE (SUBREG_REG (*split)) == MEM) ! SUBST (*split, gen_rtx_combine (ZERO_EXTEND, split_mode, XEXP (*split, 0))); #endif *************** *** 1838,1842 **** SUBST (*split, newdest); i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes); ! if (i2_code_number >= 0) insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes); } --- 1850,1857 ---- SUBST (*split, newdest); i2_code_number = recog_for_combine (&newi2pat, i2, &new_i2_notes); ! ! /* If the split point was a MULT and we didn't have one before, ! don't use one now. */ ! if (i2_code_number >= 0 && ! (split_code == MULT && ! have_mult)) insn_code_number = recog_for_combine (&newpat, i3, &new_i3_notes); } *************** *** 3262,3269 **** XEXP (XEXP (x, 0), 1), mode)) != 0) ! { ! SUBST (XEXP (XEXP (x, 0), 1), temp); ! return XEXP (x, 0); ! } /* (not (ashift 1 X)) is (rotate ~1 X). We used to do this for operands --- 3277,3281 ---- XEXP (XEXP (x, 0), 1), mode)) != 0) ! return gen_binary (XOR, mode, XEXP (XEXP (x, 0), 0), temp); /* (not (ashift 1 X)) is (rotate ~1 X). We used to do this for operands *************** *** 3437,3440 **** --- 3449,3459 ---- return gen_unary (GET_CODE (XEXP (x, 0)), mode, mode, XEXP (XEXP (XEXP (x, 0), 0), 0)); + + /* (float_truncate:SF (subreg:DF (float_truncate:SF X) 0)) + is (float_truncate:SF x). */ + if (GET_CODE (XEXP (x, 0)) == SUBREG + && subreg_lowpart_p (XEXP (x, 0)) + && GET_CODE (SUBREG_REG (XEXP (x, 0))) == FLOAT_TRUNCATE) + return SUBREG_REG (XEXP (x, 0)); break; *************** *** 4355,4358 **** --- 4374,4378 ---- && (GET_CODE (XEXP (src, 0)) == EQ || GET_CODE (XEXP (src, 0)) == NE) && XEXP (XEXP (src, 0), 1) == const0_rtx + && GET_MODE (src) == GET_MODE (XEXP (XEXP (src, 0), 0)) && (num_sign_bit_copies (XEXP (XEXP (src, 0), 0), GET_MODE (XEXP (XEXP (src, 0), 0))) *************** *** 6875,6880 **** int low0 = floor_log2 (nz0 & -nz0); int low1 = floor_log2 (nz1 & -nz1); ! int op0_maybe_minusp = (nz0 & ((HOST_WIDE_INT) 1 << (mode_width - 1))); ! int op1_maybe_minusp = (nz1 & ((HOST_WIDE_INT) 1 << (mode_width - 1))); int result_width = mode_width; int result_low = 0; --- 6895,6902 ---- int low0 = floor_log2 (nz0 & -nz0); int low1 = floor_log2 (nz1 & -nz1); ! HOST_WIDE_INT op0_maybe_minusp ! = (nz0 & ((HOST_WIDE_INT) 1 << (mode_width - 1))); ! HOST_WIDE_INT op1_maybe_minusp ! = (nz1 & ((HOST_WIDE_INT) 1 << (mode_width - 1))); int result_width = mode_width; int result_low = 0; *************** *** 8619,8622 **** --- 8641,8645 ---- op0 = gen_lowpart_for_combine (tmode, inner_op0); op1 = gen_lowpart_for_combine (tmode, inner_op1); + code = unsigned_condition (code); changed = 1; break; *************** *** 8820,8823 **** --- 8843,8847 ---- const_op = 0, op1 = const0_rtx; code = LT; + break; } else *************** *** 9812,9824 **** rtx insn, set; ! /* If there is an insn that is supposed to be immediately ! in front of subst_insn, use it. */ ! if (subst_prev_insn != 0) ! insn = subst_prev_insn; ! else ! for (insn = prev_nonnote_insn (subst_insn); ! insn && INSN_CUID (insn) >= subst_low_cuid; ! insn = prev_nonnote_insn (insn)) ! ; if (insn --- 9836,9843 ---- rtx insn, set; ! for (insn = prev_nonnote_insn (subst_insn); ! insn && INSN_CUID (insn) >= subst_low_cuid; ! insn = prev_nonnote_insn (insn)) ! ; if (insn *************** *** 10333,10340 **** { case REG_UNUSED: ! /* If this note is from any insn other than i3, then we have no ! use for it, and must ignore it. ! ! Any clobbers for i3 may still exist, and so we must process REG_UNUSED notes from that insn. --- 10352,10356 ---- { case REG_UNUSED: ! /* Any clobbers for i3 may still exist, and so we must process REG_UNUSED notes from that insn. *************** *** 10346,10357 **** In that case, we will notice that the register is set in i3, and then add a REG_UNUSED note for the destination of i3, which ! is wrong. */ ! if (from_insn != i3) ! break; /* If this register is set or clobbered in I3, put the note there unless there is one already. */ ! else if (reg_set_p (XEXP (note, 0), PATTERN (i3))) { if (! (GET_CODE (XEXP (note, 0)) == REG ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0))) --- 10362,10377 ---- In that case, we will notice that the register is set in i3, and then add a REG_UNUSED note for the destination of i3, which ! is wrong. However, it is possible to have REG_UNUSED notes from ! i2 or i1 for register which were both used and clobbered, so ! we keep notes from i2 or i1 if they will turn into REG_DEAD ! notes. */ /* If this register is set or clobbered in I3, put the note there unless there is one already. */ ! if (reg_set_p (XEXP (note, 0), PATTERN (i3))) { + if (from_insn != i3) + break; + if (! (GET_CODE (XEXP (note, 0)) == REG ? find_regno_note (i3, REG_UNUSED, REGNO (XEXP (note, 0))) *************** *** 10634,10638 **** rtx piece = gen_rtx (REG, reg_raw_mode[i], i); ! if (reg_referenced_p (piece, PATTERN (place)) && ! dead_or_set_p (place, piece) && ! reg_bitfield_target_p (piece, --- 10654,10660 ---- rtx piece = gen_rtx (REG, reg_raw_mode[i], i); ! if ((reg_referenced_p (piece, PATTERN (place)) ! || (GET_CODE (place) == CALL_INSN ! && find_reg_fusage (place, USE, piece))) && ! dead_or_set_p (place, piece) && ! reg_bitfield_target_p (piece, diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/1750a/1750a.c gcc-2.6.1/config/1750a/1750a.c *** gcc-2.6.0/config/1750a/1750a.c Mon Jul 11 19:23:45 1994 --- gcc-2.6.1/config/1750a/1750a.c Tue Sep 20 19:29:59 1994 *************** *** 1,5 **** ! /* Subroutines for insn-output.c for MIL-STD-1750A. Copyright (C) 1994 Free Software Foundation, Inc. ! Contributed by O.M.Kellogg, Deutsche Aerospace (okellogg@salyko.cube.net). This file is part of GNU CC. --- 1,5 ---- ! /* Subroutines for insn-output.c for MIL-STD-1750. Copyright (C) 1994 Free Software Foundation, Inc. ! Contributed by O.M.Kellogg, DASA (okellogg@salyko.cube.net). This file is part of GNU CC. *************** *** 37,45 **** int jmplbl_ndx = -1; int label_pending = 0, program_counter = 0; ! enum section current_section=NREL; ! char *sectname[4] = { "NREL","IREL","KREL","SREL" }; ! ! int notice_update_cc(exp) ! rtx exp; { if (GET_CODE (exp) == SET) --- 37,47 ---- int jmplbl_ndx = -1; int label_pending = 0, program_counter = 0; ! enum section current_section = Normal; ! char *sectname[4] = ! {"Normal", "Init", "Konst", "Static"}; ! ! int ! notice_update_cc (exp) ! rtx exp; { if (GET_CODE (exp) == SET) *************** *** 67,72 **** /* Emulated longword bit-ops leave cc's incorrect */ else if (GET_MODE (SET_DEST (exp)) == HImode ? ! src_code == AND || src_code == IOR || ! src_code == XOR || src_code == NOT : 0) { CC_STATUS_INIT; --- 69,74 ---- /* Emulated longword bit-ops leave cc's incorrect */ else if (GET_MODE (SET_DEST (exp)) == HImode ? ! src_code == AND || src_code == IOR || ! src_code == XOR || src_code == NOT : 0) { CC_STATUS_INIT; *************** *** 83,87 **** else if (REG_P (SET_DEST (exp))) { ! cc_status.flags = CC_NO_OVERFLOW; cc_status.value1 = SET_SRC (exp); cc_status.value2 = SET_DEST (exp); --- 85,89 ---- else if (REG_P (SET_DEST (exp))) { ! cc_status.flags = CC_NO_OVERFLOW; cc_status.value1 = SET_SRC (exp); cc_status.value2 = SET_DEST (exp); *************** *** 113,121 **** ! rtx function_arg(cum,mode,type,named) ! int cum; ! enum machine_mode mode; ! tree type; ! int named; { int size; --- 115,124 ---- ! rtx ! function_arg (cum, mode, type, named) ! int cum; ! enum machine_mode mode; ! tree type; ! int named; { int size; *************** *** 122,133 **** rtx result; ! if (MUST_PASS_IN_STACK(mode,type)) return (rtx) 0; if (mode == BLKmode) ! size = int_size_in_bytes(type); else size = GET_MODE_SIZE (mode); ! if (cum + size < 12) ! return gen_rtx(REG, mode, cum); else return (rtx) 0; --- 125,136 ---- rtx result; ! if (MUST_PASS_IN_STACK (mode, type)) return (rtx) 0; if (mode == BLKmode) ! size = int_size_in_bytes (type); else size = GET_MODE_SIZE (mode); ! if (cum + size < 12) ! return gen_rtx (REG, mode, cum); else return (rtx) 0; *************** *** 135,226 **** ! char *tekasm_float(exp_char,value) ! char exp_char; ! double value; { - extern char *strpbrk(); - int found_letter = 0; char *p; ! static char fbuf[20]; ! ! sprintf(fbuf,"%g",value); ! if ((p = strpbrk(fbuf,"Ee")) == NULL) ! sprintf(fbuf+strlen(fbuf),"%c0",exp_char); ! else ! *p = exp_char; ! return fbuf; } ! char *asm_float_syntax(rtx x) { ! if (GET_MODE(x) == HFmode) ! { ! union { double d; int i[2]; } du; ! union { float f; int i; } su; ! du.i[0] = CONST_DOUBLE_LOW(x); ! du.i[1] = CONST_DOUBLE_HIGH(x); ! su.f = (float) du.d; ! return tekasm_float('E',su.f); ! } ! else { ! union { double d; int i[2]; } du; ! du.i[0] = CONST_DOUBLE_LOW(x); ! du.i[1] = CONST_DOUBLE_HIGH(x); ! return tekasm_float('D',du.d); } } ! char *float_label(char code,char *fltstr) { ! int i=1; ! static char label[32]; ! ! label[0] = code; ! while (*fltstr) { ! label[i] = (*fltstr == '+') ? 'p' : ! (*fltstr == '-') ? 'm' : *fltstr; ! i++; ! fltstr++; } ! if (i > 11) ! i = 11; ! label[i] = '\0'; ! return label; } ! char *movcnt_regno_adjust(rtx *op) { static char outstr[40]; ! int cntreg = REGNO(op[2]), cntreg_1750 = REGNO(op[0]) + 1; ! int dstreg = REGNO(op[0]), srcreg = REGNO(op[1]); if (cntreg == cntreg_1750) ! sprintf(outstr,"MOV R%%0,R%%1"); ! else if (dstreg+1 == srcreg && srcreg == cntreg+2) ! sprintf(outstr,"XWR R%d,R%d\n\tMOV R%%0,R%%1",cntreg,dstreg); ! else if (dstreg+1 == srcreg && srcreg < cntreg) ! sprintf(outstr,"XWR R%d,R%d\n\tMOV R%%0,R%%1",srcreg,cntreg); ! else if (srcreg+1 == cntreg && dstreg > cntreg) ! sprintf(outstr,"XWR R%d,R%d\n\tMOV R%%0,R%%1",srcreg,dstreg); else ! sprintf(outstr,"XWR R%d,R%d\n\tMOV R%%0,%%1\n\tXWR R%d,R%d", ! cntreg,cntreg_1750,cntreg_1750,cntreg); return outstr; } ! char *mod_regno_adjust(char *instr,rtx *op) { static char outstr[40]; ! char *r = (!strncmp(instr,"DVR",3) ? "R" : ""); ! int modregno_gcc = REGNO(op[3]), modregno_1750 = REGNO(op[0]) + 1; if (modregno_gcc == modregno_1750) ! sprintf(outstr,"%s R%%0,%s%%2",instr,r); else ! sprintf(outstr,"LR R%d,R%d\n\t%s R%%0,%s%%2\n\tXWR R%d,R%d", ! modregno_gcc,modregno_1750,instr,r,modregno_1750,modregno_gcc); return outstr; } --- 138,231 ---- ! #ifndef STRDUP ! char * ! strdup (str) ! char *str; { char *p; ! if (str == NULL) ! return NULL; ! if ((p = (char *) malloc (strlen (str) + 1)) == NULL) ! { ! fprintf (stderr, "dynamic memory exhausted"); ! abort (); ! } ! return strcpy (p, str); } ! #endif ! ! ! double ! get_double (x) ! rtx x; { ! union { ! double d; ! long i[2]; } + du; + + du.i[0] = CONST_DOUBLE_LOW (x); + du.i[1] = CONST_DOUBLE_HIGH (x); + return du.d; } ! char * ! float_label (code, value) ! char code; ! double value; { ! int i = 1; ! static char label[32]; ! char *p; ! ! label[0] = code; ! p = label + 1; ! sprintf (p, "%lf", value); ! while (*p) { ! *p = (*p == '+') ? 'p' : ! (*p == '-') ? 'm' : *p; ! p++; } ! return strdup (label); } ! char * ! movcnt_regno_adjust (rtx * op) { static char outstr[40]; ! int cntreg = REGNO (op[2]), cntreg_1750 = REGNO (op[0]) + 1; ! int dstreg = REGNO (op[0]), srcreg = REGNO (op[1]); if (cntreg == cntreg_1750) ! sprintf (outstr, "mov r%%0,r%%1"); ! else if (dstreg + 1 == srcreg && srcreg == cntreg + 2) ! sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", cntreg, dstreg); ! else if (dstreg + 1 == srcreg && srcreg < cntreg) ! sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", srcreg, cntreg); ! else if (srcreg + 1 == cntreg && dstreg > cntreg) ! sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,r%%1", srcreg, dstreg); else ! sprintf (outstr, "xwr r%d,r%d\n\tmov r%%0,%%1\n\txwr r%d,r%d", ! cntreg, cntreg_1750, cntreg_1750, cntreg); return outstr; } ! char * ! mod_regno_adjust (char *instr, rtx * op) { static char outstr[40]; ! char *r = (!strncmp (instr, "dvr", 3) ? "r" : ""); ! int modregno_gcc = REGNO (op[3]), modregno_1750 = REGNO (op[0]) + 1; if (modregno_gcc == modregno_1750) ! sprintf (outstr, "%s r%%0,%s%%2", instr, r); else ! sprintf (outstr, "lr r%d,r%d\n\t%s r%%0,%s%%2\n\txwr r%d,r%d", ! modregno_gcc, modregno_1750, instr, r, modregno_1750, modregno_gcc); return outstr; } *************** *** 230,260 **** Check if op is a valid memory operand for 1750A arith./logic (non-move) instructions. */ ! int memop_valid(register rtx op) { ! if (GET_MODE(op) != Pmode && GET_MODE(op) != VOIDmode) return 0; ! switch (GET_CODE(op)) { ! case MEM: ! case MINUS: ! case MULT: ! case DIV: return 0; ! case PLUS: ! if (! memop_valid(XEXP(op,0))) ! return 0; ! return memop_valid(XEXP(op,1)); ! case REG: ! if (REGNO(op) > 0) ! return 1; ! return 0; ! case CONST: ! case CONST_INT: ! case SYMBOL_REF: ! case SUBREG: ! return 1; ! default: ! printf("memop_valid: code=%d\n",(int) GET_CODE(op)); return 1; } } --- 235,266 ---- Check if op is a valid memory operand for 1750A arith./logic (non-move) instructions. */ ! int ! memop_valid (register rtx op) { ! if (GET_MODE (op) != Pmode && GET_MODE (op) != VOIDmode) return 0; ! switch (GET_CODE (op)) { ! case MEM: ! case MINUS: ! case MULT: ! case DIV: ! return 0; ! case PLUS: ! if (!memop_valid (XEXP (op, 0))) return 0; ! return memop_valid (XEXP (op, 1)); ! case REG: ! if (REGNO (op) > 0) return 1; + return 0; + case CONST: + case CONST_INT: + case SYMBOL_REF: + case SUBREG: + return 1; + default: + printf ("memop_valid: code=%d\n", (int) GET_CODE (op)); + return 1; } } *************** *** 261,278 **** /* extra predicate for recog: */ ! int nonindirect_operand(register rtx op, enum machine_mode mode) { int retval; ! switch (GET_CODE(op)) { ! case MEM: ! retval = memop_valid(XEXP(op,0)); ! return retval; ! case REG: ! return 1; ! default: ! if (! CONSTANT_P(op)) ! return 0; } return 1; --- 267,285 ---- /* extra predicate for recog: */ ! int ! nonindirect_operand (register rtx op, enum machine_mode mode) { int retval; ! switch (GET_CODE (op)) { ! case MEM: ! retval = memop_valid (XEXP (op, 0)); ! return retval; ! case REG: ! return 1; ! default: ! if (!CONSTANT_P (op)) ! return 0; } return 1; *************** *** 280,286 **** /* predicate for the STC instruction: */ ! int small_nonneg_const(register rtx op, enum machine_mode mode) { ! if (GET_CODE(op) == CONST_INT && INTVAL(op) >= 0 && INTVAL(op) <= 15) return 1; return 0; --- 287,294 ---- /* predicate for the STC instruction: */ ! int ! small_nonneg_const (register rtx op, enum machine_mode mode) { ! if (GET_CODE (op) == CONST_INT && INTVAL (op) >= 0 && INTVAL (op) <= 15) return 1; return 0; *************** *** 290,294 **** or as a "Branch Conditional": */ ! int find_jmplbl(int labelnum) { int i, found = 0; --- 298,303 ---- or as a "Branch Conditional": */ ! int ! find_jmplbl (int labelnum) { int i, found = 0; *************** *** 305,309 **** } ! char *branch_or_jump(char *condition, int targetlabel_number) { static char buf[30]; --- 314,319 ---- } ! char * ! branch_or_jump (char *condition, int targetlabel_number) { static char buf[30]; *************** *** 310,320 **** int index; ! if ((index = find_jmplbl(targetlabel_number)) >= 0) if (program_counter - jmplbl[index].pc < 128) { ! sprintf(buf,"B%s %%l0",condition); return buf; } ! sprintf(buf,"JC %s,%%l0",condition); return buf; } --- 320,330 ---- int index; ! if ((index = find_jmplbl (targetlabel_number)) >= 0) if (program_counter - jmplbl[index].pc < 128) { ! sprintf (buf, "b%s %%l0", condition); return buf; } ! sprintf (buf, "jc %s,%%l0", condition); return buf; } *************** *** 322,369 **** ! /* The PRINT_OPERAND and PRINT_OPERAND_ADDRESS macros have been made functions: */ ! print_operand(file, x, code) ! FILE *file; ! rtx x; ! enum rtx_code code; ! { ! switch (GET_CODE(x)) { ! case REG: ! fprintf (file, "%d",REGNO (x)); ! break; ! case SYMBOL_REF: ! fprintf(file,"%s",XSTR(x,0)); ! break; ! case LABEL_REF: ! case CONST: ! case MEM: ! output_address(XEXP(x,0)); ! break; ! case CONST_DOUBLE: ! if (code == 'D' || code == 'E') /* KREL output hack: */ ! { /* make a label out of a floating-point number. */ ! char *fltstr = (char *)asm_float_syntax(x); ! int i, found = 0; ! for (i = 0; i <= datalbl_ndx; i++) ! if (strcmp(fltstr,datalbl[i].value) == 0) { found = 1; break; } ! if (! found) { ! strcpy(datalbl[i = ++datalbl_ndx].value,fltstr); ! strcpy(datalbl[i].name,(char *)float_label(code,fltstr)); ! datalbl[i].size = (code=='D') ? 3 : 2; ! check_section(KREL); ! fprintf(file,"K%s \tDATAF %s ;p_o\n", datalbl[i].name,fltstr); ! check_section(NREL); ! } ! } ! else if (code == 'F') { ! char *fltstr = (char *)asm_float_syntax(x); ! int i, found = 0; ! for (i = 0; i <= datalbl_ndx; i++) ! if (strcmp(fltstr,datalbl[i].value) == 0) { found = 1; --- 332,387 ---- ! /* The PRINT_OPERAND and PRINT_OPERAND_ADDRESS macros have been made functions: */ ! print_operand (file, x, kode) ! FILE *file; ! rtx x; ! enum rtx_code kode; ! { ! switch (GET_CODE (x)) { ! case REG: ! fprintf (file, "%d", REGNO (x)); ! break; ! case SYMBOL_REF: ! fprintf (file, "%s", XSTR (x, 0)); ! break; ! case LABEL_REF: ! case CONST: ! case MEM: ! output_address (XEXP (x, 0)); ! break; ! case CONST_DOUBLE: ! /* { ! double value = get_double (x); ! char fltstr[32]; ! sprintf (fltstr, "%lf", value); ! ! if (kode == 'D' || kode == 'E') ! { ! int i, found = 0; ! for (i = 0; i <= datalbl_ndx; i++) ! if (strcmp (fltstr, datalbl[i].value) == 0) ! { ! found = 1; ! break; ! } ! if (!found) { ! strcpy (datalbl[i = ++datalbl_ndx].value, fltstr); ! datalbl[i].name = float_label (kode, value); ! datalbl[i].size = (kode == 'E') ? 3 : 2; ! check_section (Konst); ! fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name, ! (kode == 'E' ? "ef" : "f"), fltstr); ! check_section (Normal); ! } ! } ! else if (kode == 'F' || kode == 'G') { ! int i, found = 0; ! for (i = 0; i <= datalbl_ndx; i++) ! if (strcmp (fltstr, datalbl[i].value) == 0) { found = 1; *************** *** 370,530 **** break; } ! if (! found) { ! printf("Aborting: 'F' float label not found in datalbl[].\n"); ! abort(); } ! fprintf(file,"%s ;P_O 'F'",datalbl[i].name); ! } else ! fprintf(file,"%s ;P_O cst_dbl",(char *)asm_float_syntax(x)); ! break; ! case CONST_INT: ! if (code == 'J') ! fprintf (file, "%d",-INTVAL(x)); ! else if (INTVAL(x) > 0x7FFF) ! fprintf (file, "%d ; range correction (val>0x7FFF) applied", ! INTVAL(x) - 0x10000); else ! fprintf (file, "%d", INTVAL(x)); ! break; ! case CODE_LABEL: ! fprintf (file, "L%d", XINT(x,3)); ! break; ! case CALL: ! fprintf(file,"CALL nargs=%d, func is either '%s' or '%s'", ! XEXP(x,1),XSTR(XEXP(XEXP(x,0),1),0),XSTR(XEXP(x,0),1)); ! break; ! case PLUS: ! { ! rtx op0 = XEXP(x,0), op1 = XEXP(x,1); ! int op0code=GET_CODE(op0), op1code=GET_CODE(op1); ! if (op1code == CONST_INT) ! switch (op0code) ! { ! case REG: ! fprintf(file,"%d,R%d ; p_o_PLUS for REG and CONST", ! INTVAL(op1),REGNO(op0)); ! break; ! case SYMBOL_REF: ! fprintf(file,"%d+%s",INTVAL(op1),XSTR(op0,0)); ! break; ! case MEM: ! fprintf(file,"%d,[mem:",INTVAL(op1)); ! output_address(XEXP(op0,0)); ! fprintf(file,"] ;P_O plus"); ! break; ! default: ! fprintf(file,"p_o_PLUS UFO, code=%d, with CONST=%d", ! (int)op0code,INTVAL(op1)); ! } ! else if (op1code == SYMBOL_REF && op0code == REG) ! fprintf(file,"%s,R%d ; P_O: (plus reg sym)", ! XSTR(op1,0),REGNO(op0)); ! else ! fprintf(file,"p_o_+: op0code=%d, op1code=%d",op0code,op1code); ! } ! break; ! default: ! fprintf (file, "p_o_UFO code=%d", GET_CODE(x)); } } ! print_operand_address(file, addr) ! FILE *file; ! rtx addr; { switch (GET_CODE (addr)) { ! case REG: ! fprintf (file, "0,R%d ; P_O_A", REGNO (addr)); ! break; ! case PLUS: ! { ! register rtx x = XEXP(addr,0), y = XEXP(addr,1); ! switch (GET_CODE(x)) ! { ! case REG: ! switch (GET_CODE(y)) ! { ! case CONST: ! output_address(XEXP(y,0)); ! fprintf(file, ",R%d ;P_O_A reg + const expr",REGNO(x)); ! break; ! case CONST_INT: ! fprintf(file,"%d,R%d ; P_O_A reg + const_int", ! INTVAL(y),REGNO(x)); ! break; ! case SYMBOL_REF: ! fprintf(file,"%s,R%d ; P_O_A reg + sym", ! XSTR(y,0),REGNO(x)); ! break; ! default: ! fprintf(file, "[P_O_A reg%d+UFO code=%d]", ! REGNO(x),GET_CODE(y)); ! } break; ! case LABEL_REF: case SYMBOL_REF: ! switch (GET_CODE(y)) ! { ! case CONST_INT: ! fprintf (file,"%d+%s",INTVAL(y),XSTR(x,0)); ! break; ! case REG: ! fprintf (file,"%s,R%d ;P_O_A sym + reg", ! XSTR(x,0),REGNO(y)); ! break; ! default: ! fprintf(file, "P_O_A sym/lab+UFO[sym=%s,code(y)=%d]", ! XSTR(x,0),GET_CODE(y)); ! } ! break; ! case CONST: ! output_address(XEXP(x,0)); ! if (GET_CODE(y) == REG) ! fprintf(file, ",R%d ;P_O_A const + reg",REGNO(x)); ! else ! fprintf(file,"P_O_A const+UFO code(y)=%d]",GET_CODE(y)); ! break; ! case MEM: ! output_address(y); ! fprintf(file, ",[mem:"); ! output_address(XEXP(x,0)); ! fprintf(file, "] ;P_O_A plus"); break; default: ! fprintf(file, "P_O_A plus op1_UFO[code1=%d,code2=%d]", ! GET_CODE(x),GET_CODE(y)); ! } ! } ! break; ! case CONST_INT: ! if (INTVAL(addr) < 0x10000 && INTVAL(addr) >= -0x10000) ! fprintf (file, "%d ; p_o_a const addr?!", INTVAL(addr)); ! else ! { ! fprintf(file,"[p_o_a=ILLEGAL_CONST]"); ! output_addr_const (file, addr); } ! break; ! case LABEL_REF: ! case SYMBOL_REF: ! fprintf(file,"%s",XSTR(addr,0)); ! break; ! case MEM: ! fprintf(file,"[memUFO:"); ! output_address(XEXP(addr,0)); ! fprintf(file,"]"); ! break; ! case CONST: ! output_address(XEXP(addr,0)); ! fprintf(file," ;P_O_A const"); ! break; ! default: ! fprintf(file," p_o_a UFO, code=%d val=0x%x", ! (int) GET_CODE(addr),INTVAL(addr)); ! break; } } --- 388,588 ---- break; } ! if (!found) { ! fprintf (stderr, ! "float value %lfnot found upon label reference\n", value); ! strcpy (datalbl[i = ++datalbl_ndx].value, fltstr); ! datalbl[i].name = float_label (kode, value); ! datalbl[i].size = (kode == 'G') ? 3 : 2; ! check_section (Konst); ! fprintf (file, "K%s \tdata%s %s ;p_o\n", datalbl[i].name, ! (kode == 'G' ? "ef" : "f"), fltstr); ! check_section (Normal); } ! fprintf (file, "%s ;P_O 'F'", datalbl[i].name); ! } else ! fprintf (file, " %s ;P_O cst_dbl ", fltstr); ! } ! */ ! fprintf (file, "%lf", get_double (x)); ! break; ! case CONST_INT: ! if (kode == 'J') ! fprintf (file, "%d", -INTVAL (x)); ! else if (INTVAL (x) > 0x7FFF) ! fprintf (file, "%d ; range correction (val>0x7FFF) applied", ! INTVAL (x) - 0x10000); ! else ! fprintf (file, "%d", INTVAL (x)); ! break; ! case CODE_LABEL: ! fprintf (file, "L%d", XINT (x, 3)); ! break; ! case CALL: ! fprintf (file, "CALL nargs=%d, func is either '%s' or '%s'", ! XEXP (x, 1), XSTR (XEXP (XEXP (x, 0), 1), 0), XSTR (XEXP (x, 0), 1)); ! break; ! case PLUS: ! { ! rtx op0 = XEXP (x, 0), op1 = XEXP (x, 1); ! int op0code = GET_CODE (op0), op1code = GET_CODE (op1); ! if (op1code == CONST_INT) ! switch (op0code) ! { ! case REG: ! fprintf (file, "%d,r%d ; p_o_PLUS for REG and CONST", ! INTVAL (op1), REGNO (op0)); ! break; ! case SYMBOL_REF: ! fprintf (file, "%d+%s", INTVAL (op1), XSTR (op0, 0)); ! break; ! case MEM: ! fprintf (file, "%d,[mem:", INTVAL (op1)); ! output_address (XEXP (op0, 0)); ! fprintf (file, "] ;P_O plus"); ! break; ! default: ! fprintf (file, "p_o_PLUS UFO, code=%d, with CONST=%d", ! (int) op0code, INTVAL (op1)); ! } ! else if (op1code == SYMBOL_REF && op0code == REG) ! fprintf (file, "%s,r%d ; P_O: (plus reg sym)", ! XSTR (op1, 0), REGNO (op0)); else ! fprintf (file, "p_o_+: op0code=%d, op1code=%d", op0code, op1code); ! } ! break; ! default: ! fprintf (file, "p_o_UFO code=%d", GET_CODE (x)); } } ! print_operand_address (file, addr) ! FILE *file; ! rtx addr; { switch (GET_CODE (addr)) { ! case REG: ! fprintf (file, "0,r%d ; P_O_A", REGNO (addr)); ! break; ! case PLUS: ! { ! register rtx x = XEXP (addr, 0), y = XEXP (addr, 1); ! switch (GET_CODE (x)) ! { ! case REG: ! switch (GET_CODE (y)) ! { ! case CONST: ! output_address (XEXP (y, 0)); ! fprintf (file, ",r%d ;P_O_A reg + const expr", REGNO (x)); break; ! case CONST_INT: ! fprintf (file, "%d,r%d", INTVAL (y), REGNO (x)); ! break; case SYMBOL_REF: ! fprintf (file, "%s,r%d ; P_O_A reg + sym", ! XSTR (y, 0), REGNO (x)); break; default: ! fprintf (file, "[P_O_A reg%d+UFO code=%d]", ! REGNO (x), GET_CODE (y)); ! } ! break; ! case LABEL_REF: ! case SYMBOL_REF: ! switch (GET_CODE (y)) ! { ! case CONST_INT: ! fprintf (file, "%d+%s", INTVAL (y), XSTR (x, 0)); ! break; ! case REG: ! fprintf (file, "%s,r%d ;P_O_A sym + reg", ! XSTR (x, 0), REGNO (y)); ! break; ! default: ! fprintf (file, "P_O_A sym/lab+UFO[sym=%s,code(y)=%d]", ! XSTR (x, 0), GET_CODE (y)); ! } ! break; ! case CONST: ! output_address (XEXP (x, 0)); ! if (GET_CODE (y) == REG) ! fprintf (file, ",r%d ;P_O_A const + reg", REGNO (x)); ! else ! fprintf (file, "P_O_A const+UFO code(y)=%d]", GET_CODE (y)); ! break; ! case MEM: ! output_address (y); ! fprintf (file, ",[mem:"); ! output_address (XEXP (x, 0)); ! fprintf (file, "] ;P_O_A plus"); ! break; ! default: ! fprintf (file, "P_O_A plus op1_UFO[code1=%d,code2=%d]", ! GET_CODE (x), GET_CODE (y)); } ! } ! break; ! case CONST_INT: ! if (INTVAL (addr) < 0x10000 && INTVAL (addr) >= -0x10000) ! fprintf (file, "%d ; p_o_a const addr?!", INTVAL (addr)); ! else ! { ! fprintf (file, "[p_o_a=ILLEGAL_CONST]"); ! output_addr_const (file, addr); ! } ! break; ! case LABEL_REF: ! case SYMBOL_REF: ! fprintf (file, "%s", XSTR (addr, 0)); ! break; ! case MEM: ! fprintf (file, "[memUFO:"); ! output_address (XEXP (addr, 0)); ! fprintf (file, "]"); ! break; ! case CONST: ! output_address (XEXP (addr, 0)); ! fprintf (file, " ;P_O_A const"); ! break; ! default: ! fprintf (file, " p_o_a UFO, code=%d val=0x%x", ! (int) GET_CODE (addr), INTVAL (addr)); ! break; } } + + /* + ASM_FILE_END(file) + FILE *file; + { + if (datalbl_ndx >= 0) { + int i, cum_size=0; + fprintf(file,"\n\tstatic\ninit_srel\n"); + for (i = 0; i <= datalbl_ndx; i++) { + if (datalbl[i].name == NULL) + { + fprintf (stderr, "asm_file_end intern err (datalbl)\n"); + exit (0); + } + fprintf(file,"%s\t block %d\n", + datalbl[i].name,datalbl[i].size); + cum_size += datalbl[i].size; + } + fprintf(file,"\n\tinit\n"); + fprintf(file,"\tLIM R0,init_srel ;dst\n"); + fprintf(file,"\tLIM R1,%d ;cnt\n",cum_size); + fprintf(file,"\tLIM R2,K%s ;src\n",datalbl[0].name); + fprintf(file,"\tMOV R0,R2\n"); + fprintf(file,"\n\tnormal\n"); + datalbl_ndx = -1; + for (i = 0; i < DATALBL_ARRSIZ; i++) + datalbl[i].size = 0; + } + fprintf(file,"\n\tend\n"); + } + */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/1750a/1750a.h gcc-2.6.1/config/1750a/1750a.h *** gcc-2.6.0/config/1750a/1750a.h Mon Jul 11 19:22:25 1994 --- gcc-2.6.1/config/1750a/1750a.h Tue Sep 20 19:30:51 1994 *************** *** 1,5 **** ! /* Definitions of target machine for GNU compiler, MIL-STD-1750A version. Copyright (C) 1994 Free Software Foundation, Inc. ! Contributed by O.M.Kellogg, Deutsche Aerospace (okellogg@salyko.cube.net). This file is part of GNU CC. --- 1,5 ---- ! /* Definitions of target machine for GNU compiler. Copyright (C) 1994 Free Software Foundation, Inc. ! Contributed by O.M.Kellogg, DASA (okellogg@salyko.cube.net). This file is part of GNU CC. *************** *** 49,53 **** /* See file aux-output.c for the actual data instances. */ struct datalabel_array { ! char name[14]; char value[14]; int size; --- 49,53 ---- /* See file aux-output.c for the actual data instances. */ struct datalabel_array { ! char *name; char value[14]; int size; *************** *** 57,61 **** int num; }; ! enum section { NREL, IREL, KREL, SREL }; #define DATALBL_ARRSIZ 256 #define JMPLBL_ARRSIZ 256 --- 57,61 ---- int num; }; ! enum section { Init, Normal, Konst, Static }; #define DATALBL_ARRSIZ 256 #define JMPLBL_ARRSIZ 256 *************** *** 66,69 **** --- 66,70 ---- extern enum section current_section; extern char *sectname[4]; + extern char *strdup(), *float_label(); #endif /*--------------------------------------------------------------------*/ *************** *** 180,189 **** /* 1 for registers that have pervasive standard uses and are not available for the register allocator. ! R15 is the 1750A stack pointer. R14 would be the frame ! pointer, but we'd like to try avoid using it if possible. */ #define FIXED_REGISTERS \ { 0, 0, 0, 0, 0, 0, 0, 0, \ ! 0, 0, 0, 0, 0, 0, 0, 1 } /* 1 for registers not available across function calls. --- 181,189 ---- /* 1 for registers that have pervasive standard uses and are not available for the register allocator. ! R15 is the 1750A stack pointer. R14 is the frame pointer. */ #define FIXED_REGISTERS \ { 0, 0, 0, 0, 0, 0, 0, 0, \ ! 0, 0, 0, 0, 0, 0, 1, 1 } /* 1 for registers not available across function calls. *************** *** 233,237 **** may be accessed via the stack pointer) in functions that seem suitable. This is computed in `reload', in reload1.c. */ ! #define FRAME_POINTER_REQUIRED 0 /* Base register for access to arguments of the function. */ --- 233,237 ---- may be accessed via the stack pointer) in functions that seem suitable. This is computed in `reload', in reload1.c. */ ! #define FRAME_POINTER_REQUIRED 1 /* Base register for access to arguments of the function. */ *************** *** 349,357 **** /* Similar, but for floating constants, and defining letter 'G'. ! Here VALUE is the CONST_DOUBLE rtx itself. ! 1750 longfloat constant 0.0 is worth recognizing 'cause it's got ! all bits zero. */ ! #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ ! ((C) == 'G' && (VALUE) == CONST0_RTX(HFmode)) /* Given an rtx X being reloaded into a reg required to be --- 349,354 ---- /* Similar, but for floating constants, and defining letter 'G'. ! Here VALUE is the CONST_DOUBLE rtx itself. */ ! #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 0 /* Given an rtx X being reloaded into a reg required to be *************** *** 453,457 **** /* 1 if the tree TYPE should be returned in memory instead of in regs. #define RETURN_IN_MEMORY(TYPE) \ ! (int_size_in_bytes(TYPE) > 13) */ --- 450,454 ---- /* 1 if the tree TYPE should be returned in memory instead of in regs. #define RETURN_IN_MEMORY(TYPE) \ ! (int_size_in_bytes(TYPE) > 12) */ *************** *** 472,476 **** such as FUNCTION_ARG to determine where the next arg should go. ! For 1750A, this is a single integer, which is a number of bytes of arguments scanned so far. */ --- 469,473 ---- such as FUNCTION_ARG to determine where the next arg should go. ! For 1750A, this is a single integer, which is a number of words of arguments scanned so far. */ *************** *** 549,556 **** fprintf(FILE,"\n"); \ if (SIZE > 0) \ ! fprintf(FILE,"\t%s R15,%d ; reserve local-variable space\n",\ ! (SIZE <= 16 ? "SISP" : "SIM "),SIZE); \ ! fprintf(FILE,"\tPSHM R14,R14 ; push old frame\n"); \ ! fprintf(FILE,"\tLR R14,R15 ; set new frame\n"); \ program_counter = 0; jmplbl_ndx = -1; \ } --- 546,553 ---- fprintf(FILE,"\n"); \ if (SIZE > 0) \ ! fprintf(FILE,"\t%s\tr15,%d ; reserve local-variable space\n",\ ! (SIZE <= 16 ? "sisp" : "sim"),SIZE); \ ! fprintf(FILE,"\tpshm\tr14,r14 ; push old frame\n"); \ ! fprintf(FILE,"\tlr\tr14,r15 ; set new frame\n"); \ program_counter = 0; jmplbl_ndx = -1; \ } *************** *** 592,599 **** #define FUNCTION_EPILOGUE(FILE, SIZE) { \ if (SIZE > 0) \ ! fprintf(FILE,"\t%s R14,%d ; free up local-var space\n", \ ! (SIZE <= 16 ? "AISP" : "AIM "),SIZE); \ ! fprintf(FILE,"\tLR R15,R14 ; set stack to return addr\n");\ ! fprintf(FILE,"\tURS R15\n"); } /* If the memory address ADDR is relative to the frame pointer, --- 589,597 ---- #define FUNCTION_EPILOGUE(FILE, SIZE) { \ if (SIZE > 0) \ ! fprintf(FILE,"\t%s\tr14,%d ; free up local-var space\n", \ ! (SIZE <= 16 ? "aisp" : "aim"),SIZE); \ ! fprintf(FILE,"\tlr\tr15,r14 ; set stack to return addr\n"); \ ! fprintf(FILE,"\tpopm\tr14,r14 ; restore prev. frame ptr\n"); \ ! fprintf(FILE,"\turs\tr15\n"); } /* If the memory address ADDR is relative to the frame pointer, *************** *** 603,607 **** #define FIX_FRAME_POINTER_ADDRESS(ADDR,DEPTH) \ ! fprintf(asm_out_file,"FIX_FRAME_POINTER_ADDRESS called, DEPTH=%d\n"), \ DEPTH), abort() --- 601,605 ---- #define FIX_FRAME_POINTER_ADDRESS(ADDR,DEPTH) \ ! fprintf(stderr,"FIX_FRAME_POINTER_ADDRESS called, DEPTH=%d\n"), \ DEPTH), abort() *************** *** 796,800 **** in one reasonably fast instruction. */ /* (was: "1750: not counting the MOV instruction") */ ! #define MOVE_MAX 256 /* Define this if zero-extension is slow (more than one real instruction). */ --- 794,798 ---- in one reasonably fast instruction. */ /* (was: "1750: not counting the MOV instruction") */ ! #define MOVE_MAX 16 /* Define this if zero-extension is slow (more than one real instruction). */ *************** *** 884,897 **** if (p = (char *)strchr(name,'.')) \ *p = '\0'; \ ! if (strlen(name) > 12) \ ! name[12] = '\0'; /* TekAs can handle only up to 12 char. */ \ ! fprintf(FILE,"\tNAME %s\n",name); \ ! fprintf(FILE,"\tNOLIST\n\tINCLUDE \"M1750.INC\"\n\tLIST\n"); \ ! fprintf(FILE,"\n\tSECTION SREL\n\tSECTION KREL\n\tSECTION IREL\n"); \ ! fprintf(FILE,"\tSECTION NREL\n"); } /* Output at end of assembler file. For 1750, we copy the data labels accrued in datalbl[] from the Constants ! section (KREL) to the Writable-Data section (SREL). */ #define ASM_FILE_END(FILE) \ --- 882,892 ---- if (p = (char *)strchr(name,'.')) \ *p = '\0'; \ ! fprintf(FILE,"\tname %s\n",name); \ ! fprintf(FILE,"\tnolist\n\tinclude \"ms1750.inc\"\n\tlist\n\n"); \ ! fprintf(FILE,"\tglobal\t__main\n\n"); } /* Output at end of assembler file. For 1750, we copy the data labels accrued in datalbl[] from the Constants ! section (Konst) to the Writable-Data section (Static). */ #define ASM_FILE_END(FILE) \ *************** *** 899,914 **** if (datalbl_ndx >= 0) { \ int i, cum_size=0; \ ! fprintf(FILE,"\n\tRESUME SREL\nINIT_SREL\n"); \ for (i = 0; i <= datalbl_ndx; i++) { \ ! fprintf(FILE,"%s\t BLOCK %d\n", \ datalbl[i].name,datalbl[i].size); \ cum_size += datalbl[i].size; \ } \ ! fprintf(FILE,"\n\tRESUME IREL\n"); \ ! fprintf(FILE,"\tLIM R0,INIT_SREL\n"); /* destin. */ \ ! fprintf(FILE,"\tLIM R1,%d\n",cum_size); /* count */ \ ! fprintf(FILE,"\tLIM R2,K%s\n",datalbl[0].name); /* source */ \ ! fprintf(FILE,"\tMOV R0,R2\n"); \ ! fprintf(FILE,"\n\tRESUME NREL\n"); \ datalbl_ndx = -1; /* reset stuff */ \ for (i = 0; i < DATALBL_ARRSIZ; i++) \ --- 894,914 ---- if (datalbl_ndx >= 0) { \ int i, cum_size=0; \ ! fprintf(FILE,"\n\tstatic\ninit_srel\n"); \ for (i = 0; i <= datalbl_ndx; i++) { \ ! if (datalbl[i].name == NULL) \ ! { \ ! fprintf(stderr, "asm_file_end internal datalbl err\n"); \ ! exit (0); \ ! } \ ! fprintf(FILE,"%s \tblock %d\n", \ datalbl[i].name,datalbl[i].size); \ cum_size += datalbl[i].size; \ } \ ! fprintf(FILE,"\n\tinit\n"); \ ! fprintf(FILE,"\tlim\tr0,init_srel\n"); /* destin. */ \ ! fprintf(FILE,"\tlim\tr1,%d\n",cum_size); /* count */ \ ! fprintf(FILE,"\tlim\tr2,K%s\n",datalbl[0].name); /* source */ \ ! fprintf(FILE,"\tmov\tr0,r2\n"); \ ! fprintf(FILE,"\n\tnormal\n"); \ datalbl_ndx = -1; /* reset stuff */ \ for (i = 0; i < DATALBL_ARRSIZ; i++) \ *************** *** 915,919 **** datalbl[i].size = 0; \ } \ ! fprintf(FILE,"\n\tEND\n"); \ } while (0) --- 915,919 ---- datalbl[i].size = 0; \ } \ ! fprintf(FILE,"\n\tend\n"); \ } while (0) *************** *** 921,925 **** may contain character constants, extra white space, comments, etc. */ ! #define ASM_APP_ON "\n\tIF 0\n; by ASM_APP_ON\n" /* Output to assembler file text saying following lines --- 921,925 ---- may contain character constants, extra white space, comments, etc. */ ! #define ASM_APP_ON "\n\tif 0\n; by ASM_APP_ON\n" /* Output to assembler file text saying following lines *************** *** 926,930 **** no longer contain unusual constructs. */ ! #define ASM_APP_OFF "\n\tENDIF\n" --- 926,930 ---- no longer contain unusual constructs. */ ! #define ASM_APP_OFF "\n\tendif\n" *************** *** 934,939 **** void const_section() \ { \ ! fprintf(asm_out_file,"\tRESUME KREL\n"); \ ! current_section = KREL; \ } \ check_section(enum section sect) \ --- 934,939 ---- void const_section() \ { \ ! fprintf(asm_out_file,"\tkonst\n"); \ ! current_section = Konst; \ } \ check_section(enum section sect) \ *************** *** 940,954 **** { \ if (current_section != sect) { \ ! fprintf(asm_out_file,"\tRESUME %s\n",sectname[(int)sect]); \ current_section = sect; \ } \ switch (sect) { \ ! case NREL: \ in_section = in_text; \ break; \ ! case SREL: \ in_section = in_data; \ break; \ ! case KREL: \ in_section = in_readonly_data; \ break; \ --- 940,955 ---- { \ if (current_section != sect) { \ ! fprintf(asm_out_file,"\t%s\n",sectname[(int)sect]); \ current_section = sect; \ } \ switch (sect) { \ ! case Init: \ ! case Normal: \ in_section = in_text; \ break; \ ! case Static: \ in_section = in_data; \ break; \ ! case Konst: \ in_section = in_readonly_data; \ break; \ *************** *** 960,968 **** #define READONLY_DATA_SECTION const_section /* Output before program text section */ ! #define TEXT_SECTION_ASM_OP "\n\tRESUME NREL ; text_section\n" /* Output before writable data. */ ! #define DATA_SECTION_ASM_OP "\n\tRESUME SREL ; data_section\n" /* How to refer to registers in assembler output. --- 961,972 ---- #define READONLY_DATA_SECTION const_section + /* Output before program init section */ + #define INIT_SECTION_ASM_OP "\n\tinit ; init_section\n" + /* Output before program text section */ ! #define TEXT_SECTION_ASM_OP "\n\tnormal ; text_section\n" /* Output before writable data. */ ! #define DATA_SECTION_ASM_OP "\n\tstatic ; data_section\n" /* How to refer to registers in assembler output. *************** *** 979,983 **** /****************** Assembler output formatting **********************/ ! #define ASM_IDENTIFY_GCC(FILE) #define ASM_COMMENT_START ";" --- 983,987 ---- /****************** Assembler output formatting **********************/ ! #define ASM_IDENTIFY_GCC(FILE) fputs ("; gcc2_compiled:\n", FILE) #define ASM_COMMENT_START ";" *************** *** 987,990 **** --- 991,1001 ---- #define ASM_OUTPUT_OPCODE(FILE,PTR) do { \ + while (*(PTR) != '\0' && *(PTR) != ' ') { \ + putc (*(PTR), FILE); \ + (PTR)++; \ + } \ + while (*(PTR) == ' ') \ + (PTR)++; \ + putc ('\t', FILE); \ program_counter += 2; \ } while (0) *************** *** 997,1015 **** /* 1750 note: Labels are prefixed with a 'K'. This is because handling has been changed for labels to be output in the "Constants" section ! (named "KREL"), and special initialization code takes care of copying ! the Const-section data into the writable data section (named "SREL"). ! In the SREL section we therefore have the true label names (i.e. not prefixed with 'K'). */ #define ASM_OUTPUT_LABEL(FILE,NAME) \ ! do { if (NAME[0] == '.') \ ! fprintf(FILE,"%s\n",NAME); \ ! else { \ ! if (strlen(NAME) > 11) NAME[11] = '\0'; \ ! check_section(KREL); \ ! fprintf(FILE,"K%s\n",NAME); \ ! strcpy(datalbl[++datalbl_ndx].name,NAME); \ ! label_pending = 1; \ ! } \ } while (0) --- 1008,1027 ---- /* 1750 note: Labels are prefixed with a 'K'. This is because handling has been changed for labels to be output in the "Constants" section ! (named "Konst"), and special initialization code takes care of copying ! the Const-section data into the writable data section (named "Static"). ! In the Static section we therefore have the true label names (i.e. not prefixed with 'K'). */ #define ASM_OUTPUT_LABEL(FILE,NAME) \ ! do { if (NAME[0] == '.') { \ ! fprintf(stderr,"Oops! label %s can't begin with '.'\n",NAME); \ ! abort(); \ ! } \ ! else { \ ! check_section(Konst); \ ! fprintf(FILE,"K%s\n",NAME); \ ! datalbl[++datalbl_ndx].name = (char *)strdup (NAME); \ ! label_pending = 1; \ ! } \ } while (0) *************** *** 1019,1025 **** #define ASM_GLOBALIZE_LABEL(FILE,NAME) do { \ ! check_section(NREL); \ ! fputs ("\tGLOBAL ", FILE); assemble_name (FILE, NAME); \ ! fputs (" ; export\n", FILE); } while (0) /* This is how to output a reference to a user-level label named NAME. --- 1031,1036 ---- #define ASM_GLOBALIZE_LABEL(FILE,NAME) do { \ ! fprintf (FILE, "\tglobal %s\t; export\n", NAME); \ ! } while (0) /* This is how to output a reference to a user-level label named NAME. *************** *** 1036,1041 **** if (strcmp(PREFIX,"LC") == 0) { \ label_pending = 1; \ ! sprintf(datalbl[++datalbl_ndx].name,"LC%d",NUM); \ ! check_section(KREL); \ fprintf(FILE,"K%s%d\n",PREFIX,NUM); \ } \ --- 1047,1053 ---- if (strcmp(PREFIX,"LC") == 0) { \ label_pending = 1; \ ! datalbl[++datalbl_ndx].name = (char *) malloc (9); \ ! sprintf(datalbl[datalbl_ndx].name,"LC%d",NUM); \ ! check_section(Konst); \ fprintf(FILE,"K%s%d\n",PREFIX,NUM); \ } \ *************** *** 1059,1073 **** constant. */ ! #define ASM_OUTPUT_FLOAT(FILE,VALUE) \ do { \ - char *tekfltstr = (char *)tekasm_float('E',VALUE); \ if (label_pending) \ label_pending = 0; \ else \ ! strcpy(datalbl[++datalbl_ndx].name, \ ! (char *)float_label('E',tekfltstr)); \ ! strcpy(datalbl[datalbl_ndx].value,tekfltstr); \ datalbl[datalbl_ndx].size = 2; \ ! fprintf (FILE, "\tDATAF %s\n",tekfltstr); \ } while(0) --- 1071,1083 ---- constant. */ ! #define ASM_OUTPUT_SHORT_FLOAT(FILE,VALUE) \ do { \ if (label_pending) \ label_pending = 0; \ else \ ! datalbl[++datalbl_ndx].name = float_label('D',VALUE); \ ! sprintf (datalbl[datalbl_ndx].value, "%lf", (double) VALUE); \ datalbl[datalbl_ndx].size = 2; \ ! fprintf (FILE, "\tdataf\t%lf\n",VALUE); \ } while(0) *************** *** 1077,1089 **** #define ASM_OUTPUT_THREE_QUARTER_FLOAT(FILE,VALUE) \ do { \ - char *tekfltstr = (char *)tekasm_float('D',VALUE); \ if (label_pending) \ label_pending = 0; \ else \ ! strcpy(datalbl[++datalbl_ndx].name, \ ! (char *)float_label('D',tekfltstr)); \ ! strcpy(datalbl[datalbl_ndx].value,tekfltstr); \ datalbl[datalbl_ndx].size = 3; \ ! fprintf(FILE,"\tDATAF %s\n",tekfltstr); \ } while (0) --- 1087,1097 ---- #define ASM_OUTPUT_THREE_QUARTER_FLOAT(FILE,VALUE) \ do { \ if (label_pending) \ label_pending = 0; \ else \ ! datalbl[++datalbl_ndx].name = float_label('E',VALUE); \ ! sprintf (datalbl[datalbl_ndx].value, "%lf", VALUE); \ datalbl[datalbl_ndx].size = 3; \ ! fprintf(FILE,"\tdataef\t%lf\n",VALUE); \ } while (0) *************** *** 1100,1106 **** for (i = 0; i < LEN; i++) \ if (PTR[i] >= 32 && PTR[i] < 127) \ ! fprintf(FILE,"\tDATA %d\t; '%c'\n",PTR[i],PTR[i]); \ else \ ! fprintf(FILE,"\tDATA %d\t; (ascii)\n",PTR[i]); \ } while (0) --- 1108,1114 ---- for (i = 0; i < LEN; i++) \ if (PTR[i] >= 32 && PTR[i] < 127) \ ! fprintf(FILE,"\tdata\t%d\t; '%c'\n",PTR[i],PTR[i]); \ else \ ! fprintf(FILE,"\tdata\t%d\t; (ascii)\n",PTR[i]); \ } while (0) *************** *** 1114,1118 **** datalbl[datalbl_ndx].size = 1; \ } \ ! fprintf(FILE, "\tDATA "); output_addr_const(FILE,VALUE); \ fprintf(FILE, "\n"); } while (0) --- 1122,1126 ---- datalbl[datalbl_ndx].size = 1; \ } \ ! fprintf(FILE, "\tdata\t"); output_addr_const(FILE,VALUE); \ fprintf(FILE, "\n"); } while (0) *************** *** 1126,1130 **** datalbl[datalbl_ndx].size = 2; \ } \ ! fprintf(FILE, "\tDATAL "); output_addr_const(FILE,VALUE); \ fprintf(FILE, "\n"); } while (0) --- 1134,1138 ---- datalbl[datalbl_ndx].size = 2; \ } \ ! fprintf(FILE, "\tdatal\t"); output_addr_const(FILE,VALUE); \ fprintf(FILE, "\n"); } while (0) *************** *** 1157,1161 **** #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ ! fprintf (FILE, "\tDATA L%d ;addr_vec_elt\n", VALUE) /* This is how to output an element of a case-vector that is relative. */ --- 1165,1169 ---- #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ ! fprintf (FILE, "\tdata\tL%d ;addr_vec_elt\n", VALUE) /* This is how to output an element of a case-vector that is relative. */ *************** *** 1162,1166 **** #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ ! fprintf (FILE, "\tDATA L%d-L%d ;addr_diff_elt\n", VALUE,REL) /* This is how to output an assembler line --- 1170,1174 ---- #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ ! fprintf (FILE, "\tdata\tL%d-L%d ;addr_diff_elt\n", VALUE,REL) /* This is how to output an assembler line *************** *** 1178,1189 **** #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) do { \ ! check_section(NREL); \ ! fprintf(FILE,"\tGLOBAL "); assemble_name(FILE,NAME); \ ! fprintf(FILE," ; common\n"); } while (0) #define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME) do { \ ! check_section(NREL); \ ! fprintf(FILE,"\tGLOBAL "); assemble_name(FILE,NAME); \ ! fprintf(FILE,"\t; external\n"); } while (0) /* This says how to output an assembler line --- 1186,1195 ---- #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) do { \ ! fprintf (FILE, "\tcommon %s,%d\n", NAME, SIZE); \ ! } while (0) #define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME) do { \ ! fprintf (FILE, "\tglobal %s\t; import\n", NAME); \ ! } while (0) /* This says how to output an assembler line *************** *** 1191,1196 **** #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) do { \ ! check_section(SREL); \ ! fprintf(FILE,"%s \tBLOCK %d ; local\n",NAME,SIZE); \ } while (0) --- 1197,1202 ---- #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) do { \ ! check_section (Static); \ ! fprintf(FILE,"%s \tblock %d\t; local common\n",NAME,SIZE); \ } while (0) *************** *** 1202,1205 **** --- 1208,1219 ---- ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO))) + + #define ASM_OUTPUT_CONSTRUCTOR(FILE, NAME) do { \ + fprintf(FILE, "\tinit\n\t"); assemble_name(NAME); \ + fprintf(FILE," ;constructor"); } while (0) + + #define ASM_OUTPUT_DESTRUCTOR(FILE, NAME) do { \ + fprintf(FILE, "\tinit\n\t"); assemble_name(NAME); \ + fprintf(FILE," ;destructor"); } while (0) /* Define the parentheses used to group arithmetic operations diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/1750a/1750a.md gcc-2.6.1/config/1750a/1750a.md *** gcc-2.6.0/config/1750a/1750a.md Mon Jul 11 19:23:06 1994 --- gcc-2.6.1/config/1750a/1750a.md Tue Sep 20 19:31:39 1994 *************** *** 1,5 **** ! ;;- Machine description for GNU compiler, MIL-STD-1750A version. ! ;; Copyright (C) 1994 Free Software Foundation, Inc. ! ;; Contributed by O.M.Kellogg, Deutsche Aerospace (okellogg@salyko.cube.net). ;; This file is part of GNU CC. --- 1,6 ---- ! ;;- Machine description for GNU compiler ! ;;- MIL-STD-1750A version. ! ;; Copyright (C) 1994 Free Software Foundation, Inc. ! ;; Contributed by O.M.Kellogg, DASA (okellogg@salyko.cube.net). ;; This file is part of GNU CC. *************** *** 54,58 **** (match_operand:QI 1 "general_operand" "r"))] "" ! "PSHM R%1,R%1") (define_insn "" --- 55,59 ---- (match_operand:QI 1 "general_operand" "r"))] "" ! "pshm r%1,r%1") (define_insn "" *************** *** 76,80 **** new_operands[0] = operands[1]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+1); ! output_asm_insn(\"PSHM R%0,R%1\",new_operands); return \"\;\"; } ") --- 77,81 ---- new_operands[0] = operands[1]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+1); ! output_asm_insn(\"pshm r%0,r%1\",new_operands); return \"\;\"; } ") *************** *** 89,93 **** new_operands[0] = operands[1]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+2); ! output_asm_insn(\"PSHM R%0,R%1\",new_operands); return \"\;\"; } ") --- 90,94 ---- new_operands[0] = operands[1]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[1])+2); ! output_asm_insn(\"pshm r%0,r%1\",new_operands); return \"\;\"; } ") *************** *** 98,102 **** (match_operand:QI 1 "push_operand" ">"))] "" ! "POPM R%1,R%1") (define_insn "" --- 99,103 ---- (match_operand:QI 1 "push_operand" ">"))] "" ! "popm r%1,r%1") (define_insn "" *************** *** 109,113 **** new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1); ! output_asm_insn(\"POPM R%0,R%1\",new_operands); return \"\;\"; } ") --- 110,114 ---- new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1); ! output_asm_insn(\"popm r%0,r%1\",new_operands); return \"\;\"; } ") *************** *** 122,126 **** new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1); ! output_asm_insn(\"POPM R%0,R%1\",new_operands); return \"\;\"; } ") --- 123,127 ---- new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+1); ! output_asm_insn(\"popm r%0,r%1\",new_operands); return \"\;\"; } ") *************** *** 135,139 **** new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+2); ! output_asm_insn(\"POPM R%0,R%1\",new_operands); return \"\;\"; } ") --- 136,140 ---- new_operands[0] = operands[0]; new_operands[1] = gen_rtx(CONST_INT,VOIDmode,REGNO(operands[0])+2); ! output_asm_insn(\"popm r%0,r%1\",new_operands); return \"\;\"; } ") *************** *** 146,150 **** (match_operand:QI 0 "register_operand" "r"))] "" ! "LR R%0,R%0 ; from tstqi") (define_insn "tsthi" --- 147,151 ---- (match_operand:QI 0 "register_operand" "r"))] "" ! "lr r%0,r%0 ; from tstqi") (define_insn "tsthi" *************** *** 152,156 **** (match_operand:HI 0 "register_operand" "r"))] "" ! "DLR R%0,R%0 ; from tsthi") (define_insn "tsthf" --- 153,157 ---- (match_operand:HI 0 "register_operand" "r"))] "" ! "dlr r%0,r%0 ; from tsthi") (define_insn "tsthf" *************** *** 158,162 **** (match_operand:HF 0 "register_operand" "r"))] "" ! "DLR R%0,R%0 ; from tsthf") ;; This one is happy with "roughly zero" :-) (should be improved) --- 159,163 ---- (match_operand:HF 0 "register_operand" "r"))] "" ! "dlr r%0,r%0 ; from tsthf") ;; This one is happy with "roughly zero" :-) (should be improved) *************** *** 165,169 **** (match_operand:TQF 0 "register_operand" "r"))] "" ! "DLR R%0,R%0 ; from tsttqf") --- 166,170 ---- (match_operand:TQF 0 "register_operand" "r"))] "" ! "dlr r%0,r%0 ; from tsttqf") *************** *** 193,201 **** "" "@ ! CISP R%0,%1 ! CISN R%0,%J1 ! CIM R%0,%1 ! CR R%0,R%1 ! C R%0,%1 ") (define_insn "cmphi" --- 194,202 ---- "" "@ ! cisp r%0,%1 ! cisn r%0,%J1 ! cim r%0,%1 ! cr r%0,r%1 ! c r%0,%1 ") (define_insn "cmphi" *************** *** 205,210 **** "" "@ ! DCR R%0,R%1 ! DC R%0,%1 ") (define_insn "cmphf" --- 206,211 ---- "" "@ ! dcr r%0,r%1 ! dc r%0,%1 ") (define_insn "cmphf" *************** *** 214,219 **** "" "@ ! FCR R%0,R%1 ! FC R%0,%1 ") (define_insn "cmptqf" --- 215,220 ---- "" "@ ! fcr r%0,r%1 ! fc r%0,%1 ") (define_insn "cmptqf" *************** *** 223,228 **** "" "@ ! EFCR R%0,R%1 ! EFC R%0,%1 ") --- 224,229 ---- "" "@ ! efcr r%0,r%1 ! efc r%0,%1 ") *************** *** 238,242 **** { REGNO(operands[1]) += 1; ! return \"LR R%0,R%1 ;trunchiqi2\"; } ") --- 239,243 ---- { REGNO(operands[1]) += 1; ! return \"lr r%0,r%1 ;trunchiqi2\"; } ") *************** *** 249,253 **** "* { ! output_asm_insn(\"XORR R%0,R%0 ;zero_extendqihi2\",operands); REGNO(operands[0]) += 1; switch (which_alternative) --- 250,254 ---- "* { ! output_asm_insn(\"xorr r%0,r%0 ;zero_extendqihi2\",operands); REGNO(operands[0]) += 1; switch (which_alternative) *************** *** 254,262 **** { case 0: ! return \"LR R%0,R%1\"; case 1: ! return \"L R%0,%1\"; case 2: ! return \"LIM R%0,%1\"; } } ") --- 255,263 ---- { case 0: ! return \"lr r%0,r%1\"; case 1: ! return \"l r%0,%1\"; case 2: ! return \"lim r%0,%1\"; } } ") *************** *** 269,275 **** "" "@ ! LR R%0,R%1 ;extendqihi2\;DSRA R%0,16 ! L R%0,%1 ;extendqihi2\;DSRA R%0,16 ! LIM R%0,%1 ;extendqihi2\;DSRA R%0,16 ") --- 270,276 ---- "" "@ ! lr r%0,r%1 ;extendqihi2\;dsra r%0,16 ! l r%0,%1 ;extendqihi2\;dsra r%0,16 ! lim r%0,%1 ;extendqihi2\;dsra r%0,16 ") *************** *** 285,294 **** { REGNO(operands[0]) += 2; ! output_asm_insn(\"XORR R%0,R%0 ;extendhftqf2\",operands); REGNO(operands[0]) -= 2; if (which_alternative == 0) ! return \"DLR R%0,R%1\"; else ! return \"DL R%0,%1\"; } ") --- 286,295 ---- { REGNO(operands[0]) += 2; ! output_asm_insn(\"xorr r%0,r%0 ;extendhftqf2\",operands); REGNO(operands[0]) -= 2; if (which_alternative == 0) ! return \"dlr r%0,r%1\"; else ! return \"dl r%0,%1\"; } ") *************** *** 300,305 **** "" "@ ! DLR R%0,R%1 ;trunctqfhf2 ! DL R%0,%1 ;trunctqfhf2 ") --- 301,306 ---- "" "@ ! dlr r%0,r%1 ;trunctqfhf2 ! dl r%0,%1 ;trunctqfhf2 ") *************** *** 310,314 **** (float:HF (match_operand:QI 1 "register_operand" "r")))] "" ! "FLT R%0,R%1") (define_insn "floathitqf2" --- 311,315 ---- (float:HF (match_operand:QI 1 "register_operand" "r")))] "" ! "flt r%0,r%1") (define_insn "floathitqf2" *************** *** 316,320 **** (float:TQF (match_operand:HI 1 "register_operand" "r")))] "" ! "EFLT R%0,R%1") --- 317,321 ---- (float:TQF (match_operand:HI 1 "register_operand" "r")))] "" ! "eflt r%0,r%1") *************** *** 325,329 **** (fix:QI (fix:HF (match_operand:HF 1 "register_operand" "r"))))] "" ! "FIX R%0,R%1") (define_insn "fix_trunctqfhi2" --- 326,330 ---- (fix:QI (fix:HF (match_operand:HF 1 "register_operand" "r"))))] "" ! "fix r%0,r%1") (define_insn "fix_trunctqfhi2" *************** *** 331,335 **** (fix:HI (fix:TQF (match_operand:TQF 1 "register_operand" "r"))))] "" ! "EFIX R%0,R%1") --- 332,336 ---- (fix:HI (fix:TQF (match_operand:TQF 1 "register_operand" "r"))))] "" ! "efix r%0,r%1") *************** *** 347,359 **** "" "@ ! XORR R%0,R%0 ! LISP R%0,%1 ! LISN R%0,%J1 ! LIM R%0,%1 ; 'M' constraint ! LIM R%0,%1 ; 'i' constraint ! LR R%0,R%1 ! L R%0,%1 ! ST R%1,%0 ! STC %1,%0 ") ;; 32-bit moves --- 348,360 ---- "" "@ ! xorr r%0,r%0 ! lisp r%0,%1 ! lisn r%0,%J1 ! lim r%0,%1 ; 'M' constraint ! lim r%0,%1 ; 'i' constraint ! lr r%0,r%1 ! l r%0,%1 ! st r%1,%0 ! stc %1,%0 ") ;; 32-bit moves *************** *** 372,394 **** if (val <= 65535) { ! output_asm_insn(\"XORR R%0,R%0 ;movhi cst->reg\",operands); operands[0] = gen_rtx(REG,QImode,REGNO(operands[0]) + 1); if (val == 0) ! return \"XORR R%0,R%0\"; else if (val <= 16) ! return \"LISP R%0,%1\"; else ! return \"LIM R%0,%1\"; } } else if (val >= -16) ! return \"LISN R%0,%J1\;DSRA R%0,16 ;movhi cst\"; INTVAL(operands[1]) >>= 16; ! output_asm_insn(\"LIM R%0,%1 ;movhi cst->reg\",operands); REGNO(operands[0]) += 1; INTVAL(operands[1]) = val & 0xFFFF; ! return \"LIM R%0,%1\"; } ! return \"LIM R%0,%1\;DSRA R%0,16 ;movhi cst\"; ") --- 373,395 ---- if (val <= 65535) { ! output_asm_insn(\"xorr r%0,r%0 ;movhi cst->reg\",operands); operands[0] = gen_rtx(REG,QImode,REGNO(operands[0]) + 1); if (val == 0) ! return \"xorr r%0,r%0\"; else if (val <= 16) ! return \"lisp r%0,%1\"; else ! return \"lim r%0,%1\"; } } else if (val >= -16) ! return \"lisn r%0,%J1\;dsra r%0,16 ;movhi cst\"; INTVAL(operands[1]) >>= 16; ! output_asm_insn(\"lim r%0,%1 ;movhi cst->reg\",operands); REGNO(operands[0]) += 1; INTVAL(operands[1]) = val & 0xFFFF; ! return \"lim r%0,%1\"; } ! return \"lim r%0,%1\;dsra r%0,16 ;movhi cst\"; ") *************** *** 398,404 **** "" "@ ! DLR R%0,R%1 ! DL R%0,%1 ! DST R%1,%0 ") --- 399,405 ---- "" "@ ! dlr r%0,r%1 ! dl r%0,%1 ! dst r%1,%0 ") *************** *** 405,418 **** ;; Single-Float moves are *same* as HImode moves: (define_insn "movhf" ! [(set (match_operand:HF 0 "general_operand" "=r,r,r,r,m") ! (match_operand:HF 1 "general_operand" "G,F,r,m,r"))] "" "@ ! DXRR.M %0,%0 ; movhf const(0.0) ! %E1\;DL R%0,%F1 ! DLR R%0,R%1 ! DL R%0,%1 ! DST R%1,%0 ") --- 406,427 ---- ;; Single-Float moves are *same* as HImode moves: + ;(define_insn "movhf" + ; [(set (match_operand:HF 0 "general_operand" "=r,r,r,m") + ; (match_operand:HF 1 "general_operand" "F,r,m,r"))] + ; "" + ; "@ + ; %D1\;dl r%0,%F1 + ; dlr r%0,r%1 + ; dl r%0,%1 + ; dst r%1,%0 ") + (define_insn "movhf" ! [(set (match_operand:HF 0 "general_operand" "=r,r,m") ! (match_operand:HF 1 "general_operand" "r,m,r"))] "" "@ ! dlr r%0,r%1 ! dl r%0,%1 ! dst r%1,%0 ") *************** *** 419,431 **** ;; Longfloat moves (define_insn "movtqf" ! [(set (match_operand:TQF 0 "general_operand" "=r,r,r,m") ! (match_operand:TQF 1 "general_operand" "F,r,m,r"))] "" "@ ! %D1\;EFL R%0,%F1 ! EFLR.M %0,%1 ! EFL R%0,%1 ! EFST R%1,%0 ") --- 428,449 ---- ;; Longfloat moves + ;(define_insn "movtqf" + ; [(set (match_operand:TQF 0 "general_operand" "=r,r,r,m") + ; (match_operand:TQF 1 "general_operand" "F,r,m,r"))] + ; "" + ; "@ + ; %E1\;efl r%0,%G1 + ; eflr.m %0,%1 + ; efl r%0,%1 + ; efst r%1,%0 ") + (define_insn "movtqf" ! [(set (match_operand:TQF 0 "general_operand" "=r,r,m") ! (match_operand:TQF 1 "general_operand" "r,m,r"))] "" "@ ! eflr.m %0,%1 ! efl r%0,%1 ! efst r%1,%0 ") *************** *** 441,445 **** ; (match_operand:QI 2 "immediate_operand" "i")))] ; "REGNO(operands[0]) != REGNO(operands[1])" ! ; "LIM R%0,%2,R%1 ;md special addqi") (define_insn "addqi3" --- 459,463 ---- ; (match_operand:QI 2 "immediate_operand" "i")))] ; "REGNO(operands[0]) != REGNO(operands[1])" ! ; "lim r%0,%2,r%1 ;md special addqi") (define_insn "addqi3" *************** *** 452,471 **** { case 0: ! return \"AISP R%0,%2\"; case 1: ! return \"SISP R%0,%J2\"; case 2: if (INTVAL(operands[2]) < 0) ! return \"SIM R%0,%J2\"; else ! return \"AIM R%0,%2\"; case 3: ! return \"AR R%0,R%2\"; case 4: ! return \"A R%0,%2\"; case 5: ! return \"INCM %2,%0\"; case 6: ! return \"DECM %J2,%0\"; } ") --- 470,489 ---- { case 0: ! return \"aisp r%0,%2\"; case 1: ! return \"sisp r%0,%J2\"; case 2: if (INTVAL(operands[2]) < 0) ! return \"sim r%0,%J2\"; else ! return \"aim r%0,%2\"; case 3: ! return \"ar r%0,r%2\"; case 4: ! return \"a r%0,%2\"; case 5: ! return \"incm %2,%0\"; case 6: ! return \"decm %J2,%0\"; } ") *************** *** 477,482 **** "" "@ ! DAR R%0,R%2 ! DA R%0,%2 ") (define_insn "addhf3" --- 495,500 ---- "" "@ ! dar r%0,r%2 ! da r%0,%2 ") (define_insn "addhf3" *************** *** 486,491 **** "" "@ ! FA R%0,%2 ! FAR R%0,R%2 ") (define_insn "addtqf3" --- 504,509 ---- "" "@ ! fa r%0,%2 ! far r%0,r%2 ") (define_insn "addtqf3" *************** *** 495,500 **** "" "@ ! EFA R%0,%2 ! EFAR R%0,R%2 ") --- 513,518 ---- "" "@ ! efa r%0,%2 ! efar r%0,r%2 ") *************** *** 508,516 **** "" "@ ! SISP R%0,%2 ! SIM R%0,%2 ! SR R%0,R%2 ! S R%0,%2 ! DECM %2,%0 ") ;; double integer --- 526,534 ---- "" "@ ! sisp r%0,%2 ! sim r%0,%2 ! sr r%0,r%2 ! s r%0,%2 ! decm %2,%0 ") ;; double integer *************** *** 521,526 **** "" "@ ! DSR R%0,R%2 ! DS R%0,%2 ") (define_insn "subhf3" --- 539,544 ---- "" "@ ! dsr r%0,r%2 ! ds r%0,%2 ") (define_insn "subhf3" *************** *** 530,535 **** "" "@ ! FSR R%0,R%2 ! FS R%0,%2 ") (define_insn "subtqf3" --- 548,553 ---- "" "@ ! fsr r%0,r%2 ! fs r%0,%2 ") (define_insn "subtqf3" *************** *** 539,544 **** "" "@ ! EFSR R%0,R%2 ! EFS R%0,%2 ") --- 557,562 ---- "" "@ ! efsr r%0,r%2 ! efs r%0,%2 ") *************** *** 551,559 **** "" "@ ! MISP R%0,%2 ! MISN R%0,%J2 ! MSIM R%0,%2 ! MSR R%0,R%2 ! MS R%0,%2 ") --- 569,577 ---- "" "@ ! misp r%0,%2 ! misn r%0,%J2 ! msim r%0,%2 ! msr r%0,r%2 ! ms r%0,%2 ") *************** *** 565,571 **** "" "@ ! MIM R%0,%1 ! MR R%0,R%2 ! M R%0,%2 ") (define_insn "mulhi3" --- 583,589 ---- "" "@ ! mim r%0,%1 ! mr r%0,r%2 ! m r%0,%2 ") (define_insn "mulhi3" *************** *** 575,580 **** "" "@ ! DMR R%0,R%2 ! DM R%0,%2 ") ; not available on 1750: "umulhi3","umulhisi3","umulsi3" (unsigned multiply's) --- 593,598 ---- "" "@ ! dmr r%0,r%2 ! dm r%0,%2 ") ; not available on 1750: "umulhi3","umulhisi3","umulsi3" (unsigned multiply's) *************** *** 586,591 **** "" "@ ! FMR R%0,R%2 ! FM R%0,%2 ") (define_insn "multqf3" --- 604,609 ---- "" "@ ! fmr r%0,r%2 ! fm r%0,%2 ") (define_insn "multqf3" *************** *** 595,600 **** "" "@ ! EFMR R%0,R%2 ! EFM R%0,%2 ") --- 613,618 ---- "" "@ ! efmr r%0,r%2 ! efm r%0,%2 ") *************** *** 622,639 **** { case 0: ! istr = \"DISP\"; break; case 1: INTVAL(operands[2]) = - INTVAL(operands[2]); /* to be corrected */ ! istr = \"DISN\"; break; case 2: ! istr = \"DVIM\"; break; case 3: ! istr = \"DVR \"; break; case 4: ! istr = \"DV \"; break; } --- 640,657 ---- { case 0: ! istr = \"disp\"; break; case 1: INTVAL(operands[2]) = - INTVAL(operands[2]); /* to be corrected */ ! istr = \"disn\"; break; case 2: ! istr = \"dvim\"; break; case 3: ! istr = \"dvr \"; break; case 4: ! istr = \"dv \"; break; } *************** *** 649,654 **** "" "@ ! DDR R%0,R%2 ! DD R%0,%2 ") (define_insn "divhf3" --- 667,672 ---- "" "@ ! ddr r%0,r%2 ! dd r%0,%2 ") (define_insn "divhf3" *************** *** 658,663 **** "" "@ ! FDR R%0,R%2 ! FD R%0,%2 ") (define_insn "divtqf3" --- 676,681 ---- "" "@ ! fdr r%0,r%2 ! fd r%0,%2 ") (define_insn "divtqf3" *************** *** 667,672 **** "" "@ ! EFDR R%0,R%2 ! EFD R%0,%2 ") --- 685,690 ---- "" "@ ! efdr r%0,r%2 ! efd r%0,%2 ") *************** *** 679,683 **** (abs:QI (match_operand:QI 1 "register_operand" "r")))] "" ! "ABS R%0,R%1") (define_insn "abshi2" --- 697,701 ---- (abs:QI (match_operand:QI 1 "register_operand" "r")))] "" ! "abs r%0,r%1") (define_insn "abshi2" *************** *** 685,689 **** (abs:HI (match_operand:HI 1 "register_operand" "r")))] "" ! "DABS R%0,R%1") (define_insn "abshf2" --- 703,707 ---- (abs:HI (match_operand:HI 1 "register_operand" "r")))] "" ! "dabs r%0,r%1") (define_insn "abshf2" *************** *** 691,695 **** (abs:HF (match_operand:HF 1 "register_operand" "r")))] "" ! "FABS R%0,R%1") --- 709,713 ---- (abs:HF (match_operand:HF 1 "register_operand" "r")))] "" ! "fabs r%0,r%1") *************** *** 700,704 **** (neg:QI (match_operand:QI 1 "register_operand" "r")))] "" ! "NEG R%0,R%1") (define_insn "neghi2" --- 718,722 ---- (neg:QI (match_operand:QI 1 "register_operand" "r")))] "" ! "neg r%0,r%1") (define_insn "neghi2" *************** *** 706,710 **** (neg:HI (match_operand:HI 1 "register_operand" "r")))] "" ! "DNEG R%0,R%1") (define_insn "neghf2" --- 724,728 ---- (neg:HI (match_operand:HI 1 "register_operand" "r")))] "" ! "dneg r%0,r%1") (define_insn "neghf2" *************** *** 712,728 **** (neg:HF (match_operand:HF 1 "register_operand" "r")))] "" ! "FNEG R%0,R%1") ; The 1750A does not have an extended float negate instruction, so simulate. ! ;(define_expand "negtqf2" ! ; [(set (match_operand:TQF 0 "register_operand" "=&r") ! ; (neg:TQF (match_operand:TQF 1 "register_operand" "r")))] ! ; "" ! ; " ! ; emit_insn(gen_rtx(SET,VOIDmode,operands[0],CONST0_RTX(TQFmode))); ! ; emit_insn(gen_rtx(SET,VOIDmode,operands[0], ! ; gen_rtx(MINUS,TQFmode,operands[0],operands[1]))); ! ; DONE; ! ; ") --- 730,746 ---- (neg:HF (match_operand:HF 1 "register_operand" "r")))] "" ! "fneg r%0,r%1") ; The 1750A does not have an extended float negate instruction, so simulate. ! (define_expand "negtqf2" ! [(set (match_operand:TQF 0 "register_operand" "=&r") ! (neg:TQF (match_operand:TQF 1 "register_operand" "r")))] ! "" ! " ! emit_insn(gen_rtx(SET,VOIDmode,operands[0],CONST0_RTX(TQFmode))); ! emit_insn(gen_rtx(SET,VOIDmode,operands[0], ! gen_rtx(MINUS,TQFmode,operands[0],operands[1]))); ! DONE; ! ") *************** *** 737,743 **** "" "@ ! ANDM R%0,%2 ! ANDR R%0,R%2 ! AND R%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() --- 755,761 ---- "" "@ ! andm r%0,%2 ! andr r%0,r%2 ! and r%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() *************** *** 747,751 **** (match_operand:HI 2 "register_operand" "r")))] "" ! "DANR.M %0,%2") ;; OR --- 765,769 ---- (match_operand:HI 2 "register_operand" "r")))] "" ! "danr.m %0,%2") ;; OR *************** *** 757,763 **** "" "@ ! ORIM R%0,%2 ! ORR R%0,R%2 ! OR R%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() --- 775,781 ---- "" "@ ! orim r%0,%2 ! orr r%0,r%2 ! or r%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() *************** *** 767,771 **** (match_operand:HI 2 "register_operand" "r")))] "" ! "DORR.M %0,%2") ;; XOR --- 785,789 ---- (match_operand:HI 2 "register_operand" "r")))] "" ! "dorr.m %0,%2") ;; XOR *************** *** 777,783 **** "" "@ ! XORM R%0,%2 ! XORR R%0,R%2 ! XOR R%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() --- 795,801 ---- "" "@ ! xorm r%0,%2 ! xorr r%0,r%2 ! xor r%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() *************** *** 787,791 **** (match_operand:HI 2 "register_operand" "r")))] "" ! "DXRR.M %0,%2") ;; NAND --- 805,809 ---- (match_operand:HI 2 "register_operand" "r")))] "" ! "dxrr.m %0,%2") ;; NAND *************** *** 797,803 **** "" "@ ! NIM R%0,%2 ! NR R%0,R%2 ! N R%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() --- 815,821 ---- "" "@ ! nim r%0,%2 ! nr r%0,r%2 ! n r%0,%2 ") ; This sets incorrect condition codes. See notice_update_cc() *************** *** 807,811 **** (not:HI (match_operand:HI 2 "register_operand" "r"))))] "" ! "DNR.M %0,%2") ;; NOT --- 825,829 ---- (not:HI (match_operand:HI 2 "register_operand" "r"))))] "" ! "dnr.m %0,%2") ;; NOT *************** *** 815,819 **** (not:QI (match_operand:QI 1 "register_operand" "0")))] "" ! "NR R%0,R%0") ; This sets incorrect condition codes. See notice_update_cc() --- 833,837 ---- (not:QI (match_operand:QI 1 "register_operand" "0")))] "" ! "nr r%0,r%0") ; This sets incorrect condition codes. See notice_update_cc() *************** *** 822,826 **** (not:HI (match_operand:HI 1 "register_operand" "0")))] "" ! "DNR.M %0,%0") --- 840,844 ---- (not:HI (match_operand:HI 1 "register_operand" "0")))] "" ! "dnr.m %0,%0") *************** *** 834,840 **** "" "@ ! ; optimized away an SLL R%0,0 ! SLL R%0,%2 ! SLR R%0,R%2 ") (define_insn "ashlhi3" --- 852,858 ---- "" "@ ! ; optimized away an SLL r%0,0 ! sll r%0,%2 ! slr r%0,r%2 ") (define_insn "ashlhi3" *************** *** 844,849 **** "" ; the 'L' constraint is a slight imprecise... "@ ! DSLL R%0,%2 ! DSLR R%0,R%2 ") (define_insn "lshrqi3" --- 862,867 ---- "" ; the 'L' constraint is a slight imprecise... "@ ! dsll r%0,%2 ! dslr r%0,r%2 ") (define_insn "lshrqi3" *************** *** 853,858 **** "" "@ ! SRL R%0,%2 ! NEG R%2,R%2\;SLR R%0,R%2 ") (define_insn "lshrhi3" --- 871,876 ---- "" "@ ! srl r%0,%2 ! neg r%2,r%2\;slr r%0,r%2 ") (define_insn "lshrhi3" *************** *** 862,867 **** "" ; the 'L' constraint is a slight imprecise... "@ ! DSRL R%0,%2 ! NEG R%2,R%2\;DSLR R%0,R%2 ") (define_insn "ashrqi3" --- 880,885 ---- "" ; the 'L' constraint is a slight imprecise... "@ ! dsrl r%0,%2 ! neg r%2,r%2\;dslr r%0,r%2 ") (define_insn "ashrqi3" *************** *** 871,876 **** "" "@ ! SRA R%0,%2 ! NEG R%2,R%2\;SAR R%0,R%2 ") (define_insn "ashrhi3" --- 889,894 ---- "" "@ ! sra r%0,%2 ! neg r%2,r%2\;sar r%0,r%2 ") (define_insn "ashrhi3" *************** *** 880,885 **** "" "@ ! DSRA R%0,%2 ! NEG R%2,R%2\;DSAR R%0,R%2 ") --- 898,903 ---- "" "@ ! dsra r%0,%2 ! neg r%2,r%2\;dsar r%0,r%2 ") *************** *** 892,897 **** "" "@ ! SLC R%0,%2 ! SCR R%0,R%2 ") (define_insn "rotlhi3" --- 910,915 ---- "" "@ ! slc r%0,%2 ! scr r%0,r%2 ") (define_insn "rotlhi3" *************** *** 901,906 **** "" "@ ! DSLC R%0,%2 ! DSCR R%0,R%2 ") (define_insn "rotrqi3" --- 919,924 ---- "" "@ ! dslc r%0,%2 ! dscr r%0,r%2 ") (define_insn "rotrqi3" *************** *** 910,915 **** "" "@ ! SLC R%0,%2 ! NEG R%2,R%2\;SCR R%0,R%2 ") (define_insn "rotrhi3" --- 928,933 ---- "" "@ ! slc r%0,%2 ! neg r%2,r%2\;scr r%0,r%2 ") (define_insn "rotrhi3" *************** *** 919,924 **** "" "@ ! DSLC R%0,%2 ! NEG R%2,R%2\;DSCR R%0,R%2 ") --- 937,942 ---- "" "@ ! dslc r%0,%2 ! neg r%2,r%2\;dscr r%0,r%2 ") *************** *** 965,969 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"EZ\",CODE_LABEL_NUMBER(operands[0])); ") --- 983,987 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"ez\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 975,979 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"NZ\",CODE_LABEL_NUMBER(operands[0])); ") --- 993,997 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"nz\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 985,989 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"GT\",CODE_LABEL_NUMBER(operands[0])); ") --- 1003,1007 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"gt\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 995,999 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"LT\",CODE_LABEL_NUMBER(operands[0])); ") --- 1013,1017 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"lt\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1005,1009 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"GE\",CODE_LABEL_NUMBER(operands[0])); ") --- 1023,1027 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"ge\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1015,1019 **** (pc)))] "" ! "* return (char *)branch_or_jump(\"LE\",CODE_LABEL_NUMBER(operands[0])); ") --- 1033,1037 ---- (pc)))] "" ! "* return (char *)branch_or_jump(\"le\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1028,1032 **** (pc)))] "" ! "JC GT,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bltu" --- 1046,1050 ---- (pc)))] "" ! "jc gt,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bltu" *************** *** 1037,1041 **** (pc)))] "" ! "JC LT,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bgeu" --- 1055,1059 ---- (pc)))] "" ! "jc lt,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bgeu" *************** *** 1046,1050 **** (pc)))] "" ! "JC GE,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bleu" --- 1064,1068 ---- (pc)))] "" ! "jc ge,%l0 ; Warning: this should be an *unsigned* test!") (define_insn "bleu" *************** *** 1055,1059 **** (pc)))] "" ! "JC LE,%l0 ; Warning: this should be an *unsigned* test!") --- 1073,1077 ---- (pc)))] "" ! "jc le,%l0 ; Warning: this should be an *unsigned* test!") *************** *** 1067,1071 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"NZ\",CODE_LABEL_NUMBER(operands[0])); ") --- 1085,1089 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"nz\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1077,1081 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"EZ\",CODE_LABEL_NUMBER(operands[0])); ") --- 1095,1099 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"ez\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1087,1091 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"LE\",CODE_LABEL_NUMBER(operands[0])); ") --- 1105,1109 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"le\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1097,1101 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"GE\",CODE_LABEL_NUMBER(operands[0])); ") --- 1115,1119 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"ge\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1107,1111 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"LT\",CODE_LABEL_NUMBER(operands[0])); ") --- 1125,1129 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"lt\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1117,1121 **** (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"GT\",CODE_LABEL_NUMBER(operands[0])); ") --- 1135,1139 ---- (label_ref (match_operand 0 "" ""))))] "" ! "* return (char *)branch_or_jump(\"gt\",CODE_LABEL_NUMBER(operands[0])); ") *************** *** 1130,1134 **** (label_ref (match_operand 0 "" ""))))] "" ! "JC LE,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" --- 1148,1152 ---- (label_ref (match_operand 0 "" ""))))] "" ! "jc le,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" *************** *** 1139,1143 **** (label_ref (match_operand 0 "" ""))))] "" ! "JC GE,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" --- 1157,1161 ---- (label_ref (match_operand 0 "" ""))))] "" ! "jc ge,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" *************** *** 1148,1152 **** (label_ref (match_operand 0 "" ""))))] "" ! "JC LT,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" --- 1166,1170 ---- (label_ref (match_operand 0 "" ""))))] "" ! "jc lt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") (define_insn "" *************** *** 1157,1161 **** (label_ref (match_operand 0 "" ""))))] "" ! "JC GT,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") ;; Tablejump --- 1175,1179 ---- (label_ref (match_operand 0 "" ""))))] "" ! "jc gt,%l0 ;inv.cond. ;Warning: this should be an *unsigned* test!") ;; Tablejump *************** *** 1166,1170 **** (use (label_ref (match_operand 1 "" "")))] "" ! "JC 15,0,R%0 ; tablejump label_ref=%1") --- 1184,1188 ---- (use (label_ref (match_operand 1 "" "")))] "" ! "jc 15,0,r%0 ; tablejump label_ref=%1") *************** *** 1174,1178 **** (label_ref (match_operand 0 "" "")))] "" ! "JC UC,%0") ;; Call subroutine, returning value in operand 0 --- 1192,1196 ---- (label_ref (match_operand 0 "" "")))] "" ! "jc uc,%0") ;; Call subroutine, returning value in operand 0 *************** *** 1184,1188 **** ;; Operand 2 not really used for 1750. "" ! "SJS R15,%1 ; return value in R0") ;; Call subroutine with no return value. --- 1202,1206 ---- ;; Operand 2 not really used for 1750. "" ! "sjs r15,%1 ; return value in R0") ;; Call subroutine with no return value. *************** *** 1193,1197 **** (match_operand:QI 1 "general_operand" ""))] "" ! "SJS R15,%0 ; no return value") ;;;;;;;;;;;; 1750: NOT READY YET. --- 1211,1215 ---- (match_operand:QI 1 "general_operand" ""))] "" ! "sjs r15,%0 ; no return value") ;;;;;;;;;;;; 1750: NOT READY YET. *************** *** 1209,1213 **** ; { ; rtx oprnd = gen_rtx(CONST_INT,VOIDmode,get_frame_size()); ! ; output_asm_insn(\"RET.M %0\",&oprnd); ; return \"\;\"; ; } ") --- 1227,1231 ---- ; { ; rtx oprnd = gen_rtx(CONST_INT,VOIDmode,get_frame_size()); ! ; output_asm_insn(\"ret.m %0\",&oprnd); ; return \"\;\"; ; } ") *************** *** 1216,1220 **** [(set (pc) (match_operand:QI 0 "address_operand" "p"))] "" ! "JCI 15,%0") (define_insn "nop" --- 1234,1238 ---- [(set (pc) (match_operand:QI 0 "address_operand" "p"))] "" ! "jci 15,%0") (define_insn "nop" *************** *** 1236,1240 **** ] "INTVAL(operands[2]) == -1" ! "SOJ R%0,%3") ;;;End. --- 1254,1258 ---- ] "INTVAL(operands[2]) == -1" ! "soj r%0,%3") ;;;End. Only in gcc-2.6.0/config/1750a: m1750.inc diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/1750a/ms1750.inc gcc-2.6.1/config/1750a/ms1750.inc *** gcc-2.6.0/config/1750a/ms1750.inc --- gcc-2.6.1/config/1750a/ms1750.inc Tue Sep 20 19:26:51 1994 *************** *** 0 **** --- 1,73 ---- + ;; GCC assembler includefile for AS1750 + ;; + ;; Macros defined: + ;; EFLR.M #d,#s Load the three regs starting at R#s to R#d following. + ;; RET.M #fs Return from function (uses the framesize #fs) + + + UC SET 15 + + ; Return from function ; parameter: framesize + MACRO RET.M + IF `1` > 0 + IF `1` <= 16 + AISP R14,`1` + ELSE + AIM R14,`1` + ENDIF + ENDIF + LR R15,R14 + URS R15 + ENDMACRO + + ; Useful instructions missing from the 1750A standard: + + ; Extended Float Load from Registers + MACRO EFLR.M ; args : #1=dest-regno, #2=source-regno + ONE SET `1` + 2 + TWO SET `2` + 2 + IF `1` >= `2` || `1`+2 < `2` + LR R`ONE`,R`TWO` + DLR R`1`,R`2` + ELSE + DLR R`1`,R`2` + LR R`ONE`,R`TWO` + DLR R`1`,R`1` ; Just to update condition codes + ENDIF + ENDMACRO + + ; The following leave the condition codes haywire. But that is + ; accounted for (see notice_update_cc in config/1750a.c.) + + ; Double ANd Register with Register + MACRO DANR.M + ONE SET `1` + 1 + TWO SET `2` + 1 + ANDR R`1`,R`2` + ANDR R`ONE`,R`TWO` + ENDMACRO + + ; Double OR Register with Register + MACRO DORR.M + ONE SET `1` + 1 + TWO SET `2` + 1 + ORR R`1`,R`2` + ORR R`ONE`,R`TWO` + ENDMACRO + + ; Double eXoR Register with Register + MACRO DXRR.M + ONE SET `1` + 1 + TWO SET `2` + 1 + XORR R`1`,R`2` + XORR R`ONE`,R`TWO` + ENDMACRO + + ; Double Nand Register with register + MACRO DNR.M + ONE SET `1` + 1 + TWO SET `2` + 1 + NR R`1`,R`2` + NR R`ONE`,R`TWO` + ENDMACRO + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/alpha.c gcc-2.6.1/config/alpha/alpha.c *** gcc-2.6.0/config/alpha/alpha.c Thu Jul 7 17:34:28 1994 --- gcc-2.6.1/config/alpha/alpha.c Wed Sep 21 15:55:24 1994 *************** *** 228,238 **** #endif ! if (GET_CODE (op) == CONST_INT) ! return (INTVAL (op) == 0xff ! || INTVAL (op) == 0xffff #if HOST_BITS_PER_WIDE_INT == 64 ! || INTVAL (op) == 0xffffffff #endif ! ); } --- 228,238 ---- #endif ! return (GET_CODE (op) == CONST_INT ! && (INTVAL (op) == 0xff ! || INTVAL (op) == 0xffff #if HOST_BITS_PER_WIDE_INT == 64 ! || INTVAL (op) == 0xffffffff #endif ! )); } *************** *** 334,337 **** --- 334,351 ---- } + /* Return 1 if OP is a valid operand for the MEM of a CALL insn. */ + + int + call_operand (op, mode) + rtx op; + enum machine_mode mode; + { + if (mode != Pmode) + return 0; + + return (GET_CODE (op) == SYMBOL_REF + || (GET_CODE (op) == REG && REGNO (op) == 27)); + } + /* Return 1 if OP is a valid Alpha comparison operator. Here we know which comparisons are valid in which insn. */ *************** *** 1522,1528 **** fprintf (file, "\n"); inside_function = FALSE; - - /* Show that we know this function if it is called again. */ - SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1; } --- 1536,1539 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/alpha.h gcc-2.6.1/config/alpha/alpha.h *** gcc-2.6.0/config/alpha/alpha.h Sat Jul 2 19:03:18 1994 --- gcc-2.6.1/config/alpha/alpha.h Wed Oct 26 18:25:58 1994 *************** *** 45,59 **** #define ASM_SPEC "-nocpp" ! /* Right now Alpha OSF/1 doesn't seem to have debugging libraries. */ ! #define LIB_SPEC "%{p:-lprof1} %{pg:-lprof2} -lc" ! /* Pass "-G 8" to ld because Alpha's CC does. Pass -O3 if we are optimizing, ! -O1 if we are not. Pass -non_shared or -call_shared as appropriate. */ #define LINK_SPEC \ ! "-G 8 %{O*:-O3} %{!O*:-O1} %{static:-non_shared} %{!static:-call_shared}" #define STARTFILE_SPEC \ ! "%{pg:mcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}" /* Print subsidiary information on the compiler version in use. */ --- 45,61 ---- #define ASM_SPEC "-nocpp" ! /* Under OSF/1, -p and -pg require -lprof1. */ ! #define LIB_SPEC "%{p:-lprof1} %{pg:-lprof1} %{a:-lprof2} -lc" ! /* Pass "-G 8" to ld because Alpha's CC does. Pass -O3 if we are ! optimizing, -O1 if we are not. Pass -shared, -non_shared or ! -call_shared as appropriate. Also pass -pg. */ #define LINK_SPEC \ ! "-G 8 %{O*:-O3} %{!O*:-O1} %{!shared:-init __main} %{static:-non_shared} \ ! %{!static:%{shared:-shared} %{!shared:-call_shared}} %{pg}" #define STARTFILE_SPEC \ ! "%{!shared:%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}" /* Print subsidiary information on the compiler version in use. */ *************** *** 511,518 **** For the Alpha, `Q' means that this is a memory operand but not a ! reference to an unaligned location. */ #define EXTRA_CONSTRAINT(OP, C) \ ((C) == 'Q' ? GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) != AND \ : 0) --- 513,523 ---- For the Alpha, `Q' means that this is a memory operand but not a ! reference to an unaligned location. ! `R' is a SYMBOL_REF that has SYMBOL_REF_FLAG set or is the current ! function. */ #define EXTRA_CONSTRAINT(OP, C) \ ((C) == 'Q' ? GET_CODE (OP) == MEM && GET_CODE (XEXP (OP, 0)) != AND \ + : (C) == 'R' ? current_file_function_operand (OP, Pmode) \ : 0) *************** *** 585,588 **** --- 590,598 ---- ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) + /* If defined, gives a class of registers that cannot be used as the + operand of a SUBREG that changes the size of the object. */ + + #define CLASS_CANNOT_CHANGE_SIZE FLOAT_REGS + /* Define the cost of moving between registers of various classes. Moving between FLOAT_REGS and anything else except float regs is expensive. *************** *** 681,685 **** (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size) \ + alpha_sa_size () \ ! + ALPHA_ROUND (get_frame_size ())); \ } --- 691,697 ---- (OFFSET) = (ALPHA_ROUND (current_function_outgoing_args_size) \ + alpha_sa_size () \ ! + (ALPHA_ROUND (get_frame_size () \ ! + current_function_pretend_args_size) \ ! - current_function_pretend_args_size)); \ } *************** *** 912,918 **** #define FUNCTION_PROFILER(FILE, LABELNO) \ do { \ ! fputs ("\tlda $27,_mcount\n", (FILE)); \ ! fputs ("\tjsr $27,($27),_mcount\n", (FILE)); \ ! fputs ("\tldgp $29,0($26)\n", (FILE)); \ } while (0); --- 924,930 ---- #define FUNCTION_PROFILER(FILE, LABELNO) \ do { \ ! fputs ("\tlda $28,_mcount\n", (FILE)); \ ! fputs ("\tjsr $28,($28),_mcount\n", (FILE)); \ ! fputs ("\tldgp $29,0($27)\n", (FILE)); \ } while (0); *************** *** 942,953 **** int blockn = (BLOCKNO); \ fputs ("\tsubq $30,16,$30\n", (FILE)); \ ! fputs ("\tstq $0,0($30)\n", (FILE)); \ ! fputs ("\tstq $1,8($30)\n", (FILE)); \ ! fputs ("\tlda $0,$PBX34\n", (FILE)); \ ! fprintf ((FILE), "\tldq $1,%d($0)\n", 8*blockn); \ ! fputs ("\taddq $1,1,$1\n", (FILE)); \ ! fprintf ((FILE), "\tstq $1,%d($0)\n", 8*blockn); \ ! fputs ("\tldq $0,0($30)\n", (FILE)); \ ! fputs ("\tldq $1,8($30)\n", (FILE)); \ fputs ("\taddq $30,16,$30\n", (FILE)); \ } while (0) --- 954,965 ---- int blockn = (BLOCKNO); \ fputs ("\tsubq $30,16,$30\n", (FILE)); \ ! fputs ("\tstq $26,0($30)\n", (FILE)); \ ! fputs ("\tstq $27,8($30)\n", (FILE)); \ ! fputs ("\tlda $26,$PBX34\n", (FILE)); \ ! fprintf ((FILE), "\tldq $27,%d($26)\n", 8*blockn); \ ! fputs ("\taddq $27,1,$27\n", (FILE)); \ ! fprintf ((FILE), "\tstq $27,%d($26)\n", 8*blockn); \ ! fputs ("\tldq $26,0($30)\n", (FILE)); \ ! fputs ("\tldq $27,8($30)\n", (FILE)); \ fputs ("\taddq $30,16,$30\n", (FILE)); \ } while (0) *************** *** 1277,1282 **** /* Define this if the tablejump instruction expects the table to contain offsets from the address of the table. ! Do not define this if the table should contain absolute addresses. */ ! /* #define CASE_VECTOR_PC_RELATIVE */ /* Specify the tree operation to be used to convert reals to integers. */ --- 1289,1297 ---- /* Define this if the tablejump instruction expects the table to contain offsets from the address of the table. ! Do not define this if the table should contain absolute addresses. ! On the Alpha, the table is really GP-relative, not relative to the PC ! of the table, but we pretend that it is PC-relative; this should be OK, ! but we hsould try to find some better way sometime. */ ! #define CASE_VECTOR_PC_RELATIVE /* Specify the tree operation to be used to convert reals to integers. */ *************** *** 1463,1466 **** --- 1478,1482 ---- alpha_write_verstamp (FILE); \ fprintf (FILE, "\t.set noreorder\n"); \ + fprintf (FILE, "\t.set volatile\n"); \ fprintf (FILE, "\t.set noat\n"); \ ASM_OUTPUT_SOURCE_FILENAME (FILE, main_input_filename); \ *************** *** 1505,1516 **** #define READONLY_DATA_SECTION literal_section ! /* If we are referencing a function that is static or is known to be ! in this file, make the SYMBOL_REF special. We can use this to see ! indicate that we can branch to this function without setting PV or ! restoring GP. */ #define ENCODE_SECTION_INFO(DECL) \ ! if (TREE_CODE (DECL) == FUNCTION_DECL \ ! && (TREE_ASM_WRITTEN (DECL) || ! TREE_PUBLIC (DECL))) \ SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1; --- 1521,1530 ---- #define READONLY_DATA_SECTION literal_section ! /* If we are referencing a function that is static, make the SYMBOL_REF ! special. We use this to see indicate we can branch to this function ! without setting PV or restoring GP. */ #define ENCODE_SECTION_INFO(DECL) \ ! if (TREE_CODE (DECL) == FUNCTION_DECL && ! TREE_PUBLIC (DECL)) \ SYMBOL_REF_FLAG (XEXP (DECL_RTL (DECL), 0)) = 1; *************** *** 1710,1722 **** fprintf (FILE, "\t.byte 0x%x\n", (VALUE) & 0xff) ! /* This is how to output an element of a case-vector that is absolute. */ ! #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ ! fprintf (FILE, "\t.gprel32 $%d\n", (VALUE) + 32) ! /* This is how to output an element of a case-vector that is relative. ! (Alpha does not use such vectors, but we must define this macro anyway.) */ ! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) abort () /* This is how to output an assembler line --- 1724,1736 ---- fprintf (FILE, "\t.byte 0x%x\n", (VALUE) & 0xff) ! /* This is how to output an element of a case-vector that is absolute. ! (Alpha does not use such vectors, but we must define this macro anyway.) */ ! #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) abort () ! /* This is how to output an element of a case-vector that is relative. */ ! #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ ! fprintf (FILE, "\t.gprel32 $%d\n", (VALUE) + 32) /* This is how to output an assembler line *************** *** 1828,1831 **** --- 1842,1846 ---- {"fp0_operand", {CONST_DOUBLE}}, \ {"current_file_function_operand", {SYMBOL_REF}}, \ + {"call_operand", {REG, SYMBOL_REF}}, \ {"input_operand", {SUBREG, REG, MEM, CONST_INT, CONST_DOUBLE, \ SYMBOL_REF, CONST, LABEL_REF}}, \ *************** *** 2002,2003 **** --- 2017,2026 ---- #define ALIGN_SYMTABLE_OFFSET(OFFSET) (((OFFSET) + 7) & ~7) + + /* The system headers under OSF/1 are C++-aware. */ + #define NO_IMPLICIT_EXTERN_C + + /* The linker will stick __main into the .init section. */ + #define HAS_INIT_SECTION + #define INIT_NAME_FORMAT "__init_%s" + #define FINI_NAME_FORMAT "__fini_%s" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/alpha.md gcc-2.6.1/config/alpha/alpha.md *** gcc-2.6.0/config/alpha/alpha.md Tue Jul 12 12:18:59 1994 --- gcc-2.6.1/config/alpha/alpha.md Fri Oct 28 17:10:07 1994 *************** *** 2399,2403 **** operands[5] = GEN_INT (~ INTVAL (operands[3])); operands[6] = gen_rtx (((GET_CODE (operands[1]) == GTU ! || GET_CODE (operands[1]) == GE) ? NE : EQ), DImode, operands[4], const0_rtx); --- 2399,2403 ---- operands[5] = GEN_INT (~ INTVAL (operands[3])); operands[6] = gen_rtx (((GET_CODE (operands[1]) == GTU ! || GET_CODE (operands[1]) == GT) ? NE : EQ), DImode, operands[4], const0_rtx); *************** *** 2407,2413 **** (define_expand "call" ! [(parallel [(call (mem:DI (match_dup 2)) (match_operand 1 "" "")) ! (use (match_operand:DI 0 "" "")) (clobber (reg:DI 26))])] "" --- 2407,2413 ---- (define_expand "call" ! [(parallel [(call (mem:DI (match_operand 0 "" "")) (match_operand 1 "" "")) ! (clobber (reg:DI 27)) (clobber (reg:DI 26))])] "" *************** *** 2415,2425 **** { if (GET_CODE (operands[0]) != MEM) abort (); - operands[0] = XEXP (operands[0], 0); ! operands[2] = gen_rtx (REG, DImode, 27); ! emit_move_insn (operands[2], operands[0]); ! if (GET_CODE (operands[0]) != SYMBOL_REF) ! operands[0] = const0_rtx; }") --- 2415,2428 ---- { if (GET_CODE (operands[0]) != MEM) abort (); ! operands[0] = XEXP (operands[0], 0); ! if (GET_CODE (operands[0]) != SYMBOL_REF ! && ! (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == 27)) ! { ! rtx tem = gen_rtx (REG, DImode, 27); ! emit_move_insn (tem, operands[0]); ! operands[0] = tem; ! } }") *************** *** 2426,2432 **** (define_expand "call_value" [(parallel [(set (match_operand 0 "" "") ! (call (mem:DI (match_dup 3)) (match_operand 2 "" ""))) ! (use (match_operand:DI 1 "" "")) (clobber (reg:DI 26))])] "" --- 2429,2435 ---- (define_expand "call_value" [(parallel [(set (match_operand 0 "" "") ! (call (mem:DI (match_operand 1 "" "")) (match_operand 2 "" ""))) ! (clobber (reg:DI 27)) (clobber (reg:DI 26))])] "" *************** *** 2437,2484 **** operands[1] = XEXP (operands[1], 0); ! operands[3] = gen_rtx (REG, DImode, 27); ! emit_move_insn (operands[3], operands[1]); ! ! if (GET_CODE (operands[1]) != SYMBOL_REF) ! operands[1] = const0_rtx; }") (define_insn "" ! [(call (mem:DI (reg:DI 27)) ! (match_operand 0 "" "")) ! (use (match_operand:DI 1 "" "")) ! (clobber (reg:DI 26))] ! "" ! "jsr $26,($27),%1\;ldgp $29,0($26)" ! [(set_attr "type" "jsr")]) ! ! (define_insn "" ! [(set (match_operand 0 "register_operand" "=rf") ! (call (mem:DI (reg:DI 27)) ! (match_operand 1 "" ""))) ! (use (match_operand:DI 2 "" "")) ! (clobber (reg:DI 26))] ! "" ! "jsr $26,($27),%2\;ldgp $29,0($26)" ! [(set_attr "type" "jsr")]) ! ! (define_insn "" ! [(call (mem:DI (match_operand 1 "current_file_function_operand" "i")) ! (match_operand 0 "" "")) ! (use (match_dup 1)) (clobber (reg:DI 26))] "" ! "bsr $26,%1..ng" ! [(set_attr "type" "ibr")]) (define_insn "" ! [(set (match_operand 0 "register_operand" "=rf") ! (call (mem:DI (match_operand 1 "current_file_function_operand" "i")) (match_operand 2 "" ""))) ! (use (match_dup 1)) (clobber (reg:DI 26))] "" ! "bsr $26,%1..ng" ! [(set_attr "type" "ibr")]) ;; Call subroutine returning any type. --- 2440,2476 ---- operands[1] = XEXP (operands[1], 0); ! if (GET_CODE (operands[1]) != SYMBOL_REF ! && ! (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == 27)) ! { ! rtx tem = gen_rtx (REG, DImode, 27); ! emit_move_insn (tem, operands[1]); ! operands[1] = tem; ! } }") (define_insn "" ! [(call (mem:DI (match_operand:DI 0 "call_operand" "r,R,i")) ! (match_operand 1 "" "")) ! (clobber (reg:DI 27)) (clobber (reg:DI 26))] "" ! "@ ! jsr $26,($27),0\;ldgp $29,0($26) ! bsr $26,%0..ng ! jsr $26,%0\;ldgp $29,0($26)" ! [(set_attr "type" "jsr,jsr,ibr")]) (define_insn "" ! [(set (match_operand 0 "register_operand" "=rf,rf,rf") ! (call (mem:DI (match_operand:DI 1 "call_operand" "r,R,i")) (match_operand 2 "" ""))) ! (clobber (reg:DI 27)) (clobber (reg:DI 26))] "" ! "@ ! jsr $26,($27),0\;ldgp $29,0($26) ! bsr $26,%1..ng ! jsr $26,%1\;ldgp $29,0($26)" ! [(set_attr "type" "jsr,jsr,ibr")]) ;; Call subroutine returning any type. *************** *** 2547,2552 **** [(set (match_dup 3) (sign_extend:DI (match_operand:SI 0 "register_operand" ""))) ! (parallel [(set (pc) (plus:DI (match_dup 3) (reg:DI 29))) ! (use (label_ref (match_operand 1 "" ""))) (clobber (match_scratch:DI 2 "=r"))])] "" --- 2539,2545 ---- [(set (match_dup 3) (sign_extend:DI (match_operand:SI 0 "register_operand" ""))) ! (parallel [(set (pc) ! (plus:DI (match_dup 3) ! (label_ref:DI (match_operand 1 "" "")))) (clobber (match_scratch:DI 2 "=r"))])] "" *************** *** 2557,2564 **** [(set (pc) (plus:DI (match_operand:DI 0 "register_operand" "r") ! (reg:DI 29))) ! (use (label_ref (match_operand 1 "" ""))) (clobber (match_scratch:DI 2 "=r"))] ! "" "* { rtx best_label = 0; --- 2550,2558 ---- [(set (pc) (plus:DI (match_operand:DI 0 "register_operand" "r") ! (label_ref:DI (match_operand 1 "" "")))) (clobber (match_scratch:DI 2 "=r"))] ! "next_active_insn (insn) != 0 ! && GET_CODE (PATTERN (next_active_insn (insn))) == ADDR_DIFF_VEC ! && PREV_INSN (next_active_insn (insn)) == operands[1]" "* { rtx best_label = 0; *************** *** 2566,2573 **** if (GET_CODE (jump_table_insn) == JUMP_INSN ! && GET_CODE (PATTERN (jump_table_insn)) == ADDR_VEC) { rtx jump_table = PATTERN (jump_table_insn); ! int n_labels = XVECLEN (jump_table, 0); int best_count = -1; int i, j; --- 2560,2567 ---- if (GET_CODE (jump_table_insn) == JUMP_INSN ! && GET_CODE (PATTERN (jump_table_insn)) == ADDR_DIFF_VEC) { rtx jump_table = PATTERN (jump_table_insn); ! int n_labels = XVECLEN (jump_table, 1); int best_count = -1; int i, j; *************** *** 2578,2587 **** for (j = i + 1; j < n_labels; j++) ! if (XEXP (XVECEXP (jump_table, 0, i), 0) ! == XEXP (XVECEXP (jump_table, 0, j), 0)) count++; if (count > best_count) ! best_count = count, best_label = XVECEXP (jump_table, 0, i); } } --- 2572,2581 ---- for (j = i + 1; j < n_labels; j++) ! if (XEXP (XVECEXP (jump_table, 1, i), 0) ! == XEXP (XVECEXP (jump_table, 1, j), 0)) count++; if (count > best_count) ! best_count = count, best_label = XVECEXP (jump_table, 1, i); } } *************** *** 3254,3257 **** --- 3248,3252 ---- rtx scratch1 = gen_rtx (REG, DImode, REGNO (operands[2])); rtx scratch2 = gen_rtx (REG, DImode, REGNO (operands[2]) + 1); + rtx scratch3 = scratch1; rtx seq; *************** *** 3260,3264 **** seq = gen_unaligned_storeqi (addr, operands[1], scratch1, ! scratch2, scratch1); alpha_set_memflags (seq, operands[0]); emit_insn (seq); --- 3255,3259 ---- seq = gen_unaligned_storeqi (addr, operands[1], scratch1, ! scratch2, scratch3); alpha_set_memflags (seq, operands[0]); emit_insn (seq); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/gdb-osf12.h gcc-2.6.1/config/alpha/gdb-osf12.h *** gcc-2.6.0/config/alpha/gdb-osf12.h Mon Jan 31 18:06:38 1994 --- gcc-2.6.1/config/alpha/gdb-osf12.h Thu Oct 20 17:51:36 1994 *************** *** 20,32 **** the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! #include "alpha/alpha.h" #undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG - - /* In OSF 1.2, there is a linker bug that prevents use of -O3 to - the linker. */ - - #undef LINK_SPEC - #define LINK_SPEC \ - "-G 8 -O1 %{static:-non_shared} %{!static:-call_shared}" --- 20,25 ---- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! #include "alpha/osf12.h" #undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/osf12.h gcc-2.6.1/config/alpha/osf12.h *** gcc-2.6.0/config/alpha/osf12.h Wed Nov 10 18:03:27 1993 --- gcc-2.6.1/config/alpha/osf12.h Thu Oct 20 17:51:36 1994 *************** *** 27,29 **** #undef LINK_SPEC #define LINK_SPEC \ ! "-G 8 -O1 %{static:-non_shared} %{!static:-call_shared}" --- 27,30 ---- #undef LINK_SPEC #define LINK_SPEC \ ! "-G 8 -O1 %{!shared:-init __main} %{static:-non_shared} ! %{!static:%{shared:-shared} %{!shared:-call_shared}}" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/alpha/osf2.h gcc-2.6.1/config/alpha/osf2.h *** gcc-2.6.0/config/alpha/osf2.h Wed Feb 9 10:26:26 1994 --- gcc-2.6.1/config/alpha/osf2.h Fri Sep 9 20:33:31 1994 *************** *** 1,5 **** /* Definitions of target machine for GNU compiler, for DEC Alpha. ! Copyright (C) 1992, 1993 Free Software Foundation, Inc. ! Contributed by Richard Kenner (kenner@nyu.edu) This file is part of GNU CC. --- 1,5 ---- /* Definitions of target machine for GNU compiler, for DEC Alpha. ! Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. ! Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu) This file is part of GNU CC. *************** *** 22,33 **** #include "alpha/alpha.h" ! /* In OSF 1.2, there is a linker bug that prevents use of -O3 to ! the linker. ! In OSF 2.0, the size of wchar_t was changed from short unsigned to unsigned int. */ - - #undef LINK_SPEC - #define LINK_SPEC \ - "-G 8 -O1 %{static:-non_shared} %{!static:-call_shared}" #undef WCHAR_TYPE --- 22,27 ---- #include "alpha/alpha.h" ! /* In OSF 2.0, the size of wchar_t was changed from short unsigned to unsigned int. */ #undef WCHAR_TYPE diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/arm.c gcc-2.6.1/config/arm/arm.c *** gcc-2.6.0/config/arm/arm.c Tue Jul 12 09:30:18 1994 --- gcc-2.6.1/config/arm/arm.c Sun Oct 2 11:10:08 1994 *************** *** 1473,1478 **** int multi_register_push (op, mode) ! rtx op; ! enum machine_mode mode; { if (GET_CODE (op) != PARALLEL --- 1473,1478 ---- int multi_register_push (op, mode) ! rtx op; ! enum machine_mode mode; { if (GET_CODE (op) != PARALLEL *************** *** 1712,1715 **** --- 1712,1744 ---- return cc_reg; + } + + void + arm_reload_in_hi (operands) + rtx *operands; + { + rtx base = find_replacement (&XEXP (operands[1], 0)); + + emit_insn (gen_zero_extendqisi2 (operands[2], gen_rtx (MEM, QImode, base))); + emit_insn (gen_zero_extendqisi2 (gen_rtx (SUBREG, SImode, operands[0], 0), + gen_rtx (MEM, QImode, + plus_constant (base, 1)))); + if (BYTES_BIG_ENDIAN) + emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (SUBREG, SImode, + operands[0], 0), + gen_rtx (IOR, SImode, + gen_rtx (ASHIFT, SImode, + gen_rtx (SUBREG, SImode, + operands[0], 0), + GEN_INT (8)), + operands[2]))); + else + emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (SUBREG, SImode, + operands[0], 0), + gen_rtx (IOR, SImode, + gen_rtx (ASHIFT, SImode, + operands[2], + GEN_INT (8)), + gen_rtx (SUBREG, SImode, operands[0], 0)))); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/arm.h gcc-2.6.1/config/arm/arm.h *** gcc-2.6.0/config/arm/arm.h Tue Jul 12 21:03:46 1994 --- gcc-2.6.1/config/arm/arm.h Sun Oct 2 11:10:16 1994 *************** *** 87,90 **** --- 87,96 ---- #define TARGET_6 (target_flags & 8) + /* Leave some bits for new processor variants */ + + /* Nonzero if shorts must be loaded byte at a time. This is not necessary + for the arm processor chip, but it is needed for some MMU chips. */ + #define TARGET_SHORT_BY_BYTES (target_flags & 0x200) + /* ARM_EXTRA_TARGET_SWITCHES is used in riscix.h to define some options which are passed to the preprocessor and the assembler post-processor. They *************** *** 97,110 **** #endif ! #define TARGET_SWITCHES \ ! { \ ! {"apcs", 1}, \ ! {"poke-function-name", 2}, \ ! {"fpe", 4}, \ ! {"6", 8}, \ ! {"2", -8}, \ ! {"3", -8}, \ ! ARM_EXTRA_TARGET_SWITCHES \ ! {"", TARGET_DEFAULT } \ } --- 103,120 ---- #endif ! #define TARGET_SWITCHES \ ! { \ ! {"apcs", 1}, \ ! {"poke-function-name", 2}, \ ! {"fpe", 4}, \ ! {"6", 8}, \ ! {"2", -8}, \ ! {"3", -8}, \ ! {"short-load-bytes", (0x200)}, \ ! {"no-short-load-bytes", -(0x200)}, \ ! {"short-load-words", -(0x200)}, \ ! {"no-short-load-words", (0x200)}, \ ! ARM_EXTRA_TARGET_SWITCHES \ ! {"", TARGET_DEFAULT } \ } *************** *** 139,143 **** --- 149,155 ---- extern enum floating_point_type arm_fpu; + #ifndef TARGET_DEFAULT #define TARGET_DEFAULT 0 + #endif #define TARGET_MEM_FUNCTIONS 1 *************** *** 173,184 **** #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \ ! if (GET_MODE_CLASS (MODE) == MODE_INT \ ! && GET_MODE_SIZE (MODE) < 4) \ ! { \ ! if (MODE == QImode) \ ! UNSIGNEDP = 1; \ ! else if (MODE == HImode) \ ! UNSIGNEDP = 0; \ ! (MODE) = SImode; \ } --- 185,196 ---- #define PROMOTE_MODE(MODE,UNSIGNEDP,TYPE) \ ! if (GET_MODE_CLASS (MODE) == MODE_INT \ ! && GET_MODE_SIZE (MODE) < 4) \ ! { \ ! if (MODE == QImode) \ ! UNSIGNEDP = 1; \ ! else if (MODE == HImode) \ ! UNSIGNEDP = TARGET_SHORT_BY_BYTES != 0; \ ! (MODE) = SImode; \ } *************** *** 547,550 **** --- 559,567 ---- && true_regnum (X) == -1) ? GENERAL_REGS \ : ((MODE) == HImode && true_regnum (X) == -1) ? GENERAL_REGS : NO_REGS) + + /* If we need to load shorts byte-at-a-time, then we need a scratch. */ + #define SECONDARY_INPUT_RELOAD_CLASS(CLASS,MODE,X) \ + (((MODE) == HImode && TARGET_SHORT_BY_BYTES && true_regnum (X) == -1) \ + ? GENERAL_REGS : NO_REGS) /* Return the maximum number of consecutive registers diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/arm.md gcc-2.6.1/config/arm/arm.md *** gcc-2.6.0/config/arm/arm.md Tue Jul 12 21:04:35 1994 --- gcc-2.6.1/config/arm/arm.md Mon Oct 24 06:12:43 1994 *************** *** 1770,1774 **** (define_expand "zero_extendhisi2" ! [(set (match_dup 2) (ashift:SI (match_operand:HI 1 "s_register_operand" "") (const_int 16))) (set (match_operand:SI 0 "s_register_operand" "") --- 1770,1774 ---- (define_expand "zero_extendhisi2" ! [(set (match_dup 2) (ashift:SI (match_operand:HI 1 "nonimmediate_operand" "") (const_int 16))) (set (match_operand:SI 0 "s_register_operand" "") *************** *** 1776,1780 **** "" " ! { operands[1] = gen_lowpart (SImode, operands[1]); operands[2] = gen_reg_rtx (SImode); }") --- 1776,1788 ---- "" " ! { ! if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM) ! { ! emit_insn (gen_movhi_bytes (operands[0], operands[1])); ! DONE; ! } ! if (! s_register_operand (operands[1], HImode)) ! operands[1] = copy_to_mode_reg (HImode, operands[1]); ! operands[1] = gen_lowpart (SImode, operands[1]); operands[2] = gen_reg_rtx (SImode); }") *************** *** 1820,1824 **** (define_expand "extendhisi2" [(set (match_dup 2) ! (ashift:SI (match_operand:HI 1 "s_register_operand" "") (const_int 16))) (set (match_operand:SI 0 "s_register_operand" "") --- 1828,1832 ---- (define_expand "extendhisi2" [(set (match_dup 2) ! (ashift:SI (match_operand:HI 1 "nonimmediate_operand" "") (const_int 16))) (set (match_operand:SI 0 "s_register_operand" "") *************** *** 1827,1832 **** "" " ! { operands[1] = gen_lowpart (SImode, operands[1]); ! operands[2] = gen_reg_rtx (SImode); }") (define_expand "extendqihi2" --- 1835,1876 ---- "" " ! { ! if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM) ! { ! emit_insn (gen_extendhisi2_mem (operands[0], operands[1])); ! DONE; ! } ! if (! s_register_operand (operands[1], HImode)) ! operands[1] = copy_to_mode_reg (HImode, operands[1]); ! operands[1] = gen_lowpart (SImode, operands[1]); ! operands[2] = gen_reg_rtx (SImode); ! }") ! ! (define_expand "extendhisi2_mem" ! [(set (match_dup 2) (zero_extend:SI (mem:QI (match_operand:HI 1 "" "")))) ! (set (match_dup 3) ! (zero_extend:SI (mem:QI (plus:SI (match_dup 1) (const_int 1))))) ! (set (match_dup 6) (ashift:SI (match_dup 4) (const_int 24))) ! (set (match_operand:SI 0 "" "") ! (ior:SI (ashiftrt:SI (match_dup 6) (const_int 16)) (match_dup 5)))] ! "" ! " ! operands[0] = gen_lowpart (SImode, operands[0]); ! operands[1] = copy_to_mode_reg (SImode, XEXP (operands[1], 0)); ! operands[2] = gen_reg_rtx (SImode); ! operands[3] = gen_reg_rtx (SImode); ! operands[6] = gen_reg_rtx (SImode); ! ! if (BYTES_BIG_ENDIAN) ! { ! operands[4] = operands[2]; ! operands[5] = operands[3]; ! } ! else ! { ! operands[4] = operands[3]; ! operands[5] = operands[2]; ! } ! ") (define_expand "extendqihi2" *************** *** 2203,2206 **** --- 2247,2256 ---- operands[1] = gen_rtx (SUBREG, HImode, reg, 0); } + else if (TARGET_SHORT_BY_BYTES && GET_CODE (operands[1]) == MEM) + { + rtx reg = gen_reg_rtx (SImode); + emit_insn (gen_movhi_bytes (reg, operands[1])); + operands[1] = gen_lowpart (HImode, reg); + } else if (BYTES_BIG_ENDIAN && GET_CODE (operands[1]) == MEM) { *************** *** 2212,2215 **** --- 2262,2290 ---- ") + (define_expand "movhi_bytes" + [(set (match_dup 2) (zero_extend:SI (mem:QI (match_operand:HI 1 "" "")))) + (set (match_dup 3) + (zero_extend:SI (mem:QI (plus:SI (match_dup 1) (const_int 1))))) + (set (match_operand:SI 0 "" "") + (ior:SI (ashift:SI (match_dup 4) (const_int 8)) (match_dup 5)))] + "" + " + operands[0] = gen_lowpart (SImode, operands[0]); + operands[1] = copy_to_mode_reg (SImode, XEXP (operands[1], 0)); + operands[2] = gen_reg_rtx (SImode); + operands[3] = gen_reg_rtx (SImode); + + if (BYTES_BIG_ENDIAN) + { + operands[4] = operands[2]; + operands[5] = operands[3]; + } + else + { + operands[4] = operands[3]; + operands[5] = operands[2]; + } + ") + (define_expand "movhi_bigend" [(set (match_dup 2) *************** *** 2231,2235 **** [(set (match_operand:HI 0 "general_operand" "=r,r,r") (match_operand:HI 1 "general_operand" "rI,K,m"))] ! "(! BYTES_BIG_ENDIAN) && (GET_CODE (operands[1]) != CONST_INT || const_ok_for_arm (INTVAL (operands[1])) --- 2306,2311 ---- [(set (match_operand:HI 0 "general_operand" "=r,r,r") (match_operand:HI 1 "general_operand" "rI,K,m"))] ! "! BYTES_BIG_ENDIAN ! && ! TARGET_SHORT_BY_BYTES && (GET_CODE (operands[1]) != CONST_INT || const_ok_for_arm (INTVAL (operands[1])) *************** *** 2245,2248 **** --- 2321,2325 ---- (match_operand:HI 1 "general_operand" "rI,K,m"))] "BYTES_BIG_ENDIAN + && ! TARGET_SHORT_BY_BYTES && (GET_CODE (operands[1]) != CONST_INT || const_ok_for_arm (INTVAL (operands[1])) *************** *** 2259,2266 **** (rotate:SI (subreg:SI (match_operand:HI 1 "memory_operand" "m") 0) (const_int 16)))] ! "BYTES_BIG_ENDIAN" "ldr%?\\t%0, %1\\t%@ movhi_bigend" [(set_attr "type" "load")]) (define_expand "reload_outhi" [(parallel [(match_operand:HI 0 "reload_memory_operand" "=o") --- 2336,2353 ---- (rotate:SI (subreg:SI (match_operand:HI 1 "memory_operand" "m") 0) (const_int 16)))] ! "BYTES_BIG_ENDIAN ! && ! TARGET_SHORT_BY_BYTES" "ldr%?\\t%0, %1\\t%@ movhi_bigend" [(set_attr "type" "load")]) + (define_insn "" + [(set (match_operand:HI 0 "s_register_operand" "=r,r") + (match_operand:HI 1 "arm_rhs_operand" "rI,K"))] + "TARGET_SHORT_BY_BYTES" + "@ + mov%?\\t%0, %1\\t%@ movhi + mvn%?\\t%0, #%B1\\t%@ movhi") + + (define_expand "reload_outhi" [(parallel [(match_operand:HI 0 "reload_memory_operand" "=o") *************** *** 2273,2276 **** --- 2360,2373 ---- ") + (define_expand "reload_inhi" + [(parallel [(match_operand:HI 0 "s_register_operand" "=r") + (match_operand:HI 1 "reload_memory_operand" "o") + (match_operand:SI 2 "s_register_operand" "=&r")])] + "TARGET_SHORT_BY_BYTES" + " + arm_reload_in_hi (operands); + DONE; + ") + (define_expand "movqi" [(set (match_operand:QI 0 "general_operand" "") *************** *** 2320,2324 **** extern int optimize; rtx mem = force_const_mem (SFmode, operands[1]); ! rtx addr = gen_reg_rtx (SImode); if (optimize == 0) { --- 2417,2426 ---- extern int optimize; rtx mem = force_const_mem (SFmode, operands[1]); ! rtx addr; ! ! if (reload_in_progress || reload_completed) ! addr = gen_rtx (REG, SImode, REGNO (operands[0])); ! else ! addr = gen_reg_rtx (SImode); if (optimize == 0) { *************** *** 2365,2369 **** extern int optimize; rtx mem = force_const_mem (DFmode, operands[1]); ! rtx addr = gen_reg_rtx (SImode); if (optimize == 0) { --- 2467,2476 ---- extern int optimize; rtx mem = force_const_mem (DFmode, operands[1]); ! rtx addr; ! ! if (reload_in_progress || reload_completed) ! addr = gen_rtx (REG, SImode, REGNO (operands[0])); ! else ! addr = gen_reg_rtx (SImode); if (optimize == 0) { *************** *** 2387,2392 **** "" " ! emit_insn (gen_addsi3 (operands[2], XEXP (XEXP (operands[0], 0), 0), ! XEXP (XEXP (operands[0], 0), 1))); emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (MEM, DFmode, operands[2]), operands[1])); --- 2494,2502 ---- "" " ! if (GET_CODE (XEXP (operands[0], 0)) == REG) ! operands[2] = XEXP (operands[0], 0); ! else ! emit_insn (gen_addsi3 (operands[2], XEXP (XEXP (operands[0], 0), 0), ! XEXP (XEXP (operands[0], 0), 1))); emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (MEM, DFmode, operands[2]), operands[1])); *************** *** 4697,4700 **** --- 4807,4811 ---- (plus:SI (match_dup 1) (match_dup 2)))] "(! BYTES_BIG_ENDIAN) + && ! TARGET_SHORT_BY_BYTES && REGNO (operands[0]) != FRAME_POINTER_REGNUM && REGNO (operands[1]) != FRAME_POINTER_REGNUM *************** *** 4711,4714 **** --- 4822,4826 ---- (minus:SI (match_dup 1) (match_dup 2)))] "(!BYTES_BIG_ENDIAN) + && ! TARGET_SHORT_BY_BYTES && REGNO (operands[0]) != FRAME_POINTER_REGNUM && REGNO (operands[1]) != FRAME_POINTER_REGNUM *************** *** 4848,4851 **** --- 4960,4964 ---- (match_dup 1)))] "(! BYTES_BIG_ENDIAN) + && ! TARGET_SHORT_BY_BYTES && REGNO (operands[0]) != FRAME_POINTER_REGNUM && REGNO (operands[1]) != FRAME_POINTER_REGNUM *************** *** 4864,4867 **** --- 4977,4981 ---- (match_dup 4)])))] "(! BYTES_BIG_ENDIAN) + && ! TARGET_SHORT_BY_BYTES && REGNO (operands[0]) != FRAME_POINTER_REGNUM && REGNO (operands[1]) != FRAME_POINTER_REGNUM *************** *** 4910,4913 **** --- 5024,5028 ---- (plus:SI (match_dup 1) (match_operand:SI 2 "index_operand" "rJ")))] "(! BYTES_BIG_ENDIAN) + && ! TARGET_SHORT_BY_BYTES && REGNO(operands[0]) != REGNO(operands[1]) && (GET_CODE (operands[2]) != REG *************** *** 5188,5192 **** (set (pc) (label_ref (match_operand 2 "" "")))] ! "GET_CODE (operands[0]) == SYMBOL_REF && short_branch (INSN_UID (insn), INSN_UID (operands[2])) && arm_insn_not_targeted (insn)" --- 5303,5307 ---- (set (pc) (label_ref (match_operand 2 "" "")))] ! "0 && GET_CODE (operands[0]) == SYMBOL_REF && short_branch (INSN_UID (insn), INSN_UID (operands[2])) && arm_insn_not_targeted (insn)" *************** *** 5234,5238 **** (set (pc) (label_ref (match_operand 3 "" "")))] ! "GET_CODE (operands[0]) == SYMBOL_REF && short_branch (INSN_UID (insn), INSN_UID (operands[3])) && arm_insn_not_targeted (insn)" --- 5349,5353 ---- (set (pc) (label_ref (match_operand 3 "" "")))] ! "0 && GET_CODE (operands[0]) == SYMBOL_REF && short_branch (INSN_UID (insn), INSN_UID (operands[3])) && arm_insn_not_targeted (insn)" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/t-riscix gcc-2.6.1/config/arm/t-riscix *** gcc-2.6.0/config/arm/t-riscix --- gcc-2.6.1/config/arm/t-riscix Fri Oct 14 10:34:27 1994 *************** *** 0 **** --- 1,3 ---- + # Just for these, we omit the frame pointer since it makes such a big + # difference. It is then pointless adding debugging. + LIBGCC2_CFLAGS=-O2 -fomit-frame-pointer $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -g0 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/x-riscix gcc-2.6.1/config/arm/x-riscix *** gcc-2.6.0/config/arm/x-riscix --- gcc-2.6.1/config/arm/x-riscix Sun Oct 23 08:54:04 1994 *************** *** 0 **** --- 1,9 ---- + # Define new names for the getopt library, so that we don't have to statically + # link [un]protoize. We have dirent.h not sys/dir.h, so define POSIX. + X_CFLAGS= -DPOSIX -Dopterr=gcc_opterr -Doptind=gcc_optind \ + -Dgetopt=gcc_getopt -Doptarg=gcc_optarg + # Compile in BSD mode. + OLDCC=/usr/ucb/cc + CC=$(OLDCC) + FIXPROTO_DEFINES= -D_POSIX_SOURCE -D_XOPEN_C -D_BSD_C -D_XOPEN_SOURCE + INSTALL=$(srcdir)/install.sh -c diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/arm/xm-arm.h gcc-2.6.1/config/arm/xm-arm.h *** gcc-2.6.0/config/arm/xm-arm.h Tue Oct 19 17:34:54 1993 --- gcc-2.6.1/config/arm/xm-arm.h Fri Oct 14 10:33:49 1994 *************** *** 63,66 **** --- 63,72 ---- #define FATAL_EXIT_CODE 33 + /* If we have defined POSIX, but are compiling in the BSD environment, then + we need to define getcwd in terms of getwd. */ + #if defined (POSIX) && defined (_BSD_C) + #define HAVE_GETWD 1 + #endif + /* EOF xm-arm.h */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/clipper/clipper.h gcc-2.6.1/config/clipper/clipper.h *** gcc-2.6.0/config/clipper/clipper.h Fri May 27 17:44:33 1994 --- gcc-2.6.1/config/clipper/clipper.h Wed Aug 17 18:31:02 1994 *************** *** 467,473 **** #define CLIPPER_ARG_SIZE(MODE, TYPE) \ ! ((MODE) != BLKmode \ ! ? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \ ! : (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD) /* Update the data in CUM to advance over an argument --- 467,474 ---- #define CLIPPER_ARG_SIZE(MODE, TYPE) \ ! (((MODE) != BLKmode \ ! ? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \ ! : (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD) \ ! * UNITS_PER_WORD) /* Update the data in CUM to advance over an argument *************** *** 496,500 **** int align = FUNCTION_ARG_BOUNDARY (MODE, TYPE) / BITS_PER_UNIT; \ (CUM).size += align - 1; \ ! (CUM).size &= align - 1; \ (CUM).size += CLIPPER_ARG_SIZE (MODE, TYPE); \ } \ --- 497,501 ---- int align = FUNCTION_ARG_BOUNDARY (MODE, TYPE) / BITS_PER_UNIT; \ (CUM).size += align - 1; \ ! (CUM).size &= ~(align - 1); \ (CUM).size += CLIPPER_ARG_SIZE (MODE, TYPE); \ } \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/convex/convex.h gcc-2.6.1/config/convex/convex.h *** gcc-2.6.0/config/convex/convex.h Sun Apr 10 06:58:57 1994 --- gcc-2.6.1/config/convex/convex.h Sun Sep 4 08:38:27 1994 *************** *** 1,4 **** /* Definitions of target machine for GNU compiler. Convex version. ! Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Definitions of target machine for GNU compiler. Convex version. ! Copyright (C) 1988, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 1488,1493 **** print_operand_address (FILE, ADDR) - /* Definitions for g++. */ - /* Do not put out GNU stabs for constructors and destructors. ld bounces them. */ --- 1488,1491 ---- *************** *** 1495,1506 **** #define FASCIST_ASSEMBLER - /* Convex user addresses are negative, so use positive numbers - to mean `vtable index'. */ - - #define VTABLE_USES_MASK - #define VINDEX_MAX ((unsigned) 0x80000000) - #define SET_DECL_VINDEX(DECL, INDEX) \ - (DECL_VINDEX (DECL) = (INDEX)) - /* __gcc_cleanup is loader-aliased to __ap$do_registered_functions if we are linking against standard libc, 0 if old (-traditional) libc. */ --- 1493,1496 ---- *************** *** 1514,1523 **** } - /* cexp.y uses LONG_TYPE_SIZE which depends on target_flags, which it - doesn't have. Until some better way exists, provide a def here. */ - #ifdef YYBISON - int target_flags; - #endif - /* Header for convex.c. Here at the end so we can use types defined above. */ --- 1504,1507 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/convex/convex.md gcc-2.6.1/config/convex/convex.md *** gcc-2.6.0/config/convex/convex.md Sun Apr 10 07:06:02 1994 --- gcc-2.6.1/config/convex/convex.md Sun Sep 4 08:33:10 1994 *************** *** 1,4 **** ;;- Machine description for GNU compiler, Convex Version ! ;; Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc. ;; This file is part of GNU CC. --- 1,4 ---- ;;- Machine description for GNU compiler, Convex Version ! ;; Copyright (C) 1988, 1994 Free Software Foundation, Inc. ;; This file is part of GNU CC. *************** *** 1095,1098 **** --- 1095,1100 ---- [(set_attr "type" "shfl,shfw")]) + ;; but C2 left shift by a constant is faster via multiply + (define_insn "" [(set (match_operand:SI 0 "register_operand" "=r") *************** *** 1454,1459 **** (define_insn "" ! [(set (cc0) (match_operand:QI 0 "register_operand" "d,a")) ! (clobber (match_scratch:QI 1 "=d,a"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") --- 1456,1461 ---- (define_insn "" ! [(set (cc0) (match_operand:QI 0 "register_operand" "d")) ! (clobber (match_scratch:QI 1 "=d"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") *************** *** 1460,1465 **** (define_insn "" ! [(set (cc0) (subreg (match_operand:QI 0 "register_operand" "d,a") 0)) ! (clobber (match_scratch:QI 1 "=d,a"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") --- 1462,1467 ---- (define_insn "" ! [(set (cc0) (subreg (match_operand:QI 0 "register_operand" "d") 0)) ! (clobber (match_scratch:QI 1 "=d"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") *************** *** 1467,1472 **** (define_insn "" [(set (cc0) ! (zero_extend (subreg (match_operand:QI 0 "register_operand" "d,a") 0))) ! (clobber (match_scratch:QI 1 "=d,a"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") --- 1469,1474 ---- (define_insn "" [(set (cc0) ! (zero_extend (subreg (match_operand:QI 0 "register_operand" "d") 0))) ! (clobber (match_scratch:QI 1 "=d"))] "next_insn_tests_no_inequality (insn)" "* return output_cmp (operands[0], operands[1], 'B');") *************** *** 1554,1563 **** if (which_alternative == 0) { ! output_cmp (operands[0], constm1_rtx, 'W'); ! return \"add.w #-1,%0\"; } else { ! output_cmp (gen_rtx (REG, HImode, 7), constm1_rtx, 'W'); return \"psh.w s7\;ld.h %0,s7\;add.h #-1,s7\;st.h s7,%0\;pop.w s7\"; } --- 1556,1565 ---- if (which_alternative == 0) { ! output_cmp (operands[0], constm1_rtx, 'H'); ! return \"add.h #-1,%0\"; } else { ! output_cmp (gen_rtx (REG, HImode, 7), constm1_rtx, 'H'); return \"psh.w s7\;ld.h %0,s7\;add.h #-1,s7\;st.h s7,%0\;pop.w s7\"; } *************** *** 1576,1585 **** if (which_alternative == 0) { ! output_cmp (operands[0], const0_rtx, 'W'); ! return \"add.w #-1,%0\"; } else { ! output_cmp (gen_rtx (REG, HImode, 7), const0_rtx, 'W'); return \"psh.w s7\;ld.h %0,s7\;add.h #-1,s7\;st.h s7,%0\;pop.w s7\"; } --- 1578,1587 ---- if (which_alternative == 0) { ! output_cmp (operands[0], const0_rtx, 'H'); ! return \"add.h #-1,%0\"; } else { ! output_cmp (gen_rtx (REG, HImode, 7), const0_rtx, 'H'); return \"psh.w s7\;ld.h %0,s7\;add.h #-1,s7\;st.h s7,%0\;pop.w s7\"; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/dsp16xx/dsp16xx.c gcc-2.6.1/config/dsp16xx/dsp16xx.c *** gcc-2.6.0/config/dsp16xx/dsp16xx.c --- gcc-2.6.1/config/dsp16xx/dsp16xx.c Fri Sep 9 13:27:39 1994 *************** *** 0 **** --- 1,2226 ---- + /* Subroutines for assembler code output on the DSP1610. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Michael Collison (collison@world.std.com). + + 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. */ + + /* Some output-actions in dsp1600.md need these. */ + #include + #include "config.h" + #include "rtl.h" + #include "regs.h" + #include "hard-reg-set.h" + #include "real.h" + #include "insn-config.h" + #include "conditions.h" + #include "insn-flags.h" + #include "output.h" + #include "insn-attr.h" + #include "tree.h" + #include "expr.h" + #include "flags.h" + + char *text_seg_name; + char *rsect_text; + char *data_seg_name; + char *rsect_data; + char *bss_seg_name; + char *rsect_bss; + char *const_seg_name; + char *rsect_const; + + char *chip_name; + char *save_chip_name; + + /* Save the operands of a compare. The 16xx has not lt or gt, so + in these cases we swap the operands and reverse the condition */ + + rtx dsp16xx_compare_op0; + rtx dsp16xx_compare_op1; + struct rtx_def *(*dsp16xx_compare_gen)(); + + static char *fp; + static char *sp; + static char *rr; + static char *a1h; + + struct dsp16xx_frame_info current_frame_info; + struct dsp16xx_frame_info zero_frame_info; + + rtx dsp16xx_addhf3_libcall = (rtx) 0; + rtx dsp16xx_subhf3_libcall = (rtx) 0; + rtx dsp16xx_mulhf3_libcall = (rtx) 0; + rtx dsp16xx_divhf3_libcall = (rtx) 0; + rtx dsp16xx_cmphf3_libcall = (rtx) 0; + rtx dsp16xx_fixhfhi2_libcall = (rtx) 0; + rtx dsp16xx_floathihf2_libcall = (rtx) 0; + rtx dsp16xx_neghf2_libcall = (rtx) 0; + + rtx dsp16xx_mulhi3_libcall = (rtx) 0; + rtx dsp16xx_udivqi3_libcall = (rtx) 0; + rtx dsp16xx_udivhi3_libcall = (rtx) 0; + rtx dsp16xx_divqi3_libcall = (rtx) 0; + rtx dsp16xx_divhi3_libcall = (rtx) 0; + rtx dsp16xx_modqi3_libcall = (rtx) 0; + rtx dsp16xx_modhi3_libcall = (rtx) 0; + rtx dsp16xx_umodqi3_libcall = (rtx) 0; + rtx dsp16xx_umodhi3_libcall = (rtx) 0; + rtx dsp16xx_ashrhi3_libcall = (rtx) 0; + rtx dsp16xx_ashlhi3_libcall = (rtx) 0; + rtx dsp16xx_ucmphi2_libcall = (rtx) 0; + rtx dsp16xx_lshrhi3_libcall = (rtx) 0; + + char *himode_reg_name[] = HIMODE_REGISTER_NAMES; + + #define SHIFT_INDEX_1 0 + #define SHIFT_INDEX_4 1 + #define SHIFT_INDEX_8 2 + #define SHIFT_INDEX_16 3 + + static char *ashift_right_asm[] = + { + "%0=%0>>1", + "%0=%0>>4", + "%0=%0>>8", + "%0=%0>>16" + }; + + static char *ashift_right_asm_first[] = + { + "%0=%1>>1", + "%0=%1>>4", + "%0=%1>>8", + "%0=%1>>16" + }; + + static char *ashift_left_asm[] = + { + "%0=%0<<1", + "%0=%0<<4", + "%0=%0<<8", + "%0=%0<<16" + }; + + static char *ashift_left_asm_first[] = + { + "%0=%1<<1", + "%0=%1<<4", + "%0=%1<<8", + "%0=%1<<16" + }; + + static char *lshift_right_asm[] = + { + "%0=%0>>1\n\t%0=%b0&0x7fff", + "%0=%0>>4\n\t%0=%b0&0x0fff", + "%0=%0>>8\n\t%0=%b0&0x00ff", + "%0=%0>>16\n\t%0=%b0&0x0000" + }; + + static char *lshift_right_asm_first[] = + { + "%0=%1>>1\n\t%0=%b0&0x7fff", + "%0=%1>>4\n\t%0=%b0&0x0fff", + "%0=%1>>8\n\t%0=%b0&0x00ff", + "%0=%1>>16\n\t%0=%b0&0x0000" + }; + + int + hard_regno_mode_ok (regno, mode) + int regno; + enum machine_mode mode; + { + switch ((int) mode) + { + case VOIDmode: + return 1; + + /* + We can't use the c0-c2 for QImode, since they are only + 8 bits in length */ + + case QImode: + if (regno != REG_C0 && regno != REG_C1 && regno != REG_C2) + return 1; + else + return 0; + + /* We only allow a0, a1, y, and p to be allocated for 32-bit modes. + Additionally we allow the virtual ybase registers to be used for 32-bit + modes. */ + + case HFmode: + case SFmode: + case DFmode: + case XFmode: + case HImode: + case SImode: + case DImode: + if (regno == REG_A0 || regno == REG_A1 || regno == REG_Y || regno == REG_PROD + || (IS_YBASE_REGISTER_WINDOW(regno) && ((regno & 1) == 0))) + return 1; + else + return 0; + + default: + return 0; + } + } + + enum reg_class + dsp16xx_reg_class_from_letter (c) + int c; + { + switch (c) + { + case 'A': + return ACCUM_REGS; + + case 'h': + return ACCUM_HIGH_REGS; + + case 'j': + return A0H_REG; + + case 'k': + return A0L_REG; + + case 'q': + return A1H_REG; + + case 'u': + return A1L_REG; + + case 'x': + return X_REG; + + case 'y': + return YH_REG; + + case 'z': + return YL_REG; + + case 't': + return P_REG; + + case 'Z': + return Y_OR_P_REGS; + + case 'd': + return ACCUM_Y_OR_P_REGS; + + case 'C': + return NO_FRAME_Y_ADDR_REGS; + + case 'a': + return Y_ADDR_REGS; + + case 'B': + return (TARGET_BMU ? BMU_REGS : NO_REGS); + + case 'Y': + return YBASE_VIRT_REGS; + + case 'v': + return PH_REG; + + case 'w': + return PL_REG; + + case 'W': + return J_REG; + + case 'e': + return YBASE_ELIGIBLE_REGS; + + case 'b': + return ACCUM_LOW_REGS; + + case 'c': + return NON_YBASE_REGS; + + case 'f': + return Y_REG; + + case 'D': + return SLOW_MEM_LOAD_REGS; + + default: + fatal ("Illegal register class letter %c", c); + return NO_REGS; + } + } + /* Return the class number of the smallest class containing + reg number REGNO. */ + + int + regno_reg_class(regno) + int regno; + { + switch (regno) + { + case REG_A0L: + return (int) A0L_REG; + case REG_A1L: + return (int) A1L_REG; + + case REG_A0: + return (int) A0H_REG; + case REG_A1: + return (int) A1H_REG; + + case REG_X: + return (int) X_REG; + + case REG_Y: + return (int) YH_REG; + case REG_YL: + return (int) YL_REG; + + case REG_PROD: + return (int) PH_REG; + case REG_PRODL: + return (int) PL_REG; + + case REG_R0: case REG_R1: case REG_R2: case REG_R3: + return (int) Y_ADDR_REGS; + + case REG_J: + return (int) J_REG; + case REG_K: + return (int) GENERAL_REGS; + + case REG_YBASE: + return (int) GENERAL_REGS; + + case REG_PT: + return (int) GENERAL_REGS; + + case REG_AR0: case REG_AR1: case REG_AR2: case REG_AR3: + return (int) BMU_REGS; + + case REG_C0: case REG_C1: case REG_C2: + return (int) GENERAL_REGS; + + case REG_PR: + return (int) GENERAL_REGS; + + case REG_RB: + return (int) GENERAL_REGS; + + case REG_YBASE0: case REG_YBASE1: case REG_YBASE2: case REG_YBASE3: + case REG_YBASE4: case REG_YBASE5: case REG_YBASE6: case REG_YBASE7: + case REG_YBASE8: case REG_YBASE9: case REG_YBASE10: case REG_YBASE11: + case REG_YBASE12: case REG_YBASE13: case REG_YBASE14: case REG_YBASE15: + case REG_YBASE16: case REG_YBASE17: case REG_YBASE18: case REG_YBASE19: + case REG_YBASE20: case REG_YBASE21: case REG_YBASE22: case REG_YBASE23: + case REG_YBASE24: case REG_YBASE25: case REG_YBASE26: case REG_YBASE27: + case REG_YBASE28: case REG_YBASE29: case REG_YBASE30: case REG_YBASE31: + return (int) YBASE_VIRT_REGS; + + default: + return (int) NO_REGS; + } + } + + /* A C expression for the maximum number of consecutive registers of class CLASS + needed to hold a value of mode MODE */ + + int + class_max_nregs(class, mode) + enum reg_class class; + enum machine_mode mode; + { + return (GET_MODE_SIZE(mode)); + } + + enum reg_class + limit_reload_class (mode, class) + enum machine_mode mode; + enum reg_class class; + { + switch ((int) class) + { + case NO_REGS: + case A0H_REG: + case A0L_REG: + case A0_REG: + case A1H_REG: + return class; + + case ACCUM_HIGH_REGS: + fatal ("ACCUM_HIGH_REGS class in limit_reload_class"); + + case A1L_REG: + case ACCUM_LOW_REGS: + case A1_REG: + return class; + + case ACCUM_REGS: + if (GET_MODE_SIZE(mode) == 1) + return ACCUM_LOW_REGS; + else + return class; + + case X_REG: + case X_OR_ACCUM_LOW_REGS: + return class; + + case X_OR_ACCUM_REGS: + if (GET_MODE_SIZE(mode) == 1) + return X_OR_ACCUM_LOW_REGS; + else + return class; + + case YH_REG: + return class; + + case YH_OR_ACCUM_HIGH_REGS: + fatal ("YH_OR_ACCUM_HIGH_REGS found in limit_reload_class"); + + case X_OR_YH_REGS: + return class; + + case YL_REG: + /* Register 'yl' is illegal for QImode, so we should never + see it. */ + + fatal ("YL found in limit_reload_class"); + + case YL_OR_ACCUM_LOW_REGS: + case X_OR_YL_REGS: + return class; + + case Y_REG: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return YH_REG; + + case ACCUM_OR_Y_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return YL_OR_ACCUM_LOW_REGS; + + case PH_REG: + case X_OR_PH_REGS: + case PL_REG: + case PL_OR_ACCUM_LOW_REGS: + case X_OR_PL_REGS: + return class; + + case P_REG: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return PL_REG; + + case ACCUM_OR_P_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return PL_OR_ACCUM_LOW_REGS; + + case YL_OR_P_REGS: + case ACCUM_LOW_OR_YL_OR_P_REGS: + return class; + + case Y_OR_P_REGS: + return class; + + case ACCUM_Y_OR_P_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return ACCUM_LOW_OR_YL_OR_P_REGS; + + case NO_FRAME_Y_ADDR_REGS: + case Y_ADDR_REGS: + case ACCUM_LOW_OR_Y_ADDR_REGS: + return class; + + case ACCUM_OR_Y_ADDR_REGS: + if (GET_MODE_SIZE(mode) > 1) + return ACCUM_REGS; + else + return ACCUM_LOW_OR_Y_ADDR_REGS; + + case X_OR_Y_ADDR_REGS: + return class; + + case Y_OR_Y_ADDR_REGS: + case P_OR_Y_ADDR_REGS: + case NON_HIGH_YBASE_ELIGIBLE_REGS: + + case J_REG: + return class; + + case YBASE_ELIGIBLE_REGS: + if (GET_MODE_SIZE(mode) > 1) + return ACCUM_Y_P_OR_YBASE_REGS; + else + return NON_HIGH_YBASE_ELIGIBLE_REGS; + + case J_OR_DAU_16_BIT_REGS: + if (GET_MODE_SIZE(mode) == 1) + return J_REG; + else + return class; + + case BMU_REGS: + case NOHIGH_NON_ADDR_REGS: + return class; + + case NON_ADDR_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return NOHIGH_NON_ADDR_REGS; + + case NOHIGH_NON_YBASE_REGS: + return class; + + case NON_YBASE_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return NOHIGH_NON_YBASE_REGS; + + case YBASE_VIRT_REGS: + case ACCUM_LOW_OR_YBASE_REGS: + return class; + + case ACCUM_OR_YBASE_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return ACCUM_LOW_OR_YBASE_REGS; + + case X_OR_YBASE_REGS: + return class; + + case Y_OR_YBASE_REGS: + case ACCUM_LOW_YL_PL_OR_YBASE_REGS: + case P_OR_YBASE_REGS: + return class; + + case ACCUM_Y_P_OR_YBASE_REGS: + return ACCUM_LOW_YL_PL_OR_YBASE_REGS; + + case Y_ADDR_OR_YBASE_REGS: + case YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS: + return class; + + case YBASE_OR_YBASE_ELIGIBLE_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS; + + case NO_HIGH_ALL_REGS: + return class; + + case ALL_REGS: + if (GET_MODE_SIZE(mode) > 1) + return class; + else + return NO_HIGH_ALL_REGS; + + default: + return class; + } + } + + int + dsp16xx_register_move_cost (from, to) + enum reg_class from, to; + { + #if 0 + if (from == NO_REGS || to == NO_REGS || (from == to)) + return 2; + #endif + + if (from == A0H_REG || from == A0L_REG || from == A0_REG || + from == A1H_REG || from == ACCUM_HIGH_REGS || from == A1L_REG || + from == ACCUM_LOW_REGS || from == A1_REG || from == ACCUM_REGS) + { + if (to == Y_REG || to == P_REG) + return 4; + else + return 2; + } + + if (to == A0H_REG || to == A0L_REG || to == A0_REG || + to == A1H_REG || to == ACCUM_HIGH_REGS || to == A1L_REG || + to == ACCUM_LOW_REGS || to == A1_REG || to == ACCUM_REGS) + { + return 2; + } + + #if 0 + if (from == YBASE_VIRT_REGS) + { + if (to == X_REG || to == YH_REG || to == YL_REG || + to == Y_REG || to == PL_REG || to == PH_REG || + to == P_REG || to == Y_ADDR_REGS || to == YBASE_ELIGIBLE_REGS || + to == Y_OR_P_REGS) + { + return 2; + } + else + return 4; + } + + if (to == YBASE_VIRT_REGS) + { + if (from == X_REG || from == YH_REG || from == YL_REG || + from == Y_REG || from == PL_REG || from == PH_REG || + from == P_REG || from == Y_ADDR_REGS || from == YBASE_ELIGIBLE_REGS || + from == Y_OR_P_REGS) + { + return 2; + } + else + return 4; + } + #endif + return 4; + } + + /* Given an rtx X being reloaded into a reg required to be + in class CLASS, return the class of reg to actually use. + In general this is just CLASS; but on some machines + in some cases it is preferable to use a more restrictive class. + Also, we must ensure that a PLUS is reloaded either + into an accumulator or an address register. */ + + enum reg_class + preferred_reload_class (x, class) + rtx x; + enum reg_class class; + { + /* The ybase registers cannot have constants copied directly + to them. */ + + if (CONSTANT_P (x)) + { + if (class == ALL_REGS) + return NON_YBASE_REGS; + } + + if (class == ALL_REGS && REG_P (x) && !TARGET_RESERVE_YBASE + && IS_YBASE_REGISTER_WINDOW (REGNO(x))) + return YBASE_ELIGIBLE_REGS; + + if (GET_CODE (x) == PLUS) + { + if (GET_MODE (x) == QImode + && REG_P (XEXP (x,0)) + && (XEXP (x,0) == frame_pointer_rtx + || XEXP (x,0) == stack_pointer_rtx) + && (GET_CODE (XEXP (x,1)) == CONST_INT)) + { + if (class == ACCUM_HIGH_REGS) + return class; + + if (reg_class_subset_p (ACCUM_HIGH_REGS, class)) + return ACCUM_HIGH_REGS; + + /* We will use accumulator 'a1l' for reloading a + PLUS. We can only use one accumulator because + 'reload_inqi' only allows one alternative to be + used. */ + + else if (class == ACCUM_LOW_REGS) + return A1L_REG; + else if (class == A0L_REG) + return NO_REGS; + else + return class; + } + + if (class == NON_YBASE_REGS || class == YBASE_ELIGIBLE_REGS) + return Y_ADDR_REGS; + else + return class; + } + else if (GET_CODE (x) == MEM) + { + if (class == ALL_REGS) + { + #if 0 + if (GET_MODE(x) == HImode) + return NO_ACCUM_NON_YBASE_REGS; + else + #endif + return NON_YBASE_REGS; + } + else + return class; + } + else + return class; + } + + /* Return the register class of a scratch register needed to copy IN into + or out of a register in CLASS in MODE. If it can be done directly, + NO_REGS is returned. */ + + enum reg_class + secondary_reload_class (class, mode, in) + enum reg_class class; + enum machine_mode mode; + rtx in; + { + int regno = -1; + + if (GET_CODE (in) == REG || GET_CODE (in) == SUBREG) + regno = true_regnum (in); + + if (class == ACCUM_HIGH_REGS + || class == ACCUM_LOW_REGS + || class == A1L_REG + || class == A0L_REG + || class == A1H_REG + || class == A0H_REG) + { + if (GET_CODE (in) == PLUS && mode == QImode) + { + rtx addr0 = XEXP (in, 0); + rtx addr1 = XEXP (in, 1); + + /* If we are reloading a plus (reg:QI) (reg:QI) + we need an additional register. */ + if (REG_P (addr0) && REG_P (addr1)) + return NO_REGS; + } + } + + /* We can place anything into ACCUM_REGS and can put ACCUM_REGS + into anything. */ + + if ((class == ACCUM_REGS || class == ACCUM_HIGH_REGS || + class == ACCUM_LOW_REGS || class == A0H_REG || class == A0L_REG || + class == A1H_REG || class == A1_REG) || + (regno >= REG_A0 && regno < REG_A1L + 1)) + return NO_REGS; + + /* We can copy the ybase registers into: + r0-r3, a0-a1, y, p, & x or the union of + any of these. */ + + if (!TARGET_RESERVE_YBASE && IS_YBASE_REGISTER_WINDOW(regno)) + { + switch ((int) class) + { + case (int) X_REG: + case (int) X_OR_ACCUM_LOW_REGS: + case (int) X_OR_ACCUM_REGS: + case (int) YH_REG: + case (int) YH_OR_ACCUM_HIGH_REGS: + case (int) X_OR_YH_REGS: + case (int) YL_REG: + case (int) YL_OR_ACCUM_LOW_REGS: + case (int) X_OR_Y_REGS: + case (int) X_OR_YL_REGS: + case (int) Y_REG: + case (int) ACCUM_OR_Y_REGS: + case (int) PH_REG: + case (int) X_OR_PH_REGS: + case (int) PL_REG: + case (int) PL_OR_ACCUM_LOW_REGS: + case (int) X_OR_PL_REGS: + case (int) YL_OR_PL_OR_ACCUM_LOW_REGS: + case (int) P_REG: + case (int) ACCUM_OR_P_REGS: + case (int) YL_OR_P_REGS: + case (int) ACCUM_LOW_OR_YL_OR_P_REGS: + case (int) Y_OR_P_REGS: + case (int) ACCUM_Y_OR_P_REGS: + case (int) Y_ADDR_REGS: + case (int) ACCUM_LOW_OR_Y_ADDR_REGS: + case (int) ACCUM_OR_Y_ADDR_REGS: + case (int) X_OR_Y_ADDR_REGS: + case (int) Y_OR_Y_ADDR_REGS: + case (int) P_OR_Y_ADDR_REGS: + case (int) YBASE_ELIGIBLE_REGS: + return NO_REGS; + + default: + return ACCUM_HIGH_REGS; + } + } + + /* We can copy r0-r3, a0-a1, y, & p + directly to the ybase registers. In addition + we can use any of the ybase virtual registers + as the secondary reload registers when copying + between any of these registers. */ + + if (!TARGET_RESERVE_YBASE && regno != -1) + { + switch (regno) + { + case REG_A0: + case REG_A0L: + case REG_A1: + case REG_A1L: + case REG_X: + case REG_Y: + case REG_YL: + case REG_PROD: + case REG_PRODL: + case REG_R0: + case REG_R1: + case REG_R2: + case REG_R3: + if (class == YBASE_VIRT_REGS) + return NO_REGS; + else + { + switch ((int) class) + { + case (int) X_REG: + case (int) X_OR_ACCUM_LOW_REGS: + case (int) X_OR_ACCUM_REGS: + case (int) YH_REG: + case (int) YH_OR_ACCUM_HIGH_REGS: + case (int) X_OR_YH_REGS: + case (int) YL_REG: + case (int) YL_OR_ACCUM_LOW_REGS: + case (int) X_OR_Y_REGS: + case (int) X_OR_YL_REGS: + case (int) Y_REG: + case (int) ACCUM_OR_Y_REGS: + case (int) PH_REG: + case (int) X_OR_PH_REGS: + case (int) PL_REG: + case (int) PL_OR_ACCUM_LOW_REGS: + case (int) X_OR_PL_REGS: + case (int) YL_OR_PL_OR_ACCUM_LOW_REGS: + case (int) P_REG: + case (int) ACCUM_OR_P_REGS: + case (int) YL_OR_P_REGS: + case (int) ACCUM_LOW_OR_YL_OR_P_REGS: + case (int) Y_OR_P_REGS: + case (int) ACCUM_Y_OR_P_REGS: + case (int) Y_ADDR_REGS: + case (int) ACCUM_LOW_OR_Y_ADDR_REGS: + case (int) ACCUM_OR_Y_ADDR_REGS: + case (int) X_OR_Y_ADDR_REGS: + case (int) Y_OR_Y_ADDR_REGS: + case (int) P_OR_Y_ADDR_REGS: + case (int) YBASE_ELIGIBLE_REGS: + return YBASE_VIRT_REGS; + + default: + break; + } + } + } + } + + /* Memory or constants can be moved from or to any register + except the ybase virtual registers */ + if (regno == -1 && GET_CODE(in) != PLUS) + { + if (class == YBASE_VIRT_REGS) + return NON_YBASE_REGS; + else + return NO_REGS; + } + + if (GET_CODE (in) == PLUS && mode == QImode) + { + rtx addr0 = XEXP (in, 0); + rtx addr1 = XEXP (in, 1); + + /* If we are reloading a plus (reg:QI) (reg:QI) + we need a low accumulator, not a high one. */ + if (REG_P (addr0) && REG_P (addr1)) + return ACCUM_LOW_REGS; + } + + #if 0 + if (REG_P(in)) + return ACCUM_REGS; + #endif + + /* Otherwise, we need a high accumulator(s). */ + return ACCUM_HIGH_REGS; + } + + int + symbolic_address_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (symbolic_address_p (op)); + + } + + int symbolic_address_p (op) + rtx op; + { + switch (GET_CODE (op)) + { + case SYMBOL_REF: + case LABEL_REF: + return 1; + + case CONST: + op = XEXP (op, 0); + return ((GET_CODE (XEXP (op, 0)) == SYMBOL_REF + || GET_CODE (XEXP (op, 0)) == LABEL_REF) + && GET_CODE (XEXP (op, 1)) == CONST_INT + && INTVAL (XEXP (op,1)) < 0x20); + + default: + return 0; + } + } + + /* For a Y address space operand we allow only *rn, *rn++, *rn--. + This routine only recognizes *rn, the '<>' constraints recognize + *rn++, *rn-- */ + + int + Y_address_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (memory_address_p (mode, op) && !symbolic_address_p (op)); + } + + int + sp_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (GET_CODE (op) == PLUS + && (XEXP (op, 0) == stack_pointer_rtx + || XEXP (op, 0) == frame_pointer_rtx) + && GET_CODE (XEXP (op,1)) == CONST_INT); + } + + int + sp_operand2 (op, mode) + rtx op; + enum machine_mode mode; + { + if ((GET_CODE (op) == PLUS + && (XEXP (op, 0) == stack_pointer_rtx + || XEXP (op, 0) == frame_pointer_rtx) + && (REG_P (XEXP (op,1)) + && IS_ADDRESS_REGISTER (REGNO (XEXP(op, 1)))))) + return 1; + else if ((GET_CODE (op) == PLUS + && (XEXP (op, 1) == stack_pointer_rtx + || XEXP (op, 1) == frame_pointer_rtx) + && (REG_P (XEXP (op,0)) + && IS_ADDRESS_REGISTER (REGNO (XEXP(op, 1)))))) + return 1; + else + return 0; + } + + int + nonmemory_arith_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (immediate_operand (op, mode) || arith_reg_operand (op, mode)); + } + + int + arith_reg_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (register_operand (op, mode) + && (GET_CODE (op) != REG + || REGNO (op) >= FIRST_PSEUDO_REGISTER + || (!(IS_YBASE_REGISTER_WINDOW (REGNO (op))) + && REGNO (op) != FRAME_POINTER_REGNUM))); + } + + int + call_address_operand (op, mode) + rtx op; + enum machine_mode mode; + { + if (symbolic_address_p (op) || REG_P(op)) + { + return 1; + } + + return 0; + } + + int + dsp16xx_comparison_operator (op, mode) + register rtx op; + enum machine_mode mode; + { + return ((mode == VOIDmode || GET_MODE (op) == mode) + && GET_RTX_CLASS (GET_CODE (op)) == '<' + && (GET_CODE(op) != GE && GET_CODE (op) != LT && + GET_CODE (op) != GEU && GET_CODE (op) != LTU)); + } + + void + notice_update_cc(exp) + rtx exp; + { + if (GET_CODE (exp) == SET) + { + /* Jumps do not alter the cc's. */ + + if (SET_DEST (exp) == pc_rtx) + return; + + /* Moving register or memory into a register: + it doesn't alter the cc's, but it might invalidate + the RTX's which we remember the cc's came from. + (Note that moving a constant 0 or 1 MAY set the cc's). */ + if (REG_P (SET_DEST (exp)) + && (REG_P (SET_SRC (exp)) || GET_CODE (SET_SRC (exp)) == MEM)) + { + if (cc_status.value1 + && reg_overlap_mentioned_p (SET_DEST (exp), cc_status.value1)) + cc_status.value1 = 0; + if (cc_status.value2 + && reg_overlap_mentioned_p (SET_DEST (exp), cc_status.value2)) + cc_status.value2 = 0; + return; + } + /* Moving register into memory doesn't alter the cc's. + It may invalidate the RTX's which we remember the cc's came from. */ + if (GET_CODE (SET_DEST (exp)) == MEM && REG_P (SET_SRC (exp))) + { + if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM) + cc_status.value1 = 0; + if (cc_status.value2 && GET_CODE (cc_status.value2) == MEM) + cc_status.value2 = 0; + return; + } + /* Function calls clobber the cc's. */ + else if (GET_CODE (SET_SRC (exp)) == CALL) + { + CC_STATUS_INIT; + return; + } + /* Tests and compares set the cc's in predictable ways. */ + else if (SET_DEST (exp) == cc0_rtx) + { + CC_STATUS_INIT; + cc_status.value1 = SET_SRC (exp); + return; + } + /* Certain instructions effect the condition codes. */ + else if (GET_MODE_CLASS (GET_MODE (SET_SRC (exp))) == MODE_INT) + switch( GET_CODE (SET_SRC (exp)) ) + { + case PLUS: + case MINUS: + if (REG_P (SET_DEST (exp))) + { + /* Address registers don't set the condition codes */ + if (IS_ADDRESS_REGISTER (REGNO (SET_DEST (exp)))) + { + CC_STATUS_INIT; + break; + } + } + case ASHIFTRT: + case LSHIFTRT: + case ASHIFT: + case LSHIFT: + case AND: + case IOR: + case XOR: + case MULT: + case NEG: + case NOT: + cc_status.value1 = SET_SRC (exp); + cc_status.value2 = SET_DEST (exp); + break; + + default: + CC_STATUS_INIT; + } + else + { + CC_STATUS_INIT; + } + } + else if (GET_CODE (exp) == PARALLEL + && GET_CODE (XVECEXP (exp, 0, 0)) == SET) + { + if (SET_DEST (XVECEXP (exp, 0, 0)) == pc_rtx) + return; + + if (SET_DEST (XVECEXP (exp, 0, 0)) == cc0_rtx) + { + CC_STATUS_INIT; + cc_status.value1 = SET_SRC (XVECEXP (exp, 0, 0)); + return; + } + + CC_STATUS_INIT; + } + else + { + CC_STATUS_INIT; + } + } + + int + dsp16xx_makes_calls () + { + rtx insn; + + for (insn = get_insns (); insn; insn = next_insn (insn)) + if (GET_CODE (insn) == CALL_INSN) + return (1); + + return 0; + } + + long compute_frame_size (size) + int size; + { + long total_size; + long var_size; + long args_size; + long extra_size; + long reg_size; + + reg_size = 0; + extra_size = 0; + var_size = size; + args_size = current_function_outgoing_args_size; + reg_size = reg_save_size (); + + total_size = var_size + args_size + extra_size + reg_size; + + + /* Save other computed information. */ + current_frame_info.total_size = total_size; + current_frame_info.var_size = var_size; + current_frame_info.args_size = args_size; + current_frame_info.extra_size = extra_size; + current_frame_info.reg_size = reg_size; + current_frame_info.initialized = reload_completed; + current_frame_info.reg_size = reg_size / UNITS_PER_WORD; + current_frame_info.function_makes_calls = dsp16xx_makes_calls (); + + if (reg_size) + { + unsigned long offset = args_size + var_size + reg_size; + current_frame_info.sp_save_offset = offset; + current_frame_info.fp_save_offset = offset - total_size; + } + + return total_size; + } + + int + dsp16xx_call_saved_register (regno) + int regno; + { + return (regs_ever_live[regno] && !call_used_regs[regno] && + !IS_YBASE_REGISTER_WINDOW(regno)); + + } + + int + ybase_regs_ever_used () + { + int regno; + int live = 0; + + for (regno = REG_YBASE0; regno <= REG_YBASE31; regno++) + if (regs_ever_live[regno]) + { + live = 1; + break; + } + + return live; + } + + void + function_prologue (file, size) + FILE *file; + int size; + { + int regno; + long total_size; + fp = reg_names[FRAME_POINTER_REGNUM]; + sp = reg_names[STACK_POINTER_REGNUM]; + rr = reg_names[RETURN_ADDRESS_REGNUM]; /* return address register */ + a1h = reg_names[REG_A1]; + + total_size = compute_frame_size (size); + + fprintf( file, "\t/* FUNCTION PROLOGUE: */\n" ); + fprintf (file, "\t/* total=%d, vars= %d, regs= %d, args=%d, extra= %d */\n", + current_frame_info.total_size, + current_frame_info.var_size, + current_frame_info.reg_size, + current_function_outgoing_args_size, + current_frame_info.extra_size); + + fprintf (file, "\t/* fp save offset= %d, sp save_offset= %d */\n\n", + current_frame_info.fp_save_offset, + current_frame_info.sp_save_offset); + /* Set up the 'ybase' register window. */ + + if (ybase_regs_ever_used()) + { + fprintf (file, "\t%s=%s\n", a1h, reg_names[REG_YBASE]); + if (TARGET_YBASE_HIGH) + fprintf (file, "\t%s=%sh-32\n", reg_names[REG_A1], a1h); + else + fprintf (file, "\t%s=%sh+32\n", reg_names[REG_A1], a1h); + fprintf (file, "\t%s=%s\n", reg_names[REG_YBASE], a1h); + } + + #if 0 + if (current_frame_info.function_makes_calls) + fprintf( file, "\t*%s++=%s\n", sp, rr ); /* Push return address */ + #endif + + + if (current_frame_info.var_size) + { + if (current_frame_info.var_size == 1) + fprintf (file, "\t*%s++\n", sp); + else + { + if(SMALL_INTVAL(current_frame_info.var_size) && ((current_frame_info.var_size & 0x8000) == 0)) + fprintf (file, "\t%s=%d\n\t*%s++%s\n", reg_names[REG_J], current_frame_info.var_size, sp, reg_names[REG_J]); + else + fatal ("Stack size > 32k"); + } + } + + /* Save any registers this function uses, unless they are + * used in a call, in which case we don't need to + */ + + for( regno = 0; regno < FIRST_PSEUDO_REGISTER; ++ regno ) + if (dsp16xx_call_saved_register (regno)) + { + #if OLD_REGISTER_SAVE + fprintf( file, "\t*%s++=%s\n", sp, reg_names[regno] ); + #else + fprintf( file, "\tpush(*%s)=%s\n", sp, reg_names[regno] ); + #endif + } + + if (current_frame_info.args_size) + { + if (current_frame_info.args_size == 1) + fprintf (file, "\t*%s++\n", sp); + else + { + if(SMALL_INTVAL(current_frame_info.args_size) && ((current_frame_info.args_size & 0x8000) == 0)) + fprintf (file, "\t%s=%d\n\t*%s++%s\n", reg_names[REG_J], current_frame_info.args_size, sp, reg_names[REG_J]); + else + fatal ("Stack size > 32k"); + } + } + + if (frame_pointer_needed) + { + fprintf( file, "\t%s=%s\n", a1h, sp ); + fprintf( file, "\t%s=%s\n", fp, a1h ); /* Establish new base frame */ + fprintf( file, "\t%s=%d\n", reg_names[REG_J], -total_size); + fprintf( file, "\t*%s++%s\n", fp, reg_names[REG_J]); + } + + fprintf( file, "\t/* END FUNCTION PROLOGUE: */\n\n" ); + } + + void + init_emulation_routines () + { + dsp16xx_addhf3_libcall = (rtx) 0; + dsp16xx_subhf3_libcall = (rtx) 0; + dsp16xx_mulhf3_libcall = (rtx) 0; + dsp16xx_divhf3_libcall = (rtx) 0; + dsp16xx_cmphf3_libcall = (rtx) 0; + dsp16xx_fixhfhi2_libcall = (rtx) 0; + dsp16xx_floathihf2_libcall = (rtx) 0; + dsp16xx_neghf2_libcall = (rtx) 0; + + dsp16xx_mulhi3_libcall = (rtx) 0; + dsp16xx_udivqi3_libcall = (rtx) 0; + dsp16xx_udivhi3_libcall = (rtx) 0; + dsp16xx_divqi3_libcall = (rtx) 0; + dsp16xx_divhi3_libcall = (rtx) 0; + dsp16xx_modqi3_libcall = (rtx) 0; + dsp16xx_modhi3_libcall = (rtx) 0; + dsp16xx_umodqi3_libcall = (rtx) 0; + dsp16xx_umodhi3_libcall = (rtx) 0; + dsp16xx_ashrhi3_libcall = (rtx) 0; + dsp16xx_ashlhi3_libcall = (rtx) 0; + dsp16xx_ucmphi2_libcall = (rtx) 0; + dsp16xx_lshrhi3_libcall = (rtx) 0; + + } + void + function_epilogue (file, size) + FILE *file; + int size; + { + int regno; + int initial_stack_dec = 0; + + fp = reg_names[FRAME_POINTER_REGNUM]; + sp = reg_names[STACK_POINTER_REGNUM]; + rr = reg_names[RETURN_ADDRESS_REGNUM]; /* return address register */ + a1h = reg_names[REG_A1]; + + fprintf( file, "\n\t/* FUNCTION EPILOGUE: */\n" ); + + if (current_frame_info.args_size) + { + if (current_frame_info.args_size == 1) + fprintf (file, "\t*%s--\n", sp); + else + { + fprintf (file, "\t%s=%d\n\t*%s++%s\n", + reg_names[REG_J], -current_frame_info.args_size, sp, reg_names[REG_J]); + } + } + + if (ybase_regs_ever_used()) + { + fprintf (file, "\t%s=%s\n", a1h, reg_names[REG_YBASE]); + if (TARGET_YBASE_HIGH) + fprintf (file, "\t%s=%sh+32\n", reg_names[REG_A1], a1h); + else + fprintf (file, "\t%s=%sh-32\n", reg_names[REG_A1], a1h); + fprintf (file, "\t%s=%s\n", reg_names[REG_YBASE], a1h); + } + + for (regno = FIRST_PSEUDO_REGISTER - 1; regno >= 0; --regno) + if (dsp16xx_call_saved_register(regno)) + { + #if OLD_REGISTER_SAVE + if (!initial_stack_dec) + { + initial_stack_dec = 1; + fprintf (file, "\t*%s--\n", sp); + } + #endif + + #if OLD_REGISTER_SAVE + fprintf( file, "\t%s=*%s--\n", reg_names[regno], sp ); + #else + fprintf( file, "\t%s=pop(*%s)\n", reg_names[regno], sp ); + #endif + } + + /* If we restored any registers we have to account for the + initial pre-decrement. But only if we had any local variables + or spills. */ + #if OLD_REGISTER_SAVE + if (initial_stack_dec) + fprintf (file, "\t*%s++\n", sp); + #endif + + if (current_frame_info.var_size) + { + if (current_frame_info.var_size == 1) + fprintf (file, "\t*%s--\n", sp); + else + { + fprintf (file, "\t%s=%d\n\t*%s++%s\n", + reg_names[REG_J], -current_frame_info.var_size, sp, reg_names[REG_J]); + } + } + + fprintf (file, "\treturn\n"); + /* Reset the frame info for the next function */ + current_frame_info = zero_frame_info; + init_emulation_routines (); + } + + /* Emit insns to move operands[1] into operands[0]. + + Return 1 if we have written out everything that needs to be done to + do the move. Otherwise, return 0 and the caller will emit the move + normally. */ + + int + emit_move_sequence (operands, mode) + rtx *operands; + enum machine_mode mode; + { + register rtx operand0 = operands[0]; + register rtx operand1 = operands[1]; + + /* We can only store registers to memory. */ + + if (GET_CODE (operand0) == MEM && GET_CODE (operand1) != REG) + operands[1] = force_reg (mode, operand1); + + return 0; + } + + void + double_reg_from_memory (operands) + rtx operands[]; + { + rtx xoperands[4]; + + if (GET_CODE(XEXP(operands[1],0)) == POST_INC) + { + output_asm_insn ("%u0=%1", operands); + output_asm_insn ("%w0=%1", operands); + } + else if (GET_CODE(XEXP(operands[1],0)) == POST_DEC) + { + xoperands[1] = XEXP (XEXP (operands[1], 0), 0); + xoperands[0] = operands[0]; + + /* We can't use j anymore since the compiler can allocate it. */ + /* output_asm_insn ("j=-3\n\t%u0=*%1++\n\t%w0=*%1++j", xoperands); */ + output_asm_insn ("%u0=*%1++\n\t%w0=*%1--\n\t*%1--\n\t*%1--", xoperands); + } + else if (GET_CODE(XEXP(operands[1],0)) == PLUS) + { + rtx addr; + rtx base; + int offset; + + output_asm_insn ("%u0=%1", operands); + + + /* In order to print out the least significant word we must + use 'offset + 1'. */ + addr = XEXP (operands[1], 0); + if (GET_CODE (XEXP(addr,0)) == CONST_INT) + offset = INTVAL(XEXP(addr,0)) + 1; + else if (GET_CODE (XEXP(addr,1)) == CONST_INT) + offset = INTVAL(XEXP(addr,1)) + 1; + + fprintf (asm_out_file, "\t%s=*(%d)\n", reg_names[REGNO(operands[0]) + 1], offset + 31); + } + else + { + xoperands[1] = XEXP(operands[1],0); + xoperands[0] = operands[0]; + + output_asm_insn ("%u0=*%1++\n\t%w0=*%1--", xoperands); + } + } + + + void + double_reg_to_memory (operands) + rtx operands[]; + { + rtx xoperands[4]; + + if (GET_CODE(XEXP(operands[0],0)) == POST_INC) + { + output_asm_insn ("%0=%u1", operands); + output_asm_insn ("%0=%w1", operands); + } + else if (GET_CODE(XEXP(operands[0],0)) == POST_DEC) + { + xoperands[0] = XEXP (XEXP (operands[0], 0), 0); + xoperands[1] = operands[1]; + + /* We can't use j anymore since the compiler can allocate it. */ + + /* output_asm_insn ("j=-3\n\t*%0++=%u1\n\t*%0++j=%w1", xoperands); */ + output_asm_insn ("*%0++=%u1\n\t*%0--=%w1\n\t*%0--\n\t*%0--", xoperands); + + } + else if (GET_CODE(XEXP(operands[0],0)) == PLUS) + { + rtx addr; + int offset; + + output_asm_insn ("%0=%u1", operands); + + /* In order to print out the least significant word we must + use 'offset + 1'. */ + addr = XEXP (operands[0], 0); + if (GET_CODE (XEXP(addr,0)) == CONST_INT) + offset = INTVAL(XEXP(addr,0)) + 1; + else if (GET_CODE (XEXP(addr,1)) == CONST_INT) + offset = INTVAL(XEXP(addr,1)) + 1; + else + fatal ("Illegal addressing mode"); + + fprintf (asm_out_file, "\t*(%d)=%s\n", offset + 31, reg_names[REGNO(operands[1]) + 1]); + } + else + { + xoperands[0] = XEXP(operands[0],0); + xoperands[1] = operands[1]; + + output_asm_insn ("*%0++=%u1\n\t*%0--=%w1", xoperands); + } + } + + void + override_options () + { + if (chip_name == (char *) 0) + chip_name = DEFAULT_CHIP_NAME; + + if (text_seg_name == (char *) 0) + text_seg_name = DEFAULT_TEXT_SEG_NAME; + + if (data_seg_name == (char *) 0) + data_seg_name = DEFAULT_DATA_SEG_NAME; + + if (bss_seg_name == (char *) 0) + bss_seg_name = DEFAULT_BSS_SEG_NAME; + + if (const_seg_name == (char *) 0) + const_seg_name = DEFAULT_CONST_SEG_NAME; + + save_chip_name = (char *) xmalloc (strlen(chip_name) + 1); + strcpy (save_chip_name, chip_name); + + rsect_text = (char *) xmalloc (strlen(".rsect ") + + strlen(text_seg_name) + 3); + rsect_data = (char *) xmalloc (strlen(".rsect ") + + strlen(data_seg_name) + 3); + rsect_bss = (char *) xmalloc (strlen(".rsect ") + + strlen(bss_seg_name) + 3); + rsect_const = (char *) xmalloc (strlen(".rsect ") + + strlen(const_seg_name) + 3); + + sprintf (rsect_text, ".rsect \"%s\"", text_seg_name); + sprintf (rsect_data, ".rsect \"%s\"", data_seg_name); + sprintf (rsect_bss, ".rsect \"%s\"", bss_seg_name); + sprintf (rsect_const, ".rsect \"%s\"", const_seg_name); + + if (optimize) + { + if (TARGET_OPTIMIZE_SPEED) + { + flag_unroll_loops = 1; + flag_inline_functions = 1; + } + } + } + + enum rtx_code save_next_cc_user_code; + + enum rtx_code + next_cc_user_code (insn) + rtx insn; + { + if ( !(insn = next_cc0_user (insn))) + abort (); + else if (GET_CODE (insn) == JUMP_INSN + && GET_CODE (PATTERN (insn)) == SET + && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE) + return GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 0)); + else if (GET_CODE (insn) == INSN + && GET_CODE (PATTERN (insn)) == SET + && comparison_operator (SET_SRC (PATTERN (insn)), VOIDmode)) + return GET_CODE (SET_SRC (PATTERN (insn))); + else + abort (); + } + + void + print_operand(file, op, letter) + FILE *file; + rtx op; + int letter; + { + enum rtx_code code; + + code = GET_CODE(op); + + switch (letter) + { + case 'I': + code = reverse_condition (code); + /* Fallthrough */ + + case 'C': + if (code == EQ) + { + fputs ("eq", file); + return; + } + else if (code == NE) + { + fputs ("ne", file); + return; + } + else if (code == GT || code == GTU) + { + fputs ("gt", file); + return; + } + else if (code == LT || code == LTU) + { + fputs ("mi", file); + return; + } + else if (code == GE || code == GEU) + { + fputs ("pl", file); + return; + } + else if (code == LE || code == LEU) + { + fputs ("le", file); + return; + } + else + abort (); + break; + + default: + break; + } + + if( code == REG ) + { + /* Print the low half of a 32-bit register pair */ + if (letter == 'w') + fprintf( file, "%s", reg_names[REGNO(op)+1] ); + else if (letter == 'u' || !letter) + fprintf( file, "%s", reg_names[REGNO(op)]); + else if (letter == 'b') + fprintf ( file, "%sh", reg_names[REGNO(op)]); + else if (letter == 'm') + fprintf (file, "%s", himode_reg_name[REGNO(op)]); + else + fatal("Bad register extension code"); + } + else if( code == MEM ) + output_address( XEXP(op,0) ); + else if( code == CONST_INT ) + { + if( letter == 'H' ) + fprintf( file, "0x%x", (INTVAL(op) & 0xffff) ); + else if (letter == 'h') + fprintf( file, "%d", INTVAL (op) ); + else if( letter == 'U' ) + fprintf( file, "0x%x", ((INTVAL(op) & 0xffff0000) >> 16) & 0xffff ); + else + output_addr_const( file, op ); + } + else if( code == CONST_DOUBLE && GET_MODE(op) != DImode ) + { + union { double d; int i[2]; } u; + union { float f; int i; } u1; + u.i[0] = CONST_DOUBLE_LOW (op); + u.i[1] = CONST_DOUBLE_HIGH (op); + u1.f = u.d; + fprintf( file, "0x%x", u1.i ); + } + else output_addr_const( file, op); + } + + + void + print_operand_address(file, addr) + FILE *file; + rtx addr; + { + rtx base; + int offset; + + switch (GET_CODE (addr)) + { + case REG: + fprintf (file, "*%s", reg_names[REGNO (addr)]); + break; + case POST_DEC: + fprintf (file, "*%s--", reg_names[REGNO (XEXP (addr, 0))]); + break; + case POST_INC: + fprintf (file, "*%s++", reg_names[REGNO (XEXP (addr, 0))]); + break; + case PLUS: + if (GET_CODE (XEXP(addr,0)) == CONST_INT) + offset = INTVAL(XEXP(addr,0)), base = XEXP(addr,1); + else if (GET_CODE (XEXP(addr,1)) == CONST_INT) + offset = INTVAL(XEXP(addr,1)), base = XEXP(addr,0); + if (GET_CODE (base) == REG && REGNO(base) == STACK_POINTER_REGNUM) + { + if (offset >= -31 && offset <= 0) + offset = 31 + offset; + else + fatal ("Illegal offset in ybase addressing"); + } + else + fatal ("Illegal register in ybase addresing"); + + fprintf (file, "*(%d)", offset); + break; + + default: + if( FITS_5_BITS( addr ) ) + fprintf( file, "*(0x%x)", (INTVAL(addr) & 0x20) ); + else + output_addr_const(file, addr); + } + } + + void + output_dsp16xx_float_const(operands) + rtx *operands; + { + rtx dst = operands[0]; + rtx src = operands[1]; + + #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT + REAL_VALUE_TYPE d; + long value; + + REAL_VALUE_FROM_CONST_DOUBLE (d, src); + REAL_VALUE_TO_TARGET_SINGLE (d, value); + + operands[1] = gen_rtx (CONST_INT, VOIDmode, value); + output_asm_insn ("%u0=%U1\n\t%w0=%H1", operands); + #else + fatal ("inline float constants not supported on this host"); + #endif + } + + int + reg_save_size () + { + int reg_save_size = 0; + int regno; + + for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) + if (dsp16xx_call_saved_register (regno)) + { + reg_save_size += UNITS_PER_WORD; + } + + return (reg_save_size); + } + + int + dsp16xx_starting_frame_offset() + { + int reg_save_size = 0; + int regno; + + for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) + if (dsp16xx_call_saved_register (regno)) + { + reg_save_size += UNITS_PER_WORD; + } + + return (reg_save_size); + } + + int + initial_frame_pointer_offset() + { + int frame_size; + int regno; + int offset = 0; + + offset = compute_frame_size (get_frame_size()); + + #ifdef STACK_GROWS_DOWNWARD + return (offset); + #else + return (-offset); + #endif + } + + /* Generate the minimum number of 1600 core shift instructions + to shift by 'shift_amount'. */ + + #if 0 + void + emit_1600_core_shift (shift_op, operands, shift_amount, mode) + enum rtx_code shift_op; + rtx *operands; + int shift_amount; + enum machine_mode mode; + { + int quotient; + int i; + int first_shift_emitted = 0; + + while (shift_amount != 0) + { + if (shift_amount/16) + { + quotient = shift_amount/16; + shift_amount = shift_amount - (quotient * 16); + for (i = 0; i < quotient; i++) + emit_insn (gen_rtx (SET, VOIDmode, operands[0], + gen_rtx (shift_op, mode, + first_shift_emitted ? operands[0] : operands[1], + gen_rtx (CONST_INT, VOIDmode, 16)))); + first_shift_emitted = 1; + } + else if (shift_amount/8) + { + quotient = shift_amount/8; + shift_amount = shift_amount - (quotient * 8); + for (i = 0; i < quotient; i++) + emit_insn (gen_rtx (SET, VOIDmode, operands[0], + gen_rtx (shift_op, mode, + first_shift_emitted ? operands[0] : operands[1], + gen_rtx (CONST_INT, VOIDmode, 8)))); + first_shift_emitted = 1; + } + else if (shift_amount/4) + { + quotient = shift_amount/4; + shift_amount = shift_amount - (quotient * 4); + for (i = 0; i < quotient; i++) + emit_insn (gen_rtx (SET, VOIDmode, operands[0], + gen_rtx (shift_op, mode, + first_shift_emitted ? operands[0] : operands[1], + gen_rtx (CONST_INT, VOIDmode, 4)))); + first_shift_emitted = 1; + } + else if (shift_amount/1) + { + quotient = shift_amount/1; + shift_amount = shift_amount - (quotient * 1); + for (i = 0; i < quotient; i++) + emit_insn (gen_rtx (SET, VOIDmode, operands[0], + gen_rtx (shift_op, mode, + first_shift_emitted ? operands[0] : operands[1], + gen_rtx (CONST_INT, VOIDmode, 1)))); + first_shift_emitted = 1; + } + } + } + #else + void + emit_1600_core_shift (shift_op, operands, shift_amount) + enum rtx_code shift_op; + rtx *operands; + int shift_amount; + { + int quotient; + int i; + int first_shift_emitted = 0; + char **shift_asm_ptr; + char **shift_asm_ptr_first; + + if (shift_op == ASHIFT) + { + shift_asm_ptr = ashift_left_asm; + shift_asm_ptr_first = ashift_left_asm_first; + } + else if (shift_op == ASHIFTRT) + { + shift_asm_ptr = ashift_right_asm; + shift_asm_ptr_first = ashift_right_asm_first; + } + else if (shift_op == LSHIFTRT) + { + shift_asm_ptr = lshift_right_asm; + shift_asm_ptr_first = lshift_right_asm_first; + } + else + fatal ("Illegal shift operator in emit_1600_core_shift"); + + while (shift_amount != 0) + { + if (shift_amount/16) + { + quotient = shift_amount/16; + shift_amount = shift_amount - (quotient * 16); + for (i = 0; i < quotient; i++) + output_asm_insn ((first_shift_emitted ? shift_asm_ptr[SHIFT_INDEX_16] + : shift_asm_ptr_first[SHIFT_INDEX_16]), operands); + first_shift_emitted = 1; + } + else if (shift_amount/8) + { + quotient = shift_amount/8; + shift_amount = shift_amount - (quotient * 8); + for (i = 0; i < quotient; i++) + output_asm_insn ((first_shift_emitted ? shift_asm_ptr[SHIFT_INDEX_8] + : shift_asm_ptr_first[SHIFT_INDEX_8]), operands); + first_shift_emitted = 1; + } + else if (shift_amount/4) + { + quotient = shift_amount/4; + shift_amount = shift_amount - (quotient * 4); + for (i = 0; i < quotient; i++) + output_asm_insn ((first_shift_emitted ? shift_asm_ptr[SHIFT_INDEX_4] + : shift_asm_ptr_first[SHIFT_INDEX_4]), operands); + first_shift_emitted = 1; + } + else if (shift_amount/1) + { + quotient = shift_amount/1; + shift_amount = shift_amount - (quotient * 1); + for (i = 0; i < quotient; i++) + output_asm_insn ((first_shift_emitted ? shift_asm_ptr[SHIFT_INDEX_1] + : shift_asm_ptr_first[SHIFT_INDEX_1]), operands); + first_shift_emitted = 1; + } + } + } + #endif + void + asm_output_common(file, name, size, rounded) + FILE *file; + char *name; + int size; + int rounded; + { + bss_section (); + ASM_GLOBALIZE_LABEL (file, name); + assemble_name (file, name); + fputs (":", file); + if (rounded > 1) + fprintf (file, "%d * int\n", rounded); + else + fprintf (file, "int\n"); + } + + void + asm_output_local(file, name, size, rounded) + FILE *file; + char *name; + int size; + int rounded; + { + bss_section (); + assemble_name (file, name); + fputs (":", file); + if (rounded > 1) + fprintf (file, "%d * int\n", rounded); + else + fprintf (file, "int\n"); + } + + void + asm_output_float (file, fp_const) + FILE *file; + double fp_const; + { + #if HOST_FLOAT_FORMAT == TARGET_FLOAT_FORMAT + REAL_VALUE_TYPE d = fp_const; + long value; + + REAL_VALUE_TO_TARGET_SINGLE (d, value); + fputs ("\tint ", file); + #ifdef WORDS_BIG_ENDIAN + fprintf (file, "0x%-4.4x, 0x%-4.4x", (value >> 16) & 0xffff, (value & 0xffff)); + #else + fprintf (file, "0x%-4.4x, 0x%-4.4x", (value & 0xffff), (value >> 16) & 0xffff); + #endif + fputs ("\n", file); + #else + fatal ("inline float constants not supported on this host"); + #endif + } + + void + asm_output_long (file, value) + FILE *file; + long value; + { + fputs ("\tint ", file); + #ifdef WORDS_BIG_ENDIAN + fprintf (file, "0x%-4.4x, 0x%-4.4x", (value >> 16) & 0xffff, (value & 0xffff)); + #else + fprintf (file, "0x%-4.4x, 0x%-4.4x", (value & 0xffff), (value >> 16) & 0xffff); + #endif + fputs ("\n", file); + } + + int + dsp16xx_address_cost (addr) + rtx addr; + { + switch (GET_CODE (addr)) + { + default: + break; + + case REG: + return 1; + + case CONST: + { + rtx offset = const0_rtx; + addr = eliminate_constant_term (addr, &offset); + + if (GET_CODE (addr) == LABEL_REF) + return 2; + + if (GET_CODE (addr) != SYMBOL_REF) + return 4; + + if (INTVAL (offset) == 0) + return 2; + } + /* fall through */ + + case POST_INC: case POST_DEC: + return (GET_MODE (addr) == QImode ? 1 : 2); + + case SYMBOL_REF: case LABEL_REF: + return 2; + + case PLUS: + { + register rtx plus0 = XEXP (addr, 0); + register rtx plus1 = XEXP (addr, 1); + + if (GET_CODE (plus0) != REG && GET_CODE (plus1) == REG) + { + plus0 = XEXP (addr, 1); + plus1 = XEXP (addr, 0); + } + + if (GET_CODE (plus0) != REG) + break; + + switch (GET_CODE (plus1)) + { + default: + break; + + case CONST_INT: + return 4; + + case CONST: + case SYMBOL_REF: + case LABEL_REF: + return dsp16xx_address_cost (plus1) + 1; + } + } + } + + return 4; + } + + + /* Determine whether a function argument is passed in a register, and + which register. + + The arguments are CUM, which summarizes all the previous + arguments; MODE, the machine mode of the argument; TYPE, + the data type of the argument as a tree node or 0 if that is not known + (which happens for C support library functions); and NAMED, + which is 1 for an ordinary argument and 0 for nameless arguments that + correspond to `...' in the called function's prototype. + + The value of the expression should either be a `reg' RTX for the + hard register in which to pass the argument, or zero to pass the + argument on the stack. + + On the dsp1610 the first four words of args are normally in registers + and the rest are pushed. If we a long or on float mode, the argument + must begin on a even register boundary + + Note that FUNCTION_ARG and FUNCTION_INCOMING_ARG were different. + For structures that are passed in memory, but could have been + passed in registers, we first load the structure into the + register, and then when the last argument is passed, we store + the registers into the stack locations. This fixes some bugs + where GCC did not expect to have register arguments, followed */ + + + struct rtx_def * + dsp16xx_function_arg (args_so_far, mode, type, named) + CUMULATIVE_ARGS args_so_far; + enum machine_mode mode; + tree type; + int named; + { + if (TARGET_REGPARM) + { + if ((args_so_far & 1) != 0 + && (mode == HImode || GET_MODE_CLASS(mode) == MODE_FLOAT)) + args_so_far++; + + if (named && args_so_far < 4 && !MUST_PASS_IN_STACK (mode,type)) + return gen_rtx (REG, mode, args_so_far + FIRST_REG_FOR_FUNCTION_ARG); + else + return (struct rtx_def *) 0; + } + else + return (struct rtx_def *) 0; + } + + /* Advance the argument to the next argument position. */ + + void + dsp16xx_function_arg_advance (cum, mode, type, named) + CUMULATIVE_ARGS *cum; /* current arg information */ + enum machine_mode mode; /* current arg mode */ + tree type; /* type of the argument or 0 if lib support */ + int named; /* whether or not the argument was named */ + { + if (TARGET_REGPARM) + { + if ((*cum & 1) != 0 + && (mode == HImode || GET_MODE_CLASS(mode) == MODE_FLOAT)) + *cum += 1; + + if (mode != BLKmode) + *cum += GET_MODE_SIZE (mode); + else + *cum += int_size_in_bytes (type); + } + } + + void + dsp16xx_file_start () + { + fprintf (asm_out_file, "#include <%s.h>\n", save_chip_name); + #if 0 + if (TARGET_BMU) + fprintf (asm_out_file, "#include <1610.h>\n"); + #endif + } + + rtx + gen_tst_reg (x) + rtx x; + { + enum machine_mode mode; + + mode = GET_MODE (x); + + if (mode == QImode) + { + emit_insn (gen_rtx (PARALLEL, VOIDmode, + gen_rtvec (2, + gen_rtx (SET, VOIDmode, cc0_rtx, x), + gen_rtx (CLOBBER, VOIDmode, + gen_rtx (SCRATCH, QImode, 0))))); + } + else if (mode == HImode) + emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, x)); + else + fatal ("Illegal mode for gen_tst_reg"); + + return cc0_rtx; + } + + rtx + gen_compare_reg (code, x, y) + enum rtx_code code; + rtx x, y; + { + enum machine_mode mode; + + mode = GET_MODE (x); + /* For floating point compare insns, a call is generated so don't + do anything here. */ + + if (GET_MODE_CLASS (mode) == MODE_FLOAT) + return cc0_rtx; + + if (mode == QImode) + { + if (code == GTU || code == GEU || + code == LTU || code == LEU) + { + emit_insn (gen_rtx (PARALLEL, VOIDmode, + gen_rtvec (3, + gen_rtx (SET, VOIDmode, cc0_rtx, + gen_rtx (COMPARE, mode, x, y)), + gen_rtx (CLOBBER, VOIDmode, + gen_rtx (SCRATCH, QImode, 0)), + gen_rtx (CLOBBER, VOIDmode, + gen_rtx (SCRATCH, QImode, 0))))); + } + else + { + emit_insn (gen_rtx (PARALLEL, VOIDmode, + gen_rtvec (3, + gen_rtx (SET, VOIDmode, cc0_rtx, + gen_rtx (COMPARE, mode, x, y)), + gen_rtx (CLOBBER, VOIDmode, + gen_rtx (SCRATCH, QImode, 0)), + gen_rtx (CLOBBER, VOIDmode, + gen_rtx (SCRATCH, QImode, 0))))); + } + } + else if (mode == HImode) + { + if (code == GTU || code == GEU || + code == LTU || code == LEU) + { + #if 1 + emit_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (5, + gen_rtx (SET, VOIDmode, cc0_rtx, gen_rtx (COMPARE, VOIDmode, x, y)), + gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, QImode, 0)), + gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, QImode, 0)), + gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, QImode, 0)), + gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, QImode, 0))))); + #else + if (!dsp16xx_ucmphi2_libcall) + dsp16xx_ucmphi2_libcall = gen_rtx (SYMBOL_REF, Pmode, UCMPHI2_LIBCALL); + emit_library_call (dsp16xx_ucmphi2_libcall, 1, HImode, 2, + x, HImode, y, HImode); + emit_insn (gen_tsthi_1 (copy_to_reg(hard_libcall_value (HImode)))); + #endif + } + else + emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, + gen_rtx (COMPARE, VOIDmode, force_reg(HImode, x), + force_reg(HImode,y)))); + } + else + fatal ("Illegal mode for integer comparison in gen_compare_reg"); + + return cc0_rtx; + } + + char * + output_block_move (operands) + rtx operands[]; + { + int loop_count = INTVAL(operands[2]); + rtx xoperands[4]; + + fprintf (asm_out_file, "\tdo %d {\n", loop_count); + xoperands[0] = operands[4]; + xoperands[1] = operands[1]; + output_asm_insn ("%0=*%1++", xoperands); + + xoperands[0] = operands[0]; + xoperands[1] = operands[4]; + output_asm_insn ("*%0++=%1", xoperands); + + fprintf (asm_out_file, "\t}\n"); + return ""; + } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/dsp16xx/dsp16xx.h gcc-2.6.1/config/dsp16xx/dsp16xx.h *** gcc-2.6.0/config/dsp16xx/dsp16xx.h --- gcc-2.6.1/config/dsp16xx/dsp16xx.h Fri Sep 9 13:27:47 1994 *************** *** 0 **** --- 1,1988 ---- + /* Definitions of target machine for GNU compiler. AT&T DSP1600. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Michael Collison (collison@world.std.com). + + 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 1, 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. */ + + extern char *low_reg_names[]; + extern char *text_seg_name; + extern char *rsect_text; + extern char *data_seg_name; + extern char *rsect_data; + extern char *bss_seg_name; + extern char *rsect_bss; + extern char *const_seg_name; + extern char *rsect_const; + extern char *chip_name; + extern char *save_chip_name; + extern struct rtx_def *dsp16xx_compare_op0, *dsp16xx_compare_op1; + extern struct rtx_def *(*dsp16xx_compare_gen)(); + extern struct rtx_def *gen_compare_reg(); + extern struct rtx_def *dsp16xx_addhf3_libcall; + extern struct rtx_def *dsp16xx_subhf3_libcall; + extern struct rtx_def *dsp16xx_mulhf3_libcall; + extern struct rtx_def *dsp16xx_divhf3_libcall; + extern struct rtx_def *dsp16xx_cmphf3_libcall; + extern struct rtx_def *dsp16xx_fixhfhi2_libcall; + extern struct rtx_def *dsp16xx_floathihf2_libcall; + extern struct rtx_def *dsp16xx_neghf2_libcall; + extern struct rtx_def *dsp16xx_umulhi3_libcall; + extern struct rtx_def *dsp16xx_mulhi3_libcall; + extern struct rtx_def *dsp16xx_udivqi3_libcall; + extern struct rtx_def *dsp16xx_udivhi3_libcall; + extern struct rtx_def *dsp16xx_divqi3_libcall; + extern struct rtx_def *dsp16xx_divhi3_libcall; + extern struct rtx_def *dsp16xx_modqi3_libcall; + extern struct rtx_def *dsp16xx_modhi3_libcall; + extern struct rtx_def *dsp16xx_umodqi3_libcall; + extern struct rtx_def *dsp16xx_umodhi3_libcall; + + extern struct rtx_def *dsp16xx_ashrhi3_libcall; + extern struct rtx_def *dsp16xx_ashlhi3_libcall; + extern struct rtx_def *dsp16xx_lshrhi3_libcall; + + + extern int hard_regno_mode_ok (); + extern enum reg_class dsp16xx_reg_class_from_letter (); + extern enum reg_class dsp16xx_limit_reload_class (); + extern int hard_regno_nregs (); + extern int regno_reg_class (); + extern int move_operand (); + extern int symbolic_address_p (); + extern int Y_address (); + extern int call_address_operand (); + extern void notice_update_cc(); + extern void function_prologue (); + extern void function_epilogue (); + extern int dsp1600_comparison_reverse (); + extern void double_reg_from_memory (); + extern void double_reg_to_memory (); + extern void bss_section (); + extern struct rtx_def *dsp16xx_function_arg (); + extern void dsp16xx_function_arg_advance (); + extern enum rtx_code next_cc_user_code (); + extern enum rtx_code save_next_cc_user_code; + extern struct rtx_def *gen_tst_reg (); + extern char *output_block_move(); + + /* RUN-TIME TARGET SPECIFICATION */ + #define DSP16XX 1 + + /* Name of the AT&T assembler */ + + #define ASM_PROG "as1600" + + /* Name of the AT&T linker */ + + #define LD_PROG "ld1600" + + /* Define which switches take word arguments */ + #define WORD_SWITCH_TAKES_ARG(STR) \ + (!strcmp (STR, "ifile") ? 1 : \ + 0) + + #ifdef CC1_SPEC + #undef CC1_SPEC + #endif + #define CC1_SPEC "" + + /* Define this as a spec to call the AT&T assembler */ + + #define CROSS_ASM_SPEC "%{!S:as1600 %a %i\n }" + + /* Define this as a spec to call the AT&T linker */ + + #define CROSS_LINK_SPEC "%{!c:%{!M:%{!MM:%{!E:%{!S:ld1600 %l %X %{o*} %{m} \ + %{r} %{s} %{t} %{u*} %{x}\ + %{!A:%{!nostdlib:%S}} %{static:}\ + %{L*} %D %o %{!nostdlib:-le1600 %L -le1600 %{!A:%E}}\n }}}}}" + + /* Nothing complicated here, just link with libc.a under normal + circumstances */ + #define LIB_SPEC "-lc" + + /* Specify the startup file to link with. */ + #define STARTFILE_SPEC "%{mmap1:m1_crt0.o%s} \ + %{mmap2:m2_crt0.o%s} \ + %{mmap3:m3_crt0.o%s} \ + %{mmap4:m4_crt0.o%s} \ + %{!mmap*: %{!ifile*: m4_crt0.o%s} %{ifile*: \ + %eA -ifile option requires a -map option}}" + + /* Specify the end file to link with */ + + #define ENDFILE_SPEC "%{mmap1:m1_crtn.o%s} \ + %{mmap2:m2_crtn.o%s} \ + %{mmap3:m3_crtn.o%s} \ + %{mmap4:m4_crtn.o%s} \ + %{!mmap*: %{!ifile*: m4_crtn.o%s} %{ifile*: \ + %eA -ifile option requires a -map option}}" + + + /* Tell gcc where to look for the startfile */ + #define STANDARD_STARTFILE_PREFIX "/d1600/lib" + + /* Tell gcc where to look for it's executables */ + #define STANDARD_EXEC_PREFIX "/d1600/bin" + + /* Command line options to the AT&T assembler */ + #define ASM_SPEC "%{V} %{v:%{!V:-V}} %{g*:-g}" + + /* Command line options for the AT&T linker */ + #define LINK_SPEC "%{V} %{v:%{!V:-V}} %{minit:-i} \ + %{!ifile*:%{mmap1:-ifile m1_deflt.if%s} \ + %{mmap2:-ifile m2_deflt.if%s} \ + %{mmap3:-ifile m3_deflt.if%s} \ + %{mmap4:-ifile m4_deflt.if%s} \ + %{!mmap*:-ifile m4_deflt.if%s}} \ + %{ifile*} %{!r:-a}" + + /* Names to predefine in the preprocessor for this target machine. */ + #ifdef __MSDOS__ + #define CPP_PREDEFINES "-Ddsp1600 -DDSP1600 -DMSDOS" + #else + #define CPP_PREDEFINES "-Ddsp1600 -DDSP1600 -Ddsp1610 -DDSP1610" + #endif + + /* Run-time compilation parameters selecting different hardware subsets. */ + + extern int target_flags; + + /* Macros used in the machine description to test the flags. */ + + #define MASK_REGPARM 0x00000001 /* Pass parameters in registers */ + #define MASK_NEAR_CALL 0x00000002 /* The call is on the same 4k page */ + #define MASK_NEAR_JUMP 0x00000004 /* The jump is on the same 4k page */ + #define MASK_BMU 0x00000008 /* Use the 'bmu' shift instructions */ + #define MASK_OPTIMIZE_MEMORY 0x00000010 /* Optimize to conserve memory */ + #define MASK_OPTIMIZE_SPEED 0x00000020 /* Optimize for speed */ + #define MASK_MAP1 0x00000040 /* Link with map1 */ + #define MASK_MAP2 0x00000080 /* Link with map2 */ + #define MASK_MAP3 0x00000100 /* Link with map3 */ + #define MASK_MAP4 0x00000200 /* Link with map4 */ + #define MASK_YBASE_HIGH 0x00000400 /* The ybase register window starts high */ + #define MASK_INIT 0x00000800 /* Have the linker generate tables to + initialize data at startup */ + #define MASK_INLINE_MULT 0x00001000 /* Inline 32 bit multiplies */ + #define MASK_RESERVE_YBASE 0x00002000 /* Reserved the ybase registers */ + + /* Compile passing first two args in regs 0 and 1. + This exists only to test compiler features that will + be needed for RISC chips. It is not usable + and is not intended to be usable on this cpu. */ + #define TARGET_REGPARM (target_flags & MASK_REGPARM) + + /* The call is on the same 4k page, so instead of loading + the 'pt' register and branching, we can branch directly */ + + #define TARGET_NEAR_CALL (target_flags & MASK_NEAR_CALL) + + /* The jump is on the same 4k page, so instead of loading + the 'pt' register and branching, we can branch directly */ + + #define TARGET_NEAR_JUMP (target_flags & MASK_NEAR_JUMP) + + /* Generate shift instructions to use the 1610 Bit Manipulation + Unit. */ + #define TARGET_BMU (target_flags & MASK_BMU) + + /* Optimize to conseverve memory */ + #define TARGET_OPTIMIZE_MEMORY (target_flags & MASK_OPTIMIZE_MEMORY) + + /* Optimize for maximum speed */ + #define TARGET_OPTIMIZE_SPEED (target_flags & MASK_OPTIMIZE_SPEED) + + #define TARGET_YBASE_HIGH (target_flags & MASK_YBASE_HIGH) + + /* Direct the linker to output extra info for initialized data */ + #define TARGET_MASK_INIT (target_flags & MASK_INIT) + + #define TARGET_INLINE_MULT (target_flags & MASK_INLINE_MULT) + + /* Reserve the ybase registers *(0) - *(31) */ + #define TARGET_RESERVE_YBASE (target_flags & MASK_RESERVE_YBASE) + + /* Macro to define tables used to set the flags. + This is a list in braces of pairs in braces, + each pair being { "NAME", VALUE } + where VALUE is the bits to set or minus the bits to clear. + An empty string NAME is used to identify the default VALUE. */ + + + #define TARGET_SWITCHES \ + { \ + { "regparm", MASK_REGPARM}, \ + { "no-regparm", -MASK_REGPARM}, \ + { "no-near-call", -MASK_NEAR_CALL}, \ + { "near-jump", MASK_NEAR_JUMP}, \ + { "no-near-jump", -MASK_NEAR_JUMP}, \ + { "bmu", MASK_BMU}, \ + { "no-bmu", -MASK_BMU}, \ + { "Om", MASK_OPTIMIZE_MEMORY}, \ + { "Os", MASK_OPTIMIZE_SPEED}, \ + { "map1", MASK_MAP1}, \ + { "map2", MASK_MAP2}, \ + { "map3", MASK_MAP3}, \ + { "map4", MASK_MAP4}, \ + { "ybase-high", MASK_YBASE_HIGH}, \ + { "init", MASK_INIT}, \ + { "inline-mult", MASK_INLINE_MULT}, \ + { "reserve-ybase", MASK_RESERVE_YBASE}, \ + { "", TARGET_DEFAULT} \ + } + + /* Default target_flags if no switches are specified */ + #ifndef TARGET_DEFAULT + #define TARGET_DEFAULT MASK_OPTIMIZE_MEMORY|MASK_REGPARM|MASK_YBASE_HIGH + #endif + + /* This macro is similar to `TARGET_SWITCHES' but defines names of + command options that have values. Its definition is an + initializer with a subgrouping for each command option. + + Each subgrouping contains a string constant, that defines the + fixed part of the option name, and the address of a variable. + The variable, type `char *', is set to the variable part of the + given option if the fixed part matches. The actual option name + is made by appending `-m' to the specified name. + + Here is an example which defines `-mshort-data-NUMBER'. If the + given option is `-mshort-data-512', the variable `m88k_short_data' + will be set to the string `"512"'. + + extern char *m88k_short_data; + #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } } */ + + #define TARGET_OPTIONS \ + { \ + { "text=", &text_seg_name }, \ + { "data=", &data_seg_name }, \ + { "bss=", &bss_seg_name }, \ + { "const=", &const_seg_name }, \ + { "chip=", &chip_name } \ + } + + /* Sometimes certain combinations of command options do not make sense + on a particular target machine. You can define a macro + `OVERRIDE_OPTIONS' to take account of this. This macro, if + defined, is executed once just after all the command options have + been parsed. */ + + #define OVERRIDE_OPTIONS override_options () + + #define OPTIMIZATION_OPTIONS(LEVEL) \ + { \ + flag_gnu_linker = FALSE; \ + \ + if (LEVEL) \ + { \ + flag_omit_frame_pointer = TRUE; \ + flag_thread_jumps = TRUE; \ + } \ + \ + if (LEVEL >= 2) \ + { \ + flag_strength_reduce = TRUE; \ + flag_cse_follow_jumps = TRUE; \ + flag_cse_skip_blocks = TRUE; \ + flag_expensive_optimizations = TRUE; \ + flag_rerun_cse_after_loop = TRUE; \ + } \ + \ + if (LEVEL >= 3) \ + { \ + flag_inline_functions = 1; \ + } \ + } + + /* STORAGE LAYOUT */ + + /* Define if you don't want extended real, but do want to use the + software floating point emulator for REAL_ARITHMETIC and + decimal <-> binary conversion. */ + #define REAL_ARITHMETIC + + /* Define this if most significant bit is lowest numbered + in instructions that operate on numbered bit-fields. + */ + #define BITS_BIG_ENDIAN 1 + + /* Define this if most significant byte of a word is the lowest numbered. + We define big-endian, but since the 1600 series cannot address bytes + it does not matter. */ + #define BYTES_BIG_ENDIAN 1 + + /* Define this if most significant word of a multiword number is numbered. + For the 1600 we can decide arbitrarily since there are no machine instructions for them. */ + #define WORDS_BIG_ENDIAN 1 + + /* number of bits in an addressible storage unit */ + #define BITS_PER_UNIT 16 + + /* Width in bits of a "word", which is the contents of a machine register. + Note that this is not necessarily the width of data type `int'; + if using 16-bit ints on a 68000, this would still be 32. + But on a machine with 16-bit registers, this would be 16. */ + #define BITS_PER_WORD 16 + + /* Maximum number of bits in a word. */ + #define MAX_BITS_PER_WORD 16 + + /* Width of a word, in units (bytes). */ + #define UNITS_PER_WORD 1 + + /* Width in bits of a pointer. + See also the macro `Pmode' defined below. */ + #define POINTER_SIZE 16 + + /* Allocation boundary (in *bits*) for storing pointers in memory. */ + #define POINTER_BOUNDARY 16 + + /* Allocation boundary (in *bits*) for storing arguments in argument list. */ + #define PARM_BOUNDARY 16 + + /* Boundary (in *bits*) on which stack pointer should be aligned. */ + #define STACK_BOUNDARY 16 + + /* Allocation boundary (in *bits*) for the code of a function. */ + #define FUNCTION_BOUNDARY 16 + + /* Biggest alignment that any data type can require on this machine, in bits. */ + #define BIGGEST_ALIGNMENT 16 + + /* Biggest alignment that any structure field can require on this machine, in bits */ + #define BIGGEST_FIELD_ALIGNMENT 16 + + /* Alignment of field after `int : 0' in a structure. */ + #define EMPTY_FIELD_BOUNDARY 16 + + /* Number of bits which any structure or union's size must be a multiple of. Each structure + or union's size is rounded up to a multiple of this */ + #define STRUCTURE_SIZE_BOUNDARY 16 + + /* Define this if move instructions will actually fail to work + when given unaligned data. */ + #define STRICT_ALIGNMENT 1 + + /* An integer expression for the size in bits of the largest integer machine mode that + should actually be used. All integer machine modes of this size or smaller can be + used for structures and unions with the appropriate sizes. */ + #define MAX_FIXED_MODE_SIZE 32 + + /* LAYOUT OF SOURCE LANGUAGE DATA TYPES */ + + #define CHAR_TYPE_SIZE 16 + #define SHORT_TYPE_SIZE 16 + #define INT_TYPE_SIZE 16 + #define LONG_TYPE_SIZE 32 + #define LONG_LONG_TYPE_SIZE 32 + #define FLOAT_TYPE_SIZE 32 + #define DOUBLE_TYPE_SIZE 32 + #define LONG_DOUBLE_TYPE_SIZE 32 + + /* An expression whose value is 1 or 0, according to whether the type char should be + signed or unsigned by default. */ + + #define DEFAULT_SIGNED_CHAR 1 + + /* A C expression to determine whether to give an enum type only as many bytes + as it takes to represent the range of possible values of that type. A nonzero + value means to do that; a zero value means all enum types should be allocated + like int. */ + + #define DEFAULT_SHORT_ENUMS 0 + + /* A C expression for a string describing the name of the data type to use for + size values. */ + + #define SIZE_TYPE "long unsigned int" + + /* A C expression for a string describing the name of the datat type to use for the + result of subtracting two pointers */ + + #define PTRDIFF_TYPE "long int" + + #define TARGET_BELL '\a' + #define TARGET_BS '\b' + #define TARGET_TAB '\t' + #define TARGET_NEWLINE '\n' + #define TARGET_VT '\v' + #define TARGET_FF '\f' + #define TARGET_CR '\r' + + + /* REGISTER USAGE. */ + + #define ALL_16_BIT_REGISTERS 1 + + /* Number of actual hardware registers. + The hardware registers are assigned numbers for the compiler + from 0 to FIRST_PSEUDO_REGISTER-1 */ + + #define FIRST_PSEUDO_REGISTER REG_YBASE31 + 1 + + /* 1 for registers that have pervasive standard uses + and are not available for the register allocator. + + The registers are layed out as follows: + + {a0,a0l,a1,a1l,x,y,yl,p,pl} - Data Arithmetic Unit + {r0,r1,r2,r3,j,k,ybase} - Y Space Address Arithmetic Unit + {pt} - X Space Address Arithmetic Unit + {ar0,ar1,ar2,ar3} - Bit Manipulation UNit + {pr} - Return Address Register + + We reserve r2 for the Stack Pointer. + We specify r3 for the Frame Pointer but allow the compiler + to omit it when possible since we have so few pointer registers. */ + + #define REG_A0 0 + #define REG_A0L 1 + #define REG_A1 2 + #define REG_A1L 3 + #define REG_X 4 + #define REG_Y 5 + #define REG_YL 6 + #define REG_PROD 7 + #define REG_PRODL 8 + #define REG_R0 9 + #define REG_R1 10 + #define REG_R2 11 + #define REG_R3 12 + #define REG_J 13 + #define REG_K 14 + #define REG_YBASE 15 + #define REG_PT 16 + #define REG_AR0 17 + #define REG_AR1 18 + #define REG_AR2 19 + #define REG_AR3 20 + #define REG_C0 21 + #define REG_C1 22 + #define REG_C2 23 + #define REG_PR 24 + #define REG_RB 25 + #define REG_YBASE0 26 + #define REG_YBASE1 27 + #define REG_YBASE2 28 + #define REG_YBASE3 29 + #define REG_YBASE4 30 + #define REG_YBASE5 31 + #define REG_YBASE6 32 + #define REG_YBASE7 33 + #define REG_YBASE8 34 + #define REG_YBASE9 35 + #define REG_YBASE10 36 + #define REG_YBASE11 37 + #define REG_YBASE12 38 + #define REG_YBASE13 39 + #define REG_YBASE14 40 + #define REG_YBASE15 41 + #define REG_YBASE16 42 + #define REG_YBASE17 43 + #define REG_YBASE18 44 + #define REG_YBASE19 45 + #define REG_YBASE20 46 + #define REG_YBASE21 47 + #define REG_YBASE22 48 + #define REG_YBASE23 49 + #define REG_YBASE24 50 + #define REG_YBASE25 51 + #define REG_YBASE26 52 + #define REG_YBASE27 53 + #define REG_YBASE28 54 + #define REG_YBASE29 55 + #define REG_YBASE30 56 + #define REG_YBASE31 57 + + /* Do we have a accumulator register? */ + #define IS_ACCUM_REG(REGNO) ((REGNO) >= REG_A0 && (REGNO) <= REG_A1L) + #define IS_ACCUM_LOW_REG(REGNO) ((REGNO) == REG_A0L || (REGNO) == REG_A1L) + + /* Do we have a virtual ybase register */ + #define IS_YBASE_REGISTER_WINDOW(REGNO) ((REGNO) >= REG_YBASE0 && (REGNO) <= REG_YBASE31) + + #define IS_ADDRESS_REGISTER(REGNO) ((REGNO) >= REG_R0 && (REGNO) <= REG_R3) + + #define FIXED_REGISTERS \ + {0, 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 1, 0, 0, 1, \ + 1, \ + 0, 0, 0, 0, \ + 1, 1, 1, \ + 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + + /* 1 for registers not available across function calls. + These must include the FIXED_REGISTERS and also any + registers that can be used without being saved. + The latter must include the registers where values are returned + and the register where structure-value addresses are passed. + On the 1610 'a0' holds return values from functions. 'r0' holds + structure-value addresses. + + In addition we don't save either j, k, ybase or any of the + bit manipulation registers. */ + + + #define CALL_USED_REGISTERS \ + {1, 1, 1, 1, 0, 1, 1, 1, 1, \ + 1, 0, 0, 1, 1, 1, 1, \ + 1, \ + 0, 0, 1, 1, \ + 1, 1, 1, \ + 0, 1, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + + /* List the order in which to allocate registers. Each register must be + listed once, even those in FIXED_REGISTERS. + + We allocate in the following order: + */ + + #define REG_ALLOC_ORDER \ + { REG_R0, REG_R1, REG_R2, REG_PROD, REG_Y, REG_X, \ + REG_PRODL, REG_YL, REG_AR0, REG_AR1, \ + REG_RB, REG_A0, REG_A1, REG_A0L, \ + REG_A1L, REG_AR2, REG_AR3, \ + REG_YBASE, REG_J, REG_K, REG_PR, REG_PT, REG_C0, \ + REG_C1, REG_C2, REG_R3, \ + REG_YBASE0, REG_YBASE1, REG_YBASE2, REG_YBASE3, \ + REG_YBASE4, REG_YBASE5, REG_YBASE6, REG_YBASE7, \ + REG_YBASE8, REG_YBASE9, REG_YBASE10, REG_YBASE11, \ + REG_YBASE12, REG_YBASE13, REG_YBASE14, REG_YBASE15, \ + REG_YBASE16, REG_YBASE17, REG_YBASE18, REG_YBASE19, \ + REG_YBASE20, REG_YBASE21, REG_YBASE22, REG_YBASE23, \ + REG_YBASE24, REG_YBASE25, REG_YBASE26, REG_YBASE27, \ + REG_YBASE28, REG_YBASE29, REG_YBASE30, REG_YBASE31 } + + /* Zero or more C statements that may conditionally modify two + variables `fixed_regs' and `call_used_regs' (both of type `char + []') after they have been initialized from the two preceding + macros. + + This is necessary in case the fixed or call-clobbered registers + depend on target flags. + + You need not define this macro if it has no work to do. + + If the usage of an entire class of registers depends on the target + flags, you may indicate this to GCC by using this macro to modify + `fixed_regs' and `call_used_regs' to 1 for each of the registers in + the classes which should not be used by GCC. Also define the macro + `REG_CLASS_FROM_LETTER' to return `NO_REGS' if it is called with a + letter for a class that shouldn't be used. + + (However, if this class is not included in `GENERAL_REGS' and all + of the insn patterns whose constraints permit this class are + controlled by target switches, then GCC will automatically avoid + using these registers when the target switches are opposed to + them.) If the user tells us there is no BMU, we can't use + ar0-ar3 for regsiter allocation */ + + #define CONDITIONAL_REGISTER_USAGE \ + do \ + { \ + if (!TARGET_BMU) \ + { \ + int regno; \ + \ + for (regno = REG_AR0; regno <= REG_AR3; regno++) \ + fixed_regs[regno] = call_used_regs[regno] = 1; \ + } \ + if (TARGET_RESERVE_YBASE) \ + { \ + int regno; \ + \ + for (regno = REG_YBASE0; regno <= REG_YBASE31; regno++) \ + fixed_regs[regno] = call_used_regs[regno] = 1; \ + } \ + } \ + while (0) + + /* Determine which register classes are very likely used by spill registers. + local-alloc.c won't allocate pseudos that have these classes as their + preferred class unless they are "preferred or nothing". */ + + #define CLASS_LIKELY_SPILLED_P(CLASS) \ + ((CLASS) != ALL_REGS && (CLASS) != YBASE_VIRT_REGS) + + /* Return number of consecutive hard regs needed starting at reg REGNO + to hold something of mode MODE. + This is ordinarily the length in words of a value of mode MODE + but can be less for certain modes in special long registers. */ + + #define HARD_REGNO_NREGS(REGNO, MODE) \ + (GET_MODE_SIZE(MODE)) + + /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE. */ + + #define HARD_REGNO_MODE_OK(REGNO, MODE) hard_regno_mode_ok(REGNO, MODE) + + /* Value is 1 if it is a good idea to tie two pseudo registers + when one has mode MODE1 and one has mode MODE2. + If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, + for any hard reg, then this must be 0 for correct output. */ + #define MODES_TIEABLE_P(MODE1, MODE2) \ + (((MODE1) == (MODE2)) || \ + (GET_MODE_CLASS((MODE1)) == MODE_FLOAT) \ + == (GET_MODE_CLASS((MODE2)) == MODE_FLOAT)) + + /* Specify the registers used for certain standard purposes. + The values of these macros are register numbers. */ + + /* DSP1600 pc isn't overloaded on a register. */ + /* #define PC_REGNUM */ + + /* Register to use for pushing function arguments. + This is r3 in our case */ + #define STACK_POINTER_REGNUM REG_R3 + + /* Base register for access to local variables of the function. + This is r2 in our case */ + #define FRAME_POINTER_REGNUM REG_R2 + + /* We can debug without the frame pointer */ + #define CAN_DEBUG_WITHOUT_FP 1 + + /* The 1610 saves the return address in this register */ + #define RETURN_ADDRESS_REGNUM REG_PR + + /* Base register for access to arguments of the function. */ + #define ARG_POINTER_REGNUM FRAME_POINTER_REGNUM + + /* Register in which static-chain is passed to a function. */ + + #define STATIC_CHAIN_REGNUM 4 + + /* Register in which address to store a structure value + is passed to a function. This is 'r0' in our case */ + #define STRUCT_VALUE_REGNUM REG_R0 + + /* Define the classes of registers for register constraints in the + machine description. Also define ranges of constants. + + One of the classes must always be named ALL_REGS and include all hard regs. + If there is more than one class, another class must be named NO_REGS + and contain no registers. + + The name GENERAL_REGS must be the name of a class (or an alias for + another name such as ALL_REGS). This is the class of registers + that is allowed by "g" or "r" in a register constraint. + Also, registers outside this class are allocated only when + instructions express preferences for them. + + The classes must be numbered in nondecreasing order; that is, + a larger-numbered class must never be contained completely + in a smaller-numbered class. + + For any two classes, it is very desirable that there be another + class that represents their union. */ + + + enum reg_class + { + NO_REGS, + A0H_REG, + A0L_REG, + A0_REG, + A1H_REG, + ACCUM_HIGH_REGS, + A1L_REG, + ACCUM_LOW_REGS, + A1_REG, + ACCUM_REGS, + X_REG, + X_OR_ACCUM_LOW_REGS, + X_OR_ACCUM_REGS, + YH_REG, + YH_OR_ACCUM_HIGH_REGS, + X_OR_YH_REGS, + YL_REG, + YL_OR_ACCUM_LOW_REGS, + X_OR_YL_REGS, + X_OR_Y_REGS, + Y_REG, + ACCUM_OR_Y_REGS, + PH_REG, + X_OR_PH_REGS, + PL_REG, + PL_OR_ACCUM_LOW_REGS, + X_OR_PL_REGS, + YL_OR_PL_OR_ACCUM_LOW_REGS, + P_REG, + ACCUM_OR_P_REGS, + YL_OR_P_REGS, + ACCUM_LOW_OR_YL_OR_P_REGS, + Y_OR_P_REGS, + ACCUM_Y_OR_P_REGS, + NO_FRAME_Y_ADDR_REGS, + Y_ADDR_REGS, + ACCUM_LOW_OR_Y_ADDR_REGS, + ACCUM_OR_Y_ADDR_REGS, + X_OR_Y_ADDR_REGS, + Y_OR_Y_ADDR_REGS, + P_OR_Y_ADDR_REGS, + NON_HIGH_YBASE_ELIGIBLE_REGS, + YBASE_ELIGIBLE_REGS, + J_REG, + J_OR_DAU_16_BIT_REGS, + BMU_REGS, + NOHIGH_NON_ADDR_REGS, + NON_ADDR_REGS, + SLOW_MEM_LOAD_REGS, + NOHIGH_NON_YBASE_REGS, + NO_ACCUM_NON_YBASE_REGS, + NON_YBASE_REGS, + YBASE_VIRT_REGS, + ACCUM_LOW_OR_YBASE_REGS, + ACCUM_OR_YBASE_REGS, + X_OR_YBASE_REGS, + Y_OR_YBASE_REGS, + ACCUM_LOW_YL_PL_OR_YBASE_REGS, + P_OR_YBASE_REGS, + ACCUM_Y_P_OR_YBASE_REGS, + Y_ADDR_OR_YBASE_REGS, + YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS, + YBASE_OR_YBASE_ELIGIBLE_REGS, + NO_HIGH_ALL_REGS, + ALL_REGS, + LIM_REG_CLASSES + }; + + /* GENERAL_REGS must be the name of a register class */ + #define GENERAL_REGS ALL_REGS + + #define N_REG_CLASSES (int) LIM_REG_CLASSES + + /* Give names of register classes as strings for dump file. */ + + #define REG_CLASS_NAMES \ + { \ + "NO_REGS", \ + "A0H_REG", \ + "A0L_REG", \ + "A0_REG", \ + "A1H_REG", \ + "ACCUM_HIGH_REGS", \ + "A1L_REG", \ + "ACCUM_LOW_REGS", \ + "A1_REG", \ + "ACCUM_REGS", \ + "X_REG", \ + "X_OR_ACCUM_LOW_REGS", \ + "X_OR_ACCUM_REGS", \ + "YH_REG", \ + "YH_OR_ACCUM_HIGH_REGS", \ + "X_OR_YH_REGS", \ + "YL_REG", \ + "YL_OR_ACCUM_LOW_REGS", \ + "X_OR_YL_REGS", \ + "X_OR_Y_REGS", \ + "Y_REG", \ + "ACCUM_OR_Y_REGS", \ + "PH_REG", \ + "X_OR_PH_REGS", \ + "PL_REG", \ + "PL_OR_ACCUM_LOW_REGS", \ + "X_OR_PL_REGS", \ + "PL_OR_YL_OR_ACCUM_LOW_REGS", \ + "P_REG", \ + "ACCUM_OR_P_REGS", \ + "YL_OR_P_REGS", \ + "ACCUM_LOW_OR_YL_OR_P_REGS", \ + "Y_OR_P_REGS", \ + "ACCUM_Y_OR_P_REGS", \ + "NO_FRAME_Y_ADDR_REGS", \ + "Y_ADDR_REGS", \ + "ACCUM_LOW_OR_Y_ADDR_REGS", \ + "ACCUM_OR_Y_ADDR_REGS", \ + "X_OR_Y_ADDR_REGS", \ + "Y_OR_Y_ADDR_REGS", \ + "P_OR_Y_ADDR_REGS", \ + "NON_HIGH_YBASE_ELIGIBLE_REGS", \ + "YBASE_ELIGIBLE_REGS", \ + "J_REG", \ + "J_OR_DAU_16_BIT_REGS", \ + "BMU_REGS", \ + "NOHIGH_NON_ADDR_REGS", \ + "NON_ADDR_REGS", \ + "SLOW_MEM_LOAD_REGS", \ + "NOHIGH_NON_YBASE_REGS", \ + "NO_ACCUM_NON_YBASE_REGS", \ + "NON_YBASE_REGS", \ + "YBASE_VIRT_REGS", \ + "ACCUM_LOW_OR_YBASE_REGS", \ + "ACCUM_OR_YBASE_REGS", \ + "X_OR_YBASE_REGS", \ + "Y_OR_YBASE_REGS", \ + "ACCUM_LOW_YL_PL_OR_YBASE_REGS", \ + "P_OR_YBASE_REGS", \ + "ACCUM_Y_P_OR_YBASE_REGS", \ + "Y_ADDR_OR_YBASE_REGS", \ + "YBASE_OR_NOHIGH_YBASE_ELIGIBLE_REGS", \ + "YBASE_OR_YBASE_ELIGIBLE_REGS", \ + "NO_HIGH_ALL_REGS", \ + "ALL_REGS" \ + } + + /* Define which registers fit in which classes. + This is an initializer for a vector of HARD_REG_SET + of length N_REG_CLASSES. */ + + #define REG_CLASS_CONTENTS \ + { \ + {0x00000000, 0x00000000}, /* no reg */ \ + {0x00000001, 0x00000000}, /* a0h */ \ + {0x00000002, 0x00000000}, /* a0l */ \ + {0x00000003, 0x00000000}, /* a0h:a0l */ \ + {0x00000004, 0x00000000}, /* a1h */ \ + {0x00000005, 0x00000000}, /* accum high */ \ + {0x00000008, 0x00000000}, /* a1l */ \ + {0x0000000A, 0x00000000}, /* accum low */ \ + {0x0000000c, 0x00000000}, /* a1h:a1l */ \ + {0x0000000f, 0x00000000}, /* accum regs */ \ + {0x00000010, 0x00000000}, /* x reg */ \ + {0x0000001A, 0x00000000}, /* x & accum_low_regs */ \ + {0x0000001f, 0x00000000}, /* x & accum regs */ \ + {0x00000020, 0x00000000}, /* y high */ \ + {0x00000025, 0x00000000}, /* yh, accum high */ \ + {0x00000030, 0x00000000}, /* x & yh */ \ + {0x00000040, 0x00000000}, /* y low */ \ + {0x0000004A, 0x00000000}, /* y low, accum_low */ \ + {0x00000050, 0x00000000}, /* x & yl */ \ + {0x00000060, 0x00000000}, /* yl:yh */ \ + {0x00000070, 0x00000000}, /* x, yh,a nd yl */ \ + {0x0000006F, 0x00000000}, /* accum, y */ \ + {0x00000080, 0x00000000}, /* p high */ \ + {0x00000090, 0x00000000}, /* x & ph */ \ + {0x00000100, 0x00000000}, /* p low */ \ + {0x0000010A, 0x00000000}, /* p_low and accum_low */ \ + {0x00000110, 0x00000000}, /* x & pl */ \ + {0x0000014A, 0x00000000}, /* pl,yl,a1l,a0l */ \ + {0x00000180, 0x00000000}, /* pl:ph */ \ + {0x0000018F, 0x00000000}, /* accum, p */ \ + {0x000001C0, 0x00000000}, /* pl:ph and yl */ \ + {0x000001CA, 0x00000000}, /* pl:ph, yl, a0l, a1l */ \ + {0x000001E0, 0x00000000}, /* y or p */ \ + {0x000001EF, 0x00000000}, /* accum, y or p */ \ + {0x00000E00, 0x00000000}, /* r0-r2 */ \ + {0x00001E00, 0x00000000}, /* r0-r3 */ \ + {0x00001E0A, 0x00000000}, /* r0-r3, accum_low */ \ + {0x00001E0F, 0x00000000}, /* accum,r0-r3 */ \ + {0x00001E10, 0x00000000}, /* x,r0-r3 */ \ + {0x00001E60, 0x00000000}, /* y,r0-r3 */ \ + {0x00001F80, 0x00000000}, /* p,r0-r3 */ \ + {0x00001FDA, 0x00000000}, /* ph:pl, r0-r3, x,a0l,a1l */ \ + {0x00001fff, 0x00000000}, /* accum,x,y,p,r0-r3 */ \ + {0x00002000, 0x00000000}, /* j */ \ + {0x00002025, 0x00000000}, /* j, yh, a1h, a0h */ \ + {0x001E0000, 0x00000000}, /* ar0-ar3 */ \ + {0x03FFE1DA, 0x00000000}, /* non_addr except yh,a0h,a1h */ \ + {0x03FFE1FF, 0x00000000}, /* non_addr regs */ \ + {0x03FFFF8F, 0x00000000}, /* non ybase except yh, yl, and x */ \ + {0x03FFFFDA, 0x00000000}, /* non ybase regs except yh,a0h,a1h */ \ + {0x03FFFFF0, 0x00000000}, /* non ybase except a0,a0l,a1,a1l */ \ + {0x03FFFFFF, 0x00000000}, /* non ybase regs */ \ + {0xFC000000, 0x03FFFFFF}, /* virt ybase regs */ \ + {0xFC00000A, 0x03FFFFFF}, /* accum_low, virt ybase regs */ \ + {0xFC00000F, 0x03FFFFFF}, /* accum, virt ybase regs */ \ + {0xFC000010, 0x03FFFFFF}, /* x,virt ybase regs */ \ + {0xFC000060, 0x03FFFFFF}, /* y,virt ybase regs */ \ + {0xFC00014A, 0x03FFFFFF}, /* accum_low, yl, pl, ybase */ \ + {0xFC000180, 0x03FFFFFF}, /* p,virt ybase regs */ \ + {0xFC0001EF, 0x03FFFFFF}, /* accum,y,p,ybase regs */ \ + {0xFC001E00, 0x03FFFFFF}, /* r0-r3, ybase regs */ \ + {0xFC001FDA, 0x03FFFFFF}, /* r0-r3, pl:ph,yl,x,a1l,a0l */ \ + {0xFC001FFF, 0x03FFFFFF}, /* virt ybase, ybase eligible regs */ \ + {0xFCFFFFDA, 0x03FFFFFF}, /* all regs except yh,a0h,a1h */ \ + {0xFFFFFFFF, 0x03FFFFFF} /* all regs */ \ + } + + + /* The same information, inverted: + Return the class number of the smallest class containing + reg number REGNO. This could be a conditional expression + or could index an array. */ + + #define REGNO_REG_CLASS(REGNO) regno_reg_class(REGNO) + + /* The class value for index registers, and the one for base regs. */ + + #define INDEX_REG_CLASS NO_REGS + #define BASE_REG_CLASS Y_ADDR_REGS + + /* Get reg_class from a letter such as appears in the machine description. */ + + #define REG_CLASS_FROM_LETTER(C) \ + dsp16xx_reg_class_from_letter(C) + + #define SECONDARY_RELOAD_CLASS(CLASS, MODE, X) \ + secondary_reload_class(CLASS, MODE, X) + + /* When defined, the compiler allows registers explicitly used in the + rtl to be used as spill registers but prevents the compiler from + extending the lifetime of these registers. */ + + #define SMALL_REGISTER_CLASSES + + /* Macros to check register numbers against specific register classes. */ + + /* These assume that REGNO is a hard or pseudo reg number. + They give nonzero only if REGNO is a hard reg of the suitable class + or a pseudo reg currently allocated to a suitable hard reg. + Since they use reg_renumber, they are safe only once reg_renumber + has been allocated, which happens in local-alloc.c. */ + + /* A C expression which is nonzero if register REGNO is suitable for use + as a base register in operand addresses. It may be either a suitable + hard register or a pseudo register that has been allocated such a + hard register. + + On the 1610 the Y address pointers can be used as a base registers */ + #define REGNO_OK_FOR_BASE_P(REGNO) \ + (((REGNO) >= REG_R0 && (REGNO) < REG_R3 + 1) || ((unsigned) reg_renumber[REGNO] >= REG_R0 \ + && (unsigned) reg_renumber[REGNO] < REG_R3 + 1)) + + #define REGNO_OK_FOR_YBASE_P(REGNO) \ + (((REGNO) == REG_YBASE) || ((unsigned) reg_renumber[REGNO] == REG_YBASE)) + + #define REGNO_OK_FOR_INDEX_P(REGNO) 0 + + #ifdef ALL_16_BIT_REGISTERS + #define IS_32_BIT_REG(REGNO) 0 + #else + #define IS_32_BIT_REG(REGNO) \ + ((REGNO) == REG_A0 || (REGNO) == REG_A1 || (REGNO) == REG_Y || (REGNO) == REG_PROD) + #endif + + /* Given an rtx X being reloaded into a reg required to be + in class CLASS, return the class of reg to actually use. + In general this is just CLASS; but on some machines + in some cases it is preferable to use a more restrictive class. + Also, we must ensure that a PLUS is reloaded either + into an accumulator or an address register. */ + + #define PREFERRED_RELOAD_CLASS(X,CLASS) preferred_reload_class (X, CLASS) + + /* A C expression that places additional restrictions on the register + class to use when it is necessary to be able to hold a value of + mode MODE in a reload register for which class CLASS would + ordinarily be used. + + Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when + there are certain modes that simply can't go in certain reload + classes. + + The value is a register class; perhaps CLASS, or perhaps another, + smaller class. + + Don't define this macro unless the target machine has limitations + which require the macro to do something nontrivial. */ + + #if 0 + #define LIMIT_RELOAD_CLASS(MODE, CLASS) dsp16xx_limit_reload_class (MODE, CLASS) + #endif + + /* A C expression for the maximum number of consecutive registers of class CLASS + needed to hold a vlaue of mode MODE */ + #define CLASS_MAX_NREGS(CLASS, MODE) \ + class_max_nregs(CLASS, MODE) + + /* The letters 'I' through 'P' in a register constraint string + can be used to stand for particular ranges of immediate operands. + This macro defines what the ranges are. + C is the letter, and VALUE is a constant value. + Return 1 if VALUE is in the range specified by C. + + For the 16xx, the following constraints are used: + 'I' requires a non-negative 16-bit value. + 'J' requires a non-negative 9-bit value + 'K' requires a constant 0 operand. + 'L' requires 16-bit value + 'M' 32-bit value -- low 16-bits zero + */ + + #define SMALL_INT(X) (SMALL_INTVAL (INTVAL (X))) + #define SMALL_INTVAL(I) ((unsigned) (I) < 0x10000) + #define SHORT_IMMEDIATE(X) (SHORT_INTVAL (INTVAL(X))) + #define SHORT_INTVAL(I) ((unsigned) (I) < 0x100) + + #define CONST_OK_FOR_LETTER_P(VALUE, C) \ + ((C) == 'I' ? (SMALL_INTVAL(VALUE)) \ + : (C) == 'J' ? (SHORT_INTVAL(VALUE)) \ + : (C) == 'K' ? ((VALUE) == 0) \ + : (C) == 'L' ? ! ((VALUE) & ~0x0000ffff) \ + : (C) == 'M' ? ! ((VALUE) & ~0xffff0000) \ + : (C) == 'N' ? ((VALUE) == -1 || (VALUE) == 1 || \ + (VALUE) == -2 || (VALUE) == 2) \ + : 0) + + #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) 1 + + /* Optional extra constraints for this machine */ + #define EXTRA_CONSTRAINT(OP,C) \ + ((C) == 'R' ? symbolic_address_p (OP) \ + : 0) + + /* DESCRIBING STACK LAYOUT AND CALLING CONVENTIONS */ + + /* Define this if pushing a word on the stack + makes the stack pointer a smaller address. */ + /* #define STACK_GROWS_DOWNWARD */ + + /* Define this if the nominal address of the stack frame + is at the high-address end of the local variables; + that is, each additional local variable allocated + goes at a more negative offset in the frame. */ + /* #define FRAME_GROWS_DOWNWARD */ + + #define ARGS_GROW_DOWNWARD + + /* We use post decrement on the 1600 because there isn't + a pre-decrement addressing mode. This means that we + assume the stack pointer always points at the next + FREE location on the stack. */ + #define STACK_PUSH_CODE POST_INC + + /* Offset within stack frame to start allocating local variables at. + If FRAME_GROWS_DOWNWARD, this is the offset to the END of the + first local allocated. Otherwise, it is the offset to the BEGINNING + of the first local allocated. */ + #define STARTING_FRAME_OFFSET 0 + + /* Offset from the stack pointer register to the first + location at which outgoing arguments are placed. */ + #define STACK_POINTER_OFFSET (0) + + struct dsp16xx_frame_info + { + unsigned long total_size; /* # bytes that the entire frame takes up */ + unsigned long var_size; /* # bytes that variables take up */ + unsigned long args_size; /* # bytes that outgoing arguments take up */ + unsigned long extra_size; /* # bytes of extra gunk */ + unsigned int reg_size; /* # bytes needed to store regs */ + long fp_save_offset; /* offset from vfp to store registers */ + unsigned long sp_save_offset; /* offset from new sp to store registers */ + int initialized; /* != 0 if frame size already calculated */ + int num_regs; /* number of registers saved */ + int function_makes_calls; /* Does the function make calls */ + }; + + extern struct dsp16xx_frame_info current_frame_info; + + /* If we generate an insn to push BYTES bytes, + this says how many the stack pointer really advances by. */ + /* #define PUSH_ROUNDING(BYTES) ((BYTES)) */ + + /* If defined, the maximum amount of space required for outgoing + arguments will be computed and placed into the variable + 'current_function_outgoing_args_size'. No space will be pushed + onto the stack for each call; instead, the function prologue should + increase the stack frame size by this amount. + + It is not proper to define both 'PUSH_ROUNDING' and + 'ACCUMULATE_OUTGOING_ARGS'. */ + #define ACCUMULATE_OUTGOING_ARGS + + /* Offset of first parameter from the argument pointer + register value. */ + + #define FIRST_PARM_OFFSET(FNDECL) (0) + + /* Value is 1 if returning from a function call automatically + pops the arguments described by the number-of-args field in the call. + FUNTYPE is the data type of the function (as a tree), + or for a library call it is an identifier node for the subroutine name. */ + + #define RETURN_POPS_ARGS(FUNTYPE, STACK_SIZE) 0 + + /* Define how to find the value returned by a function. + VALTYPE is the data type of the value (as a tree). + If the precise function being called is known, FUNC is its FUNCTION_DECL; + otherwise, FUNC is 0. On the 1610 all function return their values + in a0 (i.e. the upper 16 bits). If the return value is 32-bits the + entire register is significant. */ + + #define VALUE_REGNO(MODE) (REG_Y) + + #define FUNCTION_VALUE(VALTYPE, FUNC) \ + gen_rtx (REG, TYPE_MODE (VALTYPE), VALUE_REGNO(TYPE_MODE(VALTYPE))) + + /* Define how to find the value returned by a library function + assuming the value has mode MODE. */ + #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, VALUE_REGNO(MODE)) + + /* 1 if N is a possible register number for a function value. */ + #define FUNCTION_VALUE_REGNO_P(N) ((N) == REG_Y) + + + /* Define where to put the arguments to a function. + Value is zero to push the argument on the stack, + or a hard register in which to store the argument. + + MODE is the argument's machine mode. + TYPE is the data type of the argument (as a tree). + This is null for libcalls where that information may + not be available. + CUM is a variable of type CUMULATIVE_ARGS which gives info about + the preceding args and about the function being called. + NAMED is nonzero if this argument is a named parameter + (otherwise it is an extra parameter matching an ellipsis). */ + + /* On the 1610 all args are pushed, except if -mregparm is specified + then the first two words of arguments are passed in a0, a1. */ + #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ + dsp16xx_function_arg (CUM, MODE, TYPE, NAMED) + + /* Define the first register to be used for argument passing */ + #define FIRST_REG_FOR_FUNCTION_ARG REG_Y + + /* Define the profitablity of saving registers around calls. + NOTE: For now we turin this off because of a bug in the + caller-saves code and also because i'm not sure it is helpful + on the 1610. */ + + #define CALLER_SAVE_PROFITABLE(REFS,CALLS) 0 + + /* This indicates that an argument is to be passed with an invisible reference + (i.e., a pointer to the object is passed). + + On the dsp16xx, we do this if it must be passed on the stack. */ + + #define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \ + (MUST_PASS_IN_STACK (MODE, TYPE)) + + /* For an arg passed partly in registers and partly in memory, + this is the number of registers used. + For args passed entirely in registers or entirely in memory, zero. */ + + #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) (0) + + /* Define a data type for recording info about an argument list + during the scan of that argument list. This data type should + hold all necessary information about the function itself + and about the args processed so far, enough to enable macros + such as FUNCTION_ARG to determine where the next arg should go. */ + #define CUMULATIVE_ARGS int + + /* Initialize a variable CUM of type CUMULATIVE_ARGS + for a call to a function whose data type is FNTYPE. + For a library call, FNTYPE is 0. */ + #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) ((CUM) = 0) + + /* Update the data in CUM to advance over an argument + of mode MODE and data type TYPE. + (TYPE is null for libcalls where that information may not be available.) */ + + #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ + dsp16xx_function_arg_advance (&CUM, MODE,TYPE, NAMED) + + /* 1 if N is a possible register number for function argument passing. */ + #define FUNCTION_ARG_REGNO_P(N) \ + ((N) == REG_Y || (N) == REG_YL || (N) == REG_PROD || (N) == REG_PRODL) + + /* This macro generates the assembly code for function entry. + FILE is a stdio stream to output the code to. + SIZE is an int: how many units of temporary storage to allocate. + Refer to the array `regs_ever_live' to determine which registers + to save; `regs_ever_live[I]' is nonzero if register number I + is ever used in the function. This macro is responsible for + knowing which registers should not be saved even if used. */ + + #define FUNCTION_PROLOGUE(FILE, SIZE) function_prologue(FILE, SIZE) + + /* Output assembler code to FILE to increment profiler label # LABELNO + for profiling a function entry. */ + + #define FUNCTION_PROFILER(FILE, LABELNO) fatal("Profiling not implemented yet.") + + /* Output assembler code to FILE to initialize this source file's + basic block profiling info, if that has not already been done. */ + #define FUNCTION_BLOCK_PROFILER(FILE, LABELNO) fatal("Profiling not implemented yet.") + + /* Output assembler code to FILE to increment the entry-count for + the BLOCKNO'th basic block in this source file. */ + #define BLOCK_PROFILER(FILE, BLOCKNO) fatal("Profiling not implemented yet.") + + + /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, + the stack pointer does not matter. The value is tested only in + functions that have frame pointers. + No definition is equivalent to always zero. */ + + #define EXIT_IGNORE_STACK (0) + + #define TRAMPOLINE_TEMPLATE(FILE) fatal ("Trampolines not yet implemented"); + + /* Length in units of the trampoline for entering a nested function. + This is a dummy value */ + + #define TRAMPOLINE_SIZE 20 + + /* Emit RTL insns to initialize the variable parts of a trampoline. + FNADDR is an RTX for the address of the function's pure code. + CXT is an RTX for the static chain value for the function. */ + + #define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \ + fatal ("Trampolines not yet implemented"); + + /* This macro generates the assembly code for function exit, + on machines that need it. If FUNCTION_EPILOGUE is not defined + then individual return instructions are generated for each + return statement. Args are same as for FUNCTION_PROLOGUE. + + The function epilogue should not depend on the current stack pointer! + It should use the frame pointer only. This is mandatory because + of alloca; we also take advantage of it to omit stack adjustments + before returning. */ + + #define FUNCTION_EPILOGUE(FILE, SIZE) function_epilogue(FILE, SIZE) + + /* A C expression which is nonzero if a function must have and use a + frame pointer. If its value is nonzero the functions will have a + frame pointer. */ + #define FRAME_POINTER_REQUIRED (current_function_calls_alloca) + + /* A C statement to store in the variable 'DEPTH' the difference + between the frame pointer and the stack pointer values immediately + after the function prologue. */ + #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) \ + { (DEPTH) = initial_frame_pointer_offset(); \ + } + + /* IMPLICIT CALLS TO LIBRARY ROUTINES */ + + #define ADDHF3_LIBCALL "__Emulate_addhf3" + #define SUBHF3_LIBCALL "__Emulate_subhf3" + #define MULHF3_LIBCALL "__Emulate_mulhf3" + #define DIVHF3_LIBCALL "__Emulate_divhf3" + #define CMPHF3_LIBCALL "__Emulate_cmphf3" + #define FIXHFHI2_LIBCALL "__Emulate_fixhfhi2" + #define FLOATHIHF2_LIBCALL "__Emulate_floathihf2" + #define NEGHF2_LIBCALL "__Emulate_neghf2" + + #define UMULHI3_LIBCALL "__Emulate_umulhi3" + #define MULHI3_LIBCALL "__Emulate_mulhi3" + #define UDIVQI3_LIBCALL "__Emulate_udivqi3" + #define UDIVHI3_LIBCALL "__Emulate_udivhi3" + #define DIVQI3_LIBCALL "__Emulate_divqi3" + #define DIVHI3_LIBCALL "__Emulate_divhi3" + #define MODQI3_LIBCALL "__Emulate_modqi3" + #define MODHI3_LIBCALL "__Emulate_modhi3" + #define UMODQI3_LIBCALL "__Emulate_umodqi3" + #define UMODHI3_LIBCALL "__Emulate_umodhi3" + #define ASHRHI3_LIBCALL "__Emulate_ashrhi3" + #define LSHRHI3_LIBCALL "__Emulate_lshrhi3" + #define ASHLHI3_LIBCALL "__Emulate_ashlhi3" + #define LSHLHI3_LIBCALL "__Emulate_lshlhi3" /* NOT USED */ + + /* Define this macro if calls to the ANSI C library functions memcpy and + memset should be generated instead of the BSD function bcopy & bzero. */ + #define TARGET_MEM_FUNCTIONS + + + /* ADDRESSING MODES */ + + /* The 1610 has post-increment and decrement, but no pre-modify */ + #define HAVE_POST_INCREMENT + #define HAVE_POST_DECREMENT + + /* #define HAVE_PRE_DECREMENT */ + /* #define HAVE_PRE_INCREMENT */ + + /* Recognize any constant value that is a valid address. */ + #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X) + + /* Maximum number of registers that can appear in a valid memory address. */ + #define MAX_REGS_PER_ADDRESS 1 + + /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx + and check its validity for a certain class. + We have two alternate definitions for each of them. + The usual definition accepts all pseudo regs; the other rejects + them unless they have been allocated suitable hard regs. + The symbol REG_OK_STRICT causes the latter definition to be used. + + Most source files want to accept pseudo regs in the hope that + they will get allocated to the class that the insn wants them to be in. + Source files for reload pass need to be strict. + After reload, it makes no difference, since pseudo regs have + been eliminated by then. */ + + #ifndef REG_OK_STRICT + + /* Nonzero if X is a hard reg that can be used as an index + or if it is a pseudo reg. */ + #define REG_OK_FOR_INDEX_P(X) 0 + + /* Nonzero if X is a hard reg that can be used as a base reg + or if it is a pseudo reg. */ + #define REG_OK_FOR_BASE_P(X) \ + ((REGNO (X) >= REG_R0 && REGNO (X) < REG_R3 + 1 ) \ + || (REGNO (X) >= FIRST_PSEUDO_REGISTER)) + + /* Nonzero if X is the 'ybase' register */ + #define REG_OK_FOR_YBASE_P(X) \ + (REGNO(X) == REG_YBASE || (REGNO (X) >= FIRST_PSEUDO_REGISTER)) + #else + + /* Nonzero if X is a hard reg that can be used as an index. */ + #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) + + /* Nonzero if X is a hard reg that can be used as a base reg. */ + #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) + + /* Nonzero if X is the 'ybase' register */ + #define REG_OK_FOR_YBASE_P(X) REGNO_OK_FOR_YBASE_P (REGNO(X)) + + #endif + + /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression + that is a valid memory address for an instruction. + The MODE argument is the machine mode for the MEM expression + that wants to use this address. + + On the 1610, the actual legitimate addresses must be N (N must fit in + 5 bits), *rn (register indirect), *rn++, or *rn-- */ + + #define INT_FITS_5_BITS(I) ((unsigned long) (I) < 0x20) + #define INT_FITS_16_BITS(I) ((unsigned long) (I) < 0x10000) + #define YBASE_CONST_OFFSET(I) ((I) >= -31 && (I) <= 0) + #define YBASE_OFFSET(X) (GET_CODE (X) == CONST_INT && YBASE_CONST_OFFSET (INTVAL(X))) + + #define FITS_16_BITS(X) (GET_CODE (X) == CONST_INT && INT_FITS_16_BITS(INTVAL(X))) + #define FITS_5_BITS(X) (GET_CODE (X) == CONST_INT && INT_FITS_5_BITS(INTVAL(X))) + #define ILLEGAL_HIMODE_ADDR(MODE, CONST) ((MODE) == HImode && CONST == -31) + + #define INDIRECTABLE_ADDRESS_P(X) \ + ((GET_CODE(X) == REG && REG_OK_FOR_BASE_P(X)) \ + || ((GET_CODE(X) == POST_DEC || GET_CODE(X) == POST_INC) \ + && REG_P(XEXP(X,0)) && REG_OK_FOR_BASE_P(XEXP(X,0))) \ + || (GET_CODE(X) == CONST_INT && (unsigned long) (X) < 0x20)) + + + #define INDEXABLE_ADDRESS_P(X,MODE) \ + ((GET_CODE(X) == PLUS && GET_CODE (XEXP (X,0)) == REG && \ + XEXP(X,0) == stack_pointer_rtx && YBASE_OFFSET(XEXP(X,1)) && \ + !ILLEGAL_HIMODE_ADDR(MODE, INTVAL(XEXP(X,1)))) || \ + (GET_CODE(X) == PLUS && GET_CODE (XEXP (X,1)) == REG && \ + XEXP(X,1) == stack_pointer_rtx && YBASE_OFFSET(XEXP(X,0)) && \ + !ILLEGAL_HIMODE_ADDR(MODE, INTVAL(XEXP(X,0))))) + + #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ + { \ + if (INDIRECTABLE_ADDRESS_P(X)) \ + goto ADDR; \ + } + + + /* Try machine-dependent ways of modifying an illegitimate address + to be legitimate. If we find one, return the new, valid address. + This macro is used in only one place: `memory_address' in explow.c. + + OLDX is the address as it was before break_out_memory_refs was called. + In some cases it is useful to look at this to decide what needs to be done. + + MODE and WIN are passed so that this macro can use + GO_IF_LEGITIMATE_ADDRESS. + + It is always safe for this macro to do nothing. It exists to recognize + opportunities to optimize the output. + + For the 1610, we need not do anything. However, if we don't, + `memory_address' will try lots of things to get a valid address, most of + which will result in dead code and extra pseudos. So we make the address + valid here. + + This is easy: The only valid addresses are an offset from a register + and we know the address isn't valid. So just call either `force_operand' + or `force_reg' unless this is a (plus (reg ...) (const_int 0)). */ + + #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \ + { if (GET_CODE (X) == PLUS && XEXP (X, 1) == const0_rtx) \ + X = XEXP (x, 0); \ + if (GET_CODE (X) == MULT || GET_CODE (X) == PLUS) \ + X = force_operand (X, 0); \ + else \ + X = force_reg (Pmode, X); \ + goto WIN; \ + } + + /* Go to LABEL if ADDR (a legitimate address expression) + has an effect that depends on the machine mode it is used for. + On the 1610, only postdecrement and postincrement address depend thus + (the amount of decrement or increment being the length of the operand). */ + + #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ + if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == POST_DEC) goto LABEL + + /* Nonzero if the constant value X is a legitimate general operand. + It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ + #define LEGITIMATE_CONSTANT_P(X) (1) + + + /* CONDITION CODE INFORMATION */ + + /* Store in cc_status the expressions + that the condition codes will describe + after execution of an instruction whose pattern is EXP. + Do not alter them if the instruction would not alter the cc's. */ + + #define NOTICE_UPDATE_CC(EXP, INSN) \ + notice_update_cc( (EXP) ) + + /* DESCRIBING RELATIVE COSTS OF OPERATIONS */ + + /* Compute the cost of computing a constant rtl expression RTX + whose rtx-code is CODE. The body of this macro is a portion + of a switch statement. If the code is computed here, + return it with a return statement. */ + #define CONST_COSTS(RTX,CODE,OUTER_CODE) \ + case CONST_INT: \ + return 0; \ + case LABEL_REF: \ + case SYMBOL_REF: \ + case CONST: \ + return COSTS_N_INSNS (1); \ + \ + case CONST_DOUBLE: \ + return COSTS_N_INSNS (2); + + /* Like CONST_COSTS but applies to nonsonstant RTL expressions. + This can be used, for example to indicate how costly a multiply + instruction is. */ + #define RTX_COSTS(X,CODE,OUTER_CODE) \ + case MEM: \ + return GET_MODE (X) == QImode ? COSTS_N_INSNS (2) : \ + COSTS_N_INSNS (4); \ + case DIV: \ + case MOD: \ + return COSTS_N_INSNS (38); \ + case MULT: \ + if (GET_MODE (X) == QImode) \ + return COSTS_N_INSNS (2); \ + else \ + return COSTS_N_INSNS (38); \ + case PLUS: \ + if (GET_MODE_CLASS (GET_MODE (X)) == MODE_INT) \ + { \ + if (GET_CODE (XEXP (X,1)) == CONST_INT) \ + { \ + int number = INTVAL(XEXP (X,1)); \ + if (number == 1) \ + return COSTS_N_INSNS (1); \ + if (INT_FITS_16_BITS(number)) \ + return COSTS_N_INSNS (2); \ + else \ + return COSTS_N_INSNS (4); \ + } \ + return COSTS_N_INSNS (1); \ + } \ + else \ + return COSTS_N_INSNS (38); \ + case MINUS: \ + if (GET_MODE_CLASS (GET_MODE (X)) == MODE_INT) \ + { \ + if (GET_CODE (XEXP (X,1)) == CONST_INT) \ + { \ + if (INT_FITS_16_BITS(INTVAL(XEXP(X,1)))) \ + return COSTS_N_INSNS (2); \ + else \ + return COSTS_N_INSNS (4); \ + } \ + return COSTS_N_INSNS (1); \ + } \ + else \ + return COSTS_N_INSNS (38); \ + case AND: case IOR: case XOR: \ + if (GET_CODE (XEXP (X,1)) == CONST_INT) \ + { \ + if (INT_FITS_16_BITS(INTVAL(XEXP(X,1)))) \ + return COSTS_N_INSNS (2); \ + else \ + return COSTS_N_INSNS (4); \ + } \ + return COSTS_N_INSNS (1); \ + case NEG: case NOT: \ + return COSTS_N_INSNS (1); \ + case ASHIFT: \ + case ASHIFTRT: \ + case LSHIFT: \ + case LSHIFTRT: \ + if (GET_CODE (XEXP (X,1)) == CONST_INT) \ + { \ + int number = INTVAL(XEXP (X,1)); \ + if (number == 1 || number == 4 || number == 8 || \ + number == 16) \ + return COSTS_N_INSNS (1); \ + else \ + return COSTS_N_INSNS (2); \ + } \ + return COSTS_N_INSNS (1); + + /* An expression giving the cost of an addressing mode that contains + address. */ + #define ADDRESS_COST(ADDR) dsp16xx_address_cost (ADDR) + + /* A c expression for the cost of moving data from a register in + class FROM to one in class TO. The classes are expressed using + the enumeration values such as GENERAL_REGS. A value of 2 is + the default. */ + #define REGISTER_MOVE_COST(FROM,TO) dsp16xx_register_move_cost (FROM, TO) + + /* A C expression for the cost of moving data of mode MODE between + a register and memory. A value of 2 is the default. */ + #define MEMORY_MOVE_COST(MODE) \ + (GET_MODE_CLASS(MODE) == MODE_INT && MODE == QImode ? 12 \ + : 16) + + /* A C expression for the cost of a branch instruction. A value of + 1 is the default; */ + #define BRANCH_COST 2 + + + /* Define this because otherwise gcc will try to put the function address + in any old pseudo register. We can only use pt. */ + #define NO_FUNCTION_CSE + + /* Define this macro as a C expression which is nonzero if accessing less + than a word of memory (i.e a char or short) is no faster than accessing + a word of memory, i.e if such access require more than one instruction + or if ther is no difference in cost between byte and (aligned) word + loads. */ + #define SLOW_BYTE_ACCESS 1 + + /* Define this macro if zero-extension (of a char or short to an int) can + be done faster if the destination is a register that is know to be zero. */ + /* #define SLOW_ZERO_EXTEND */ + + /* Define this macro if unaligned accesses have a cost many times greater than + aligned accesses, for example if they are emulated in a trap handler */ + /* define SLOW_UNALIGNED_ACCESS */ + + /* Define this macro to inhibit strength reduction of memory addresses */ + /* #define DONT_REDUCE_ADDR */ + + + /* DIVIDING THE OUTPUT IN SECTIONS */ + /* Output before read-only data. */ + + #define DEFAULT_TEXT_SEG_NAME ".text" + #define TEXT_SECTION_ASM_OP rsect_text + + /* Output before constants and strings */ + #define DEFAULT_CONST_SEG_NAME ".const" + #define READONLY_SECTION_ASM_OP rsect_const + #define READONLY_DATA_SECTION const_section + + /* Output before writable data. */ + #define DEFAULT_DATA_SEG_NAME ".data" + #define DATA_SECTION_ASM_OP rsect_data + + #define DEFAULT_BSS_SEG_NAME ".bss" + #define BSS_SECTION_ASM_OP rsect_bss + + /* We will default to using 1610 if the user doesn't + specify it. */ + #define DEFAULT_CHIP_NAME "1610" + + /* A list of names for sections other than the standard two, which are + 'in_text' and 'in_data'. */ + #define EXTRA_SECTIONS in_bss, in_const + + #define EXTRA_SECTION_FUNCTIONS \ + void \ + const_section () \ + { \ + if (in_section != in_const) \ + { \ + fprintf (asm_out_file, "%s\n", READONLY_SECTION_ASM_OP); \ + in_section = in_const; \ + } \ + } \ + void \ + bss_section () \ + { \ + if (in_section != in_bss) { \ + fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP); \ + in_section = in_bss; \ + } \ + } + + + /* THE OVERALL FRAMEWORK OF AN ASSEMBLER FILE */ + + /* Output at beginning of assembler file. */ + #define ASM_FILE_START(FILE) dsp16xx_file_start () + + /* Prevent output of .gcc_compiled */ + #define ASM_IDENTIFY_GCC(FILE) + + /* A C string constant describing how to begin a comment in the target + assembler language. */ + /* define ASM_COMMENT_START */ + + /* Output to assembler file text saying following lines + may contain character constants, extra white space, comments, etc. */ + #define ASM_APP_ON "" + + /* Output to assembler file text saying following lines + no longer contain unusual constructs. */ + #define ASM_APP_OFF "" + + /* OUTPUT OF DATA */ + + /* This is how to output an assembler line defining a `double' constant. */ + #define ASM_OUTPUT_DOUBLE(FILE,VALUE) asm_output_float (FILE,VALUE) + + /* This is how to output an assembler line defining a `float' constant. */ + #define ASM_OUTPUT_FLOAT(FILE,VALUE) asm_output_float (FILE, VALUE) + + /* This is how to output and assembler line defininf a 'float' constant of + size HFmode. */ + #define ASM_OUTPUT_SHORT_FLOAT(FILE,VALUE) asm_output_float (FILE, VALUE) + + /* This is how to output an assembler line defining an `char' constant. */ + #define ASM_OUTPUT_CHAR(FILE,VALUE) \ + ( fprintf (FILE, "\tint "), \ + output_addr_const (FILE, (VALUE)), \ + fprintf (FILE, "\n")) + + /* This is how to output an assembler line defining an `short' constant. */ + #define ASM_OUTPUT_SHORT(FILE,EXP) asm_output_long(FILE,INTVAL(EXP)) + + /* This is how to output an assembler line defining a 'int' constant. */ + #define ASM_OUTPUT_INT(FILE, EXP) asm_output_long(FILE,INTVAL(EXP)) + + /* This is how to output an assembler line for a numeric constant byte. */ + #define ASM_OUTPUT_BYTE(FILE,VALUE) ASM_OUTPUT_CHAR(FILE,VALUE) + + /* This is how we output a 'c' character string. For the 16xx + assembler we have to do it one letter at a time */ + + #define ASCII_LENGTH 10 + + #define ASM_OUTPUT_ASCII(MYFILE, MYSTRING, MYLENGTH) \ + do { \ + FILE *_hide_asm_out_file = (MYFILE); \ + unsigned char *_hide_p = (unsigned char *) (MYSTRING); \ + int _hide_thissize = (MYLENGTH); \ + { \ + FILE *asm_out_file = _hide_asm_out_file; \ + unsigned char *p = _hide_p; \ + int thissize = _hide_thissize; \ + int i; \ + \ + for (i = 0; i < thissize; i++) \ + { \ + register int c = p[i]; \ + \ + if (i % ASCII_LENGTH == 0) \ + fprintf (asm_out_file, "\tint "); \ + \ + if (c >= ' ' && c < 0177 && c != '\'') \ + { \ + putc ('\'', asm_out_file); \ + putc (c, asm_out_file); \ + putc ('\'', asm_out_file); \ + } \ + else \ + { \ + fprintf (asm_out_file, "%d", c); \ + /* After an octal-escape, if a digit follows, \ + terminate one string constant and start another. \ + The Vax assembler fails to stop reading the escape \ + after three digits, so this is the only way we \ + can get it to parse the data properly. \ + if (i < thissize - 1 \ + && p[i + 1] >= '0' && p[i + 1] <= '9') \ + fprintf (asm_out_file, "\'\n\tint \'"); \ + */ \ + } \ + /* if: \ + we are not at the last char (i != thissize -1) \ + and (we are not at a line break multiple \ + but i == 0) (it will be the very first time) \ + then put out a comma to extend. \ + */ \ + if ((i != thissize - 1) && ((i + 1) % ASCII_LENGTH)) \ + fprintf(asm_out_file, ","); \ + if (!((i + 1) % ASCII_LENGTH)) \ + fprintf (asm_out_file, "\n"); \ + } \ + fprintf (asm_out_file, "\n"); \ + } \ + } \ + while (0) + + /* Store in OUTPUT a string (made with alloca) containing + an assembler-name for a local static variable or function + named NAME. LABELNO is an integer which is different for + each call. */ + + #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ + do { \ + int len = strlen (NAME); \ + char *temp = (char *) alloca (len + 3); \ + temp[0] = 'L'; \ + strcpy (&temp[1], (NAME)); \ + temp[len + 1] = '_'; \ + temp[len + 2] = 0; \ + (OUTPUT) = (char *) alloca (strlen (NAME) + 11); \ + ASM_GENERATE_INTERNAL_LABEL (OUTPUT, temp, LABELNO); \ + } while (0) + + #define ASM_OPEN_PAREN "(" + #define ASM_CLOSE_PAREN ")" + + + /* OUTPUT OF UNINITIALIZED VARIABLES */ + + /* This says how to output an assembler line + to define a global common symbol. */ + + #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ + asm_output_common (FILE, NAME, SIZE, ROUNDED); + + /* This says how to output an assembler line + to define a local common symbol. */ + + #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ + asm_output_local (FILE, NAME, SIZE, ROUNDED); + + /* OUTPUT AND GENERATION OF LABELS */ + + /* This is how to output the definition of a user-level label named NAME, + such as the label on a static function or variable NAME. */ + #define ASM_OUTPUT_LABEL(FILE,NAME) \ + do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0) + + /* This is how to output a command to make the user-level label named NAME + defined for reference from other files. */ + + #define ASM_GLOBALIZE_LABEL(FILE,NAME) \ + do { fputs (".global ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0) + + /* A C statement to output to the stdio stream any text necessary + for declaring the name of an external symbol named name which + is referenced in this compilation but not defined. */ + + #define ASM_OUTPUT_EXTERNAL(FILE, DECL, NAME) \ + { \ + fprintf (FILE, ".extern "); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + } + /* A C statement to output on stream an assembler pseudo-op to + declare a library function named external. */ + + #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \ + { \ + fprintf (FILE, ".extern "); \ + assemble_name (FILE, XSTR (FUN, 0)); \ + fprintf (FILE, "\n"); \ + } + /* This is how to output a reference to a user-level label named NAME. + `assemble_name' uses this. */ + #define ASM_OUTPUT_LABELREF(FILE,NAME) \ + fprintf (FILE, "_%s", NAME) + + /* This is how to output an internal numbered label where + PREFIX is the class of label and NUM is the number within the class. */ + #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ + fprintf (FILE, "%s%d:\n", PREFIX, NUM) + + /* This is how to store into the string LABEL + the symbol_ref name of an internal numbered label where + PREFIX is the class of label and NUM is the number within the class. + This is suitable for output with `assemble_name'. */ + #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ + sprintf (LABEL, "*%s%d", PREFIX, NUM) + + + /* OUTPUT OF ASSEMBLER INSTRUCTIONS */ + + /* How to refer to registers in assembler output. + This sequence is indexed by compiler's hard-register-number (see above). */ + + #define REGISTER_NAMES \ + {"a0", "a0l", "a1", "a1l", "x", "y", "yl", "p", "pl", \ + "r0", "r1", "r2", "r3", "j", "k", "ybase", "pt", \ + "ar0", "ar1", "ar2", "ar3", \ + "c0", "c1", "c2", "pr", "rb", \ + "*(0)", "*(1)", "*(2)", "*(3)", "*(4)", "*(5)", \ + "*(6)", "*(7)", "*(8)", "*(9)", "*(10)", "*(11)", \ + "*(12)", "*(13)", "*(14)", "*(15)", "*(16)", "*(17)", \ + "*(18)", "*(19)", "*(20)", "*(21)", "*(22)", "*(23)", \ + "*(24)", "*(25)", "*(26)", "*(27)", "*(28)", "*(29)", \ + "*(30)", "*(31)" } + + #define HIMODE_REGISTER_NAMES \ + {"a0", "a0", "a1", "a1", "x", "y", "y", "p", "p", \ + "r0", "r1", "r2", "r3", "j", "k", "ybase", "pt", \ + "ar0", "ar1", "ar2", "ar3", \ + "c0", "c1", "c2", "pr", "rb", \ + "*(0)", "*(1)", "*(2)", "*(3)", "*(4)", "*(5)", \ + "*(6)", "*(7)", "*(8)", "*(9)", "*(10)", "*(11)", \ + "*(12)", "*(13)", "*(14)", "*(15)", "*(16)", "*(17)", \ + "*(18)", "*(19)", "*(20)", "*(21)", "*(22)", "*(23)", \ + "*(24)", "*(25)", "*(26)", "*(27)", "*(28)", "*(29)", \ + "*(30)", "*(31)" } + + #define PRINT_OPERAND_PUNCT_VALID_P(CODE) 0 + + /* Print operand X (an rtx) in assembler syntax to file FILE. + CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified. + For `%' followed by punctuation, CODE is the punctuation and X is null. + + DSP1610 extensions for operand codes: + + %H - print lower 16 bits of constant + %U - print upper 16 bits of constant + %w - print low half of register (e.g 'a0l') + %u - print upper half of register (e.g 'a0') + %b - print high half of accumulator for F3 ALU instructions + %h - print constant in decimal */ + + #define PRINT_OPERAND(FILE, X, CODE) print_operand(FILE, X, CODE) + + + /* Print a memory address as an operand to reference that memory location. */ + + #define PRINT_OPERAND_ADDRESS(FILE, ADDR) print_operand_address (FILE, ADDR) + + /* This is how to output an insn to push a register on the stack. + It need not be very fast code since it is used only for profiling */ + #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) fatal("Profiling not implemented yet."); + + /* This is how to output an insn to pop a register from the stack. + It need not be very fast code since it is used only for profiling */ + #define ASM_OUTPUT_REG_POP(FILE,REGNO) fatal("Profiling not implemented yet."); + + /* OUTPUT OF DISPATCH TABLES */ + + /* This macro should be provided on machines where the addresses in a dispatch + table are relative to the table's own address. */ + #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ + fprintf (FILE, "\tint L%d-L%d\n", VALUE, REL) + + /* This macro should be provided on machines where the addresses in a dispatch + table are absolute. */ + #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ + fprintf (FILE, "\tint L%d\n", VALUE) + + /* ASSEMBLER COMMANDS FOR ALIGNMENT */ + + /* This is how to output an assembler line that says to advance + the location counter to a multiple of 2**LOG bytes. We should + not have to do any alignemnt since the 1610 is a word machine. */ + #define ASM_OUTPUT_ALIGN(FILE,LOG) + + /* Define this macro if ASM_OUTPUT_SKIP should not be used in the text section + because it fails to put zero1 in the bytes that are skipped. */ + #define ASM_NO_SKIP_IN_TEXT 1 + + #define ASM_OUTPUT_SKIP(FILE,SIZE) \ + fprintf (FILE, "\t%d * int 0\n", (SIZE)) + + /* CONTROLLING DEBUGGING INFORMATION FORMAT */ + + /* Define this macro if GCC should produce COFF-style debugging output + for SDB in response to the '-g' option */ + #define SDB_DEBUGGING_INFO + + /* Support generating stabs for the listing file generator */ + #define DBX_DEBUGGING_INFO + + /* The default format when -g is given is still COFF debug info */ + #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG + + #define DBX_REGISTER_NUMBER(REGNO) (REGNO) + + /* MISCELLANEOUS PARAMETERS */ + + /* Specify the machine mode that this machine uses + for the index in the tablejump instruction. */ + #define CASE_VECTOR_MODE QImode + + /* Define this if the tablejump instruction expects the table + to contain offsets from the address of the table. + Do not define this if the table should contain absolute addresses. */ + /* #define CASE_VECTOR_PC_RELATIVE */ + + /* Specify the tree operation to be used to convert reals to integers. */ + #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR + + /* This is the kind of divide that is easiest to do in the general case. */ + #define EASY_DIV_EXPR TRUNC_DIV_EXPR + + /* Define this if the library function 'vprintf' is available on your system. */ + #define HAVE_VPRINTF + + /* Max number of bytes we can move from memory to memory + in one reasonably fast instruction. */ + #define MOVE_MAX 1 + + /* Defining this macro causes the compiler to omit a sign-extend, zero-extend, + or bitwise 'and' instruction that truncates the count of a shift operation + to a width equal to the number of bits needed to represent the size of the + object being shifted. Do not define this macro unless the trucation applies + to both shoft operations and bit-field operations (if any). */ + /* #define SHIFT_COUNT_TRUNCATED */ + + /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits + is done just by pretending it is already truncated. */ + #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 + + /* When a prototype says `char' or `short', really pass an `int'. */ + #define PROMOTE_PROTOTYPES + + /* An alias for the machine mode used for pointers */ + #define Pmode QImode + + /* A function address in a call instruction + is a byte address (for indexing purposes) + so give the MEM rtx a byte's mode. */ + #define FUNCTION_MODE QImode + + #if !defined(__DATE__) + #define TARGET_VERSION fprintf (stderr, " (%s)", VERSION_INFO1) + #else + #define TARGET_VERSION fprintf (stderr, " (%s, %s)", VERSION_INFO1, __DATE__) + #endif + + #define VERSION_INFO1 "AT&T DSP16xx C Cross Compiler, version 1.2.0" + + + /* Define this as 1 if `char' should by default be signed; else as 0. */ + #define DEFAULT_SIGNED_CHAR 1 + + /* If this macro is defined, GNU CC gathers statistics about the number and + kind of tree node it allocates during each run. The option '-fstats' will + tell the compiler to print these statistics about the sizes of it obstacks. */ + #define GATHER_STATISTICS + + /* Define this so gcc does not output a call to __main, since we + are not currently supporting c++. */ + #define INIT_SECTION_ASM_OP 1 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/dsp16xx/dsp16xx.md gcc-2.6.1/config/dsp16xx/dsp16xx.md *** gcc-2.6.0/config/dsp16xx/dsp16xx.md --- gcc-2.6.1/config/dsp16xx/dsp16xx.md Fri Sep 9 13:27:51 1994 *************** *** 0 **** --- 1,2180 ---- + ;;- Machine description for the AT&T DSP1600 for GNU C compiler + ;; Copyright (C) 1994 Free Software Foundation, Inc. + ;; Contributed by Michael Collison (collison@world.std.com). + + ;; 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. + + + ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al. + + ;; Attribute specifications + + ; Type of each instruction. Default is arithmetic. + ; I'd like to write the list as this, but genattrtab won't accept it. + ; + ; "jump,cond_jump,call, ; flow-control instructions + ; load_i,load, store, move ; Y space address arithmetic instructions + ; malu,special,f3_alu,f3_alu_i ; data arithmetic unit instructions + ; shift_i,shift, bfield_i, bfield ; bit manipulation unit instructions + ; arith, ; integer unit instructions + ; nop + + ; Classification of each insn. Some insns of TYPE_BRANCH are multi-word. + (define_attr "type" + "jump,cond_jump,call,load_i,load,move,store,malu,malu_mul,special,f3_alu,f3_alu_i,shift_i,shift,bfield_i,bfield,nop,ld_short_i" + (const_string "malu")) + + ; Length in # of instructions of each insn. The values are not exact, but + ; are safe. + (define_attr "length" "" + (cond [(eq_attr "type" "cond_jump,f3_alu_i,shift_i,bfield_i,load_i") + (const_int 2)] + (const_int 1))) + + + ;; .................... + ;; + ;; Test against 0 instructions + ;; + ;; .................... + + (define_expand "tsthi" + [(set (cc0) + (match_operand:HI 0 "register_operand" ""))] + "" + " + { + dsp16xx_compare_gen = gen_tst_reg; + dsp16xx_compare_op0 = operands[0]; + dsp16xx_compare_op1 = const0_rtx; + DONE; + }") + + (define_insn "tsthi_1" + [(set (cc0) + (match_operand:HI 0 "register_operand" "A"))] + "" + "%0=%0" + [(set_attr "type" "malu")]) + + (define_expand "tstqi" + [(set (cc0) + (match_operand:QI 0 "register_operand" ""))] + "" + " + { + dsp16xx_compare_gen = gen_tst_reg; + dsp16xx_compare_op0 = operands[0]; + dsp16xx_compare_op1 = const0_rtx; + DONE; + }") + + (define_insn "tstqi_1" + [(set (cc0) + (match_operand:QI 0 "register_operand" "j,q")) + (clobber (match_scratch:QI 1 "=k,u"))] + "" + "@ + %1=0\;%b0-0 + %1=0\;%b0-0" + [(set_attr "type" "malu,malu")]) + + + ;; + ;; .................... + ;; + ;; Bit test instructions + ;; + ;; .................... + + (define_insn "" + [(set (cc0) + (and:HI (match_operand:HI 0 "register_operand" "A,!A,A") + (match_operand:HI 1 "nonmemory_operand" "Z,A,I")))] + "" + "* + { + switch (which_alternative) + { + case 0: + case 1: + return \"%0&%1\"; + + case 2: + return \"%0&%H1\"; + } + }" + [(set_attr "type" "f3_alu,malu,f3_alu_i")]) + + + ;;(define_insn "" + ;; [(set (cc0) + ;; (and:QI (match_operand:QI 0 "register_operand" "h") + ;; (match_operand:QI 1 "const_int_operand" "I")))] + ;; "" + ;; "%b0&%H1" + ;; [(set_attr "type" "f3_alu_i")]) + + ;; + ;; + ;; Compare Instructions + ;; + + (define_expand "cmphi" + [(parallel [(set (cc0) + (compare (match_operand:HI 0 "general_operand" "") + (match_operand:HI 1 "general_operand" ""))) + (clobber (match_scratch:QI 2 "")) + (clobber (match_scratch:QI 3 "")) + (clobber (match_scratch:QI 4 "")) + (clobber (match_scratch:QI 5 ""))])] + "" + " + { + if (GET_CODE (operands[1]) == CONST_INT) + operands[1] = force_reg (HImode, operands[1]); + + if (operands[0]) /* Avoid unused code warning */ + { + dsp16xx_compare_gen = gen_compare_reg; + dsp16xx_compare_op0 = operands[0]; + dsp16xx_compare_op1 = operands[1]; + DONE; + } + + }") + + (define_insn "" + [(set (cc0) + (compare (match_operand:HI 0 "general_operand" "Z*r*m*i") + (match_operand:HI 1 "general_operand" "Z*r*m*i"))) + (clobber (match_scratch:QI 2 "=&A")) + (clobber (match_scratch:QI 3 "=&A")) + (clobber (match_scratch:QI 4 "=&A")) + (clobber (match_scratch:QI 5 "=&A"))] + "(save_next_cc_user_code = next_cc_user_code (insn)) == GTU \ + || save_next_cc_user_code == GEU \ + || save_next_cc_user_code == LTU \ + || save_next_cc_user_code == LEU" + "* + { + if (GET_CODE(operands[0]) == REG) + { + if (REGNO (operands[0]) == REG_Y || + REGNO (operands[0]) == REG_PROD) + { + output_asm_insn (\"a0=%0\", operands); + } + else if (IS_YBASE_REGISTER_WINDOW (REGNO(operands[0]))) + { + output_asm_insn (\"a0=%u0\;a0l=%w0\", operands); + } + else + fatal (\"Illegal register for compare\"); + } + else if (GET_CODE(operands[0]) == CONST_INT) + { + output_asm_insn (\"a0=%U0\;a0l=%H0\", operands); + } + else if (GET_CODE (operands[0]) == MEM) + { + rtx xoperands[2]; + + xoperands[0] = gen_rtx (REG, HImode, REG_A0); + xoperands[1] = operands[0]; + double_reg_from_memory (xoperands); + } + + if (GET_CODE(operands[1]) == REG) + { + if (REGNO (operands[1]) == REG_Y || + REGNO (operands[1]) == REG_PROD) + { + output_asm_insn (\"a1=%1\", operands); + } + else if (IS_YBASE_REGISTER_WINDOW (REGNO(operands[1]))) + { + output_asm_insn (\"a1=%u1\;a1l=%w1\", operands); + } + else + fatal (\"Illegal register for compare\"); + } + else if (GET_CODE (operands[1]) == MEM) + { + rtx xoperands[2]; + + xoperands[0] = gen_rtx (REG, HImode, REG_A1); + xoperands[1] = operands[1]; + double_reg_from_memory (xoperands); + } + else if (GET_CODE(operands[1]) == CONST_INT) + { + output_asm_insn (\"a1=%U1\;a1l=%H1\", operands); + } + + return \"psw = 0\;a0 - a1\"; + }") + + (define_insn "" + [(set (cc0) (compare (match_operand:HI 0 "register_operand" "A,!A") + (match_operand:HI 1 "register_operand" "Z,*A")))] + "" + "@ + %0-%1 + %0-%1" + [(set_attr "type" "malu,f3_alu")]) + + (define_expand "cmpqi" + [(parallel [(set (cc0) + (compare (match_operand:QI 0 "register_operand" "") + (match_operand:QI 1 "nonmemory_operand" ""))) + (clobber (match_operand:QI 2 "register_operand" "")) + (clobber (match_operand:QI 3 "register_operand" ""))])] + "" + " + { + if (operands[0]) /* Avoid unused code warning */ + { + dsp16xx_compare_gen = gen_compare_reg; + dsp16xx_compare_op0 = operands[0]; + dsp16xx_compare_op1 = operands[1]; + DONE; + } + }") + + (define_insn "" + [(set (cc0) (compare (match_operand:QI 0 "register_operand" "k,k,!k,k,u,u,!u,u") + (match_operand:QI 1 "nonmemory_operand" "w,z,u,i,w,z,k,i"))) + (clobber (match_scratch:QI 2 "=j,j,j,j,q,q,q,q")) + (clobber (match_scratch:QI 3 "=v,y,q,X,v,y,j,X"))] + "(save_next_cc_user_code = next_cc_user_code (insn)) == GTU \ + || save_next_cc_user_code == GEU \ + || save_next_cc_user_code == LTU \ + || save_next_cc_user_code == LEU" + "@ + %2=0\;%3=0\;%2-%3 + %2=0\;%3=0\;%2-%3 + %2=0\;%3=0\;%2-%3 + %2=0\;%0-%H1 + %2=0\;%3=0\;%2-%3 + %2=0\;%3=0\;%2-%3 + %2=0\;%3=0\;%2-%3 + %2=0\;%0-%H1") + + + (define_insn "" + [(set (cc0) (compare (match_operand:QI 0 "register_operand" "j,j,!j,j,q,q,!q,q") + (match_operand:QI 1 "nonmemory_operand" "v,y,q,i,v,y,j,i"))) + (clobber (match_scratch:QI 2 "=k,k,k,k,u,u,u,u")) + (clobber (match_scratch:QI 3 "=w,z,u,X,w,z,k,X"))] + "" + "@ + %2=0\;%3=0\;%0-%1 + %2=0\;%3=0\;%0-%1 + %2=0\;%3=0\;%0-%1 + %2=0\;%b0-%H1 + %2=0\;%3=0\;%0-%1 + %2=0\;%3=0\;%0-%1 + %2=0\;%3=0\;%0-%1 + %2=0\;%b0-%H1") + + + (define_expand "cmphf" + [(set (cc0) + (compare (match_operand:HF 0 "register_operand" "") + (match_operand:HF 1 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_cmphf3_libcall) + dsp16xx_cmphf3_libcall = gen_rtx (SYMBOL_REF, Pmode, CMPHF3_LIBCALL); + + dsp16xx_compare_gen = gen_compare_reg; + dsp16xx_compare_op0 = operands[0]; + dsp16xx_compare_op1 = operands[1]; + emit_library_call (dsp16xx_cmphf3_libcall, 1, HImode, 2, + operands[0], HFmode, + operands[1], HFmode); + emit_insn (gen_tsthi_1 (copy_to_reg(hard_libcall_value (HImode)))); + DONE; + }") + + + ;; .................... + ;; + ;; Add instructions + ;; + ;; .................... + + + (define_insn "addhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A") + (plus:HI (match_operand:HI 1 "register_operand" "%A,A,A") + (match_operand:HI 2 "nonmemory_operand" "Z,d,i")))] + "" + "@ + %0=%1+%2 + %0=%1+%2 + %0=%w1+%H2\;%0=%b0+%U2" + [(set_attr "type" "malu,malu,f3_alu_i")]) + + (define_insn "" + [(set (match_operand:QI 0 "register_operand" "=k,u,!k,!u") + (plus:QI (plus:QI (match_operand:QI 1 "register_operand" "uk,uk,uk,uk") + (match_operand:QI 2 "register_operand" "wz,wz,uk,uk")) + (match_operand:QI 3 "immediate_operand" "i,i,i,i"))) + (clobber (match_scratch:QI 4 "=j,q,j,q"))] + "" + "@ + %m0=%m1+%m2\;%m0=%0+%H3 + %m0=%m1+%m2\;%m0=%0+%H3 + %m0=%m1+%m2\;%m0=%0+%H3 + %m0=%m1+%m2\;%m0=%0+%H3") + + (define_expand "addqi3" + [(parallel [(set (match_operand:QI 0 "register_operand" "") + (plus:QI (match_operand:QI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" ""))) + (clobber (match_scratch:QI 3 ""))])] + "" + " + { + if (reload_in_progress) + { + if (REG_P (operands[1]) && + (REGNO(operands[1]) == STACK_POINTER_REGNUM || + REGNO(operands[1]) == FRAME_POINTER_REGNUM) && + GET_CODE (operands[2]) == CONST_INT) + { + if (REG_P (operands[0]) && IS_ACCUM_REG(REGNO(operands[0]))) + emit_move_insn (operands[0], operands[1]); + + operands[1] = operands[0]; + } + } + }") + + + (define_insn "match_addqi3" + [(set (match_operand:QI 0 "register_operand" "=!a,!a,k,u,!k,!u,h,!a") + (plus:QI (match_operand:QI 1 "register_operand" "0,0,uk,uk,uk,uk,h,0") + (match_operand:QI 2 "nonmemory_operand" "W,N,wzi,wzi,uk,uk,i,n"))) + (clobber (match_scratch:QI 3 "=X,X,j,q,j,q,X,W"))] + "" + "* + { + switch (which_alternative) + { + case 0: + return \"*%0++%2\"; + + case 1: + switch (INTVAL (operands[2])) + { + case -1: + return \"*%0--\"; + + case 1: + return \"*%0++\"; + + case -2: + return \"*%0--\;*%0--\"; + + case 2: + return \"*%0++\;*%0++\"; + } + + case 2: + case 3: + if (!CONSTANT_P(operands[2])) + return \"%m0=%m1+%m2\"; + else + return \"%m0=%1+%H2\"; + + case 4: + case 5: + return \"%m0=%m1+%m2\"; + + case 6: + return \"%0=%b1+%H2\"; + + case 7: + return \"%3=%2\;*%0++%3\"; + } + }") + + (define_expand "addhf3" + [(set (match_operand:HF 0 "register_operand" "") + (plus:HF (match_operand:HF 1 "register_operand" "") + (match_operand:HF 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_addhf3_libcall) + dsp16xx_addhf3_libcall = gen_rtx (SYMBOL_REF, Pmode, ADDHF3_LIBCALL); + + emit_library_call (dsp16xx_addhf3_libcall, 1, HFmode, 2, + operands[1], HFmode, + operands[2], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + + ;; + ;; .................... + ;; + ;; Subtract instructions + ;; + ;; .................... + + (define_insn "subhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A") + (minus:HI (match_operand:HI 1 "register_operand" "A,A,A") + (match_operand:HI 2 "nonmemory_operand" "Z,d,i")))] + "" + "@ + %0=%1-%2 + %0=%1-%2 + %0=%w1-%H2\;%0=%b0-%U2" + [(set_attr "type" "malu,malu,f3_alu_i")]) + + (define_insn "subqi3" + [(set (match_operand:QI 0 "register_operand" "=?*a,k,u,!k,!u") + (minus:QI (match_operand:QI 1 "register_operand" "0,uk,uk,uk,uk") + (match_operand:QI 2 "nonmemory_operand" "n,wzi,wzi,uk,uk"))) + (clobber (match_scratch:QI 3 "=W,j,q,j,q"))] + "" + "* + { + switch (which_alternative) + { + case 0: + switch (INTVAL (operands[2])) + { + case 0: + return \"\"; + + case 1: + return \"*%0--\"; + + case -1: + return \"*%0++\"; + + default: + operands[2] = GEN_INT (-INTVAL (operands[2])); + + if (SHORT_IMMEDIATE(operands[2])) + return \"set %3=%H2\;*%0++%3\"; + else + return \"%3=%H2\;*%0++%3\"; + } + + case 1: + case 2: + if (!CONSTANT_P(operands[2])) + return \"%m0=%m1-%m2\"; + else + return \"%m0=%1-%H2\"; + + case 3: + case 4: + return \"%m0=%m1-%m2\"; + } + }") + + (define_expand "subhf3" + [(set (match_operand:HF 0 "register_operand" "") + (minus:HF (match_operand:HF 1 "register_operand" "") + (match_operand:HF 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_subhf3_libcall) + dsp16xx_subhf3_libcall = gen_rtx (SYMBOL_REF, Pmode, SUBHF3_LIBCALL); + + emit_library_call (dsp16xx_subhf3_libcall, 1, HFmode, 2, + operands[1], HFmode, + operands[2], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + (define_insn "neghi2" + [(set (match_operand:HI 0 "register_operand" "=A") + (neg:HI (match_operand:HI 1 "register_operand" "A")))] + "" + "%0=-%1" + [(set_attr "type" "special")]) + + (define_expand "neghf2" + [(set (match_operand:HF 0 "general_operand" "") + (neg:HF (match_operand:HF 1 "general_operand" "")))] + "" + " + { + if (!dsp16xx_neghf2_libcall) + dsp16xx_neghf2_libcall = gen_rtx (SYMBOL_REF, Pmode, NEGHF2_LIBCALL); + + emit_library_call (dsp16xx_neghf2_libcall, 1, HFmode, 1, + operands[1], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + + + ;; + ;; .................... + ;; + ;; Multiply instructions + ;; + + (define_expand "mulhi3" + [(set (match_operand:HI 0 "register_operand" "") + (mult:HI (match_operand:HI 1 "register_operand" "") + (match_operand:HI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_mulhi3_libcall) + dsp16xx_mulhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, MULHI3_LIBCALL); + + emit_library_call (dsp16xx_mulhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], HImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_insn "mulqi3" + [(set (match_operand:QI 0 "register_operand" "=w") + (mult:HI (match_operand:QI 1 "register_operand" "%x") + (match_operand:QI 2 "register_operand" "y"))) + (clobber (match_scratch:QI 3 "=v"))] + "" + "%m0=%1*%2" + [(set_attr "type" "malu_mul")]) + + (define_insn "mulqihi3" + [(set (match_operand:HI 0 "register_operand" "=t") + (mult:HI (sign_extend:HI (match_operand:QI 1 "register_operand" "%x")) + (sign_extend:HI (match_operand:QI 2 "register_operand" "y"))))] + "" + "%0=%1*%2" + [(set_attr "type" "malu_mul")]) + + (define_insn "umulqihi3" + [(set (match_operand:HI 0 "register_operand" "=t") + (mult:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "%x")) + (zero_extend:HI (match_operand:QI 2 "register_operand" "y"))))] + "" + "%0=%1*%2" + [(set_attr "type" "malu_mul")]) + + (define_expand "mulhf3" + [(set (match_operand:HF 0 "register_operand" "") + (mult:HF (match_operand:HF 1 "register_operand" "") + (match_operand:HF 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_mulhf3_libcall) + dsp16xx_mulhf3_libcall = gen_rtx (SYMBOL_REF, Pmode, MULHF3_LIBCALL); + + emit_library_call (dsp16xx_mulhf3_libcall, 1, HFmode, 2, + operands[1], HFmode, + operands[2], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + + + ;; + ;; ******************* + ;; + ;; Divide Instructions + ;; + + (define_expand "divhi3" + [(set (match_operand:HI 0 "register_operand" "") + (div:HI (match_operand:HI 1 "register_operand" "") + (match_operand:HI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_divhi3_libcall) + dsp16xx_divhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, DIVHI3_LIBCALL); + + emit_library_call (dsp16xx_divhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], HImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_expand "udivhi3" + [(set (match_operand:HI 0 "register_operand" "") + (udiv:HI (match_operand:HI 1 "register_operand" "") + (match_operand:HI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_udivhi3_libcall) + dsp16xx_udivhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, UDIVHI3_LIBCALL); + + emit_library_call (dsp16xx_udivhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], HImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_expand "divqi3" + [(set (match_operand:QI 0 "register_operand" "") + (div:QI (match_operand:QI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_divqi3_libcall) + dsp16xx_divqi3_libcall = gen_rtx (SYMBOL_REF, Pmode, DIVQI3_LIBCALL); + + emit_library_call (dsp16xx_divqi3_libcall, 1, QImode, 2, + operands[1], QImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(QImode)); + DONE; + }") + + (define_expand "udivqi3" + [(set (match_operand:QI 0 "register_operand" "") + (udiv:QI (match_operand:QI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_udivqi3_libcall) + dsp16xx_udivqi3_libcall = gen_rtx (SYMBOL_REF, Pmode, UDIVQI3_LIBCALL); + + emit_library_call (dsp16xx_udivqi3_libcall, 1, QImode, 2, + operands[1], QImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(QImode)); + DONE; + }") + + ;; + ;; .................... + ;; + ;; Modulo instructions + ;; + ;; .................... + + (define_expand "modhi3" + [(set (match_operand:HI 0 "register_operand" "") + (mod:HI (match_operand:HI 1 "register_operand" "") + (match_operand:HI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_modhi3_libcall) + dsp16xx_modhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, MODHI3_LIBCALL); + + emit_library_call (dsp16xx_modhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], HImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_expand "umodhi3" + [(set (match_operand:HI 0 "register_operand" "") + (umod:HI (match_operand:HI 1 "register_operand" "") + (match_operand:HI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_umodhi3_libcall) + dsp16xx_umodhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, UMODHI3_LIBCALL); + + emit_library_call (dsp16xx_umodhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], HImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_expand "modqi3" + [(set (match_operand:QI 0 "register_operand" "") + (mod:QI (match_operand:QI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_modqi3_libcall) + dsp16xx_modqi3_libcall = gen_rtx (SYMBOL_REF, Pmode, MODQI3_LIBCALL); + + emit_library_call (dsp16xx_modqi3_libcall, 1, QImode, 2, + operands[1], QImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(QImode)); + DONE; + }") + + (define_expand "umodqi3" + [(set (match_operand:QI 0 "register_operand" "") + (umod:QI (match_operand:QI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_umodqi3_libcall) + dsp16xx_umodqi3_libcall = gen_rtx (SYMBOL_REF, Pmode, UMODQI3_LIBCALL); + + emit_library_call (dsp16xx_umodqi3_libcall, 1, QImode, 2, + operands[1], QImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(QImode)); + DONE; + }") + + (define_expand "divhf3" + [(set (match_operand:HF 0 "register_operand" "") + (div:HF (match_operand:HF 1 "register_operand" "") + (match_operand:HF 2 "nonmemory_operand" "")))] + "" + " + { + if (!dsp16xx_divhf3_libcall) + dsp16xx_divhf3_libcall = gen_rtx (SYMBOL_REF, Pmode, DIVHF3_LIBCALL); + + emit_library_call (dsp16xx_divhf3_libcall, 1, HFmode, 2, + operands[1], HFmode, + operands[2], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + + + ;; + ;; ******************** + ;; + ;; Logical Instructions + ;; + + (define_insn "andhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,?A") + (and:HI (match_operand:HI 1 "register_operand" "%A,!A,A") + (match_operand:HI 2 "nonmemory_operand" "Z,A,i")))] + "" + "@ + %0=%1&%2 + %0=%1&%2 + %0=%w1&%H2\;%0=%b0&%U2" + [(set_attr "type" "f3_alu,f3_alu,f3_alu_i")]) + + (define_insn "andqi3" + [(set (match_operand:QI 0 "register_operand" "=k,u,uk,!k,!u,j,q,jq,!j,!q") + (and:QI (match_operand:QI 1 "register_operand" "uk,uk,uk,uk,uk,jq,jq,jq,jq,jq") + (match_operand:QI 2 "nonmemory_operand" "wz,wz,i,uk,uk,yv,yv,i,jq,jq"))) + (clobber (match_scratch:QI 3 "=j,q,X,j,q,k,u,X,k,u"))] + "" + "@ + %m0=%m1&%m2 + %m0=%m1&%m2 + %m0=%1&%H2 + %m0=%m1&%m2 + %m0=%m1&%m2 + %m0=%m1&%m2 + %m0=%m1&%m2 + %m0=%b1&%H2 + %m0=%m1&%m2 + %m0=%m1&%m2") + + (define_insn "iorhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A,?A") + (ior:HI (match_operand:HI 1 "register_operand" "%A,!A,A,A") + (match_operand:HI 2 "nonmemory_operand" "Z,A,I,i")))] + "" + "@ + %0=%u1|%u2 + %0=%u1|%u2 + %0=%w1|%H2 + %0=%w1|%H2\;%0=%b0|%U2" + [(set_attr "type" "f3_alu,f3_alu,f3_alu_i,f3_alu_i")]) + + (define_insn "iorqi3" + [(set (match_operand:QI 0 "register_operand" "=k,u,uk,!k,!u,j,q,jq,!j,!q") + (ior:QI (match_operand:QI 1 "register_operand" "uk,uk,uk,uk,uk,jq,jq,jq,jq,jq") + (match_operand:QI 2 "nonmemory_operand" "wz,wz,i,uk,uk,yv,yv,i,jq,jq"))) + (clobber (match_scratch:QI 3 "=j,q,X,j,q,k,u,X,k,u"))] + "" + "@ + %m0=%m1|%m2 + %m0=%m1|%m2 + %m0=%1|%H2 + %m0=%m1|%m2 + %m0=%m1|%m2 + %m0=%m1|%m2 + %m0=%m1|%m2 + %m0=%b1|%H2 + %m0=%m1|%m2 + %m0=%m1|%m2") + + (define_insn "xorhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A,?A") + (xor:HI (match_operand:HI 1 "register_operand" "%A,!A,A,A") + (match_operand:HI 2 "nonmemory_operand" "Z,A,I,i")))] + "" + "@ + %0=%1^%2 + %0=%1^%2 + %0=%w1^%H2 + %0=%w1^%H2\;%0=%b0^%U2" + [(set_attr "type" "f3_alu,f3_alu,f3_alu_i,f3_alu_i")]) + + (define_insn "xorqi3" + [(set (match_operand:QI 0 "register_operand" "=k,u,uk,!k,!u,j,q,jq,!j,!q") + (xor:QI (match_operand:QI 1 "register_operand" "uk,uk,uk,uk,uk,jq,jq,jq,jq,jq") + (match_operand:QI 2 "nonmemory_operand" "wz,wz,i,uk,uk,yv,yv,i,jq,jq"))) + (clobber (match_scratch:QI 3 "=j,q,X,j,q,k,u,X,k,u"))] + "" + "@ + %m0=%m1^%m2 + %m0=%m1^%m2 + %m0=%1^%H2 + %m0=%m1^%m2 + %m0=%m1^%m2 + %m0=%m1^%m2 + %m0=%m1^%m2 + %m0=%b1^%H2 + %m0=%m1^%m2 + %m0=%m1^%m2") + + (define_insn "one_cmplhi2" + [(set (match_operand:HI 0 "register_operand" "=A") + (not:HI (match_operand:HI 1 "register_operand" "A")))] + "" + "%0= ~%1" + [(set_attr "type" "special")]) + + (define_insn "one_cmplqi2" + [(set (match_operand:QI 0 "register_operand" "=ku,jq") + (not:QI (match_operand:QI 1 "register_operand" "ku,jq")))] + "" + "@ + %m0= %1 ^ 0xffff + %m0= %b1 ^ 0xffff" + [(set_attr "type" "special")]) + + + ;; + ;; MOVE INSTRUCTIONS + ;; + + (define_expand "movhi" + [(set (match_operand:HI 0 "general_operand" "") + (match_operand:HI 1 "general_operand" ""))] + "" + " + { + if (emit_move_sequence (operands, HImode)) + DONE; + }") + + + (define_insn "match_movhi1" + [(set (match_operand:HI 0 "nonimmediate_operand" "=A,Z,A,d,d,m,?d,*Y,t,f") + (match_operand:HI 1 "general_operand" "d,A,K,i,m,d,*Y,?d,t,f"))] + "register_operand(operands[0], HImode) + || register_operand(operands[1], HImode)" + "* + { + switch (which_alternative) + { + /* register to accumulator */ + case 0: + return \"%0=%1\"; + case 1: + return \"%u0=%u1\;%w0=%w1\"; + case 2: + return \"%0=%0^%0\"; + case 3: + return \"%u0=%U1\;%w0=%H1\"; + case 4: + double_reg_from_memory(operands); + return \"\"; + case 5: + double_reg_to_memory(operands); + return \"\"; + case 6: + case 7: + return \"%u0=%u1\;%w0=%w1\"; + case 8: + case 9: + return \"\"; + } + }" + [(set_attr "type" "move,move,load_i,load_i,load,store,load,store,move,move")]) + + + ;; NOTE: It is cheaper to do 'y = *r0', than 'r0 = *r0'. + + (define_expand "movqi" + [(set (match_operand:QI 0 "nonimmediate_operand" "") + (match_operand:QI 1 "general_operand" ""))] + "" + " + { + if (emit_move_sequence (operands, QImode)) + DONE; + }") + + ;; The movqi pattern with the parallel is used for addqi insns (which have a parallel) + ;; that are turned into moveqi insns by the flow phase. This happens when a auto-increment + ;; is detected. + + (define_insn "match_movqi1" + [(parallel [(set (match_operand:QI 0 "nonimmediate_operand" "=A,r,aW,c,?D,m<>,e,Y,r,xyz,m<>") + (match_operand:QI 1 "general_operand" "r,A,J,i,m<>,D,Y,e,0,m<>,xyz")) + (clobber (match_scratch:QI 2 "=X,X,X,X,X,X,X,X,X,X,X"))])] + "register_operand(operands[0], QImode) + || register_operand(operands[1], QImode)" + "* + { + switch (which_alternative) + { + case 0: + /* We have to use the move mneumonic otherwise the 1610 will + attempt to transfer all 32-bits of 'y', 'p' or an accumualtor + , which we don't want */ + if (REGNO(operands[1]) == REG_Y || REGNO(operands[1]) == REG_PROD + || IS_ACCUM_REG(REGNO(operands[1]))) + return \"move %0=%1\"; + else + return \"%0=%1\"; + + case 1: + return \"%0=%1\"; + + case 2: + return \"set %0=%H1\"; + + case 3: + return \"%0=%H1\"; + + case 4: + return \"%0=%1\"; + + case 5: + case 6: + return \"%0=%1\"; + + case 7: + return \"%0=%1\"; + + case 8: + return \"\"; + + case 9: case 10: + return \"%0=%1\"; + } + }") + + (define_insn "match_movqi2" + [(set (match_operand:QI 0 "nonimmediate_operand" "=A,r,aW,c,?D,m<>,e,Y,r,xyz,m<>") + (match_operand:QI 1 "general_operand" "r,A,J,i,m<>,D,Y,e,0,m<>,xyz"))] + "register_operand(operands[0], QImode) + || register_operand(operands[1], QImode)" + "* + { + switch (which_alternative) + { + case 0: + /* We have to use the move mneumonic otherwise the 1610 will + attempt to transfer all 32-bits of 'y', 'p' or an accumualtor + , which we don't want */ + if (REGNO(operands[1]) == REG_Y || REGNO(operands[1]) == REG_PROD + || IS_ACCUM_REG(REGNO(operands[1]))) + return \"move %0=%1\"; + else + return \"%0=%1\"; + + case 1: + return \"%0=%1\"; + + case 2: + return \"set %0=%H1\"; + + case 3: + return \"%0=%H1\"; + + case 4: + return \"%0=%1\"; + + case 5: + case 6: + return \"%0=%1\"; + + case 7: + return \"%0=%1\"; + + case 8: + return \"\"; + + case 9: case 10: + return \"%0=%1\"; + } + }") + + (define_expand "reload_inqi" + [(set (match_operand:QI 0 "register_operand" "=u") + (match_operand:QI 1 "sp_operand" "")) + (clobber (match_operand:QI 2 "register_operand" "=&q"))] + "" + " + { + rtx addr_reg = XEXP (operands[1], 0); + rtx offset = XEXP (operands[1], 1); + + /* First, move the frame or stack pointer to the accumulator */ + emit_move_insn (operands[0], addr_reg); + + /* Then generate the add insn */ + emit_insn (gen_rtx (PARALLEL, VOIDmode, + gen_rtvec (2, + gen_rtx (SET, VOIDmode, operands[0], + gen_rtx (PLUS, QImode, operands[0], offset)), + gen_rtx (CLOBBER, VOIDmode, operands[2])))); + DONE; + }") + + (define_expand "reload_inhi" + [(set (match_operand:HI 0 "register_operand" "=r") + (match_operand:HI 1 "register_operand" "r")) + (clobber (match_operand:QI 2 "register_operand" "=&h"))] + "" + " + { + /* Check for an overlap of operand 2 (an accumulator) with + the msw of operand 0. If we have an overlap we must reverse + the order of the moves. */ + + if (REGNO(operands[2]) == REGNO(operands[0])) + { + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HImode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HImode), operands[2]); + } + else + { + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HImode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HImode), operands[2]); + } + + DONE; + }") + + + (define_expand "reload_outhi" + [(set (match_operand:HI 0 "register_operand" "=r") + (match_operand:HI 1 "register_operand" "r")) + (clobber (match_operand:QI 2 "register_operand" "=&h"))] + "" + " + { + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HImode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HImode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HImode), operands[2]); + DONE; + }") + + (define_expand "movstrqi" + [(parallel [(set (match_operand:BLK 0 "memory_operand" "") + (match_operand:BLK 1 "memory_operand" "")) + (use (match_operand:QI 2 "const_int_operand" "")) + (use (match_operand:QI 3 "const_int_operand" "")) + (clobber (match_scratch:QI 4 "")) + (clobber (match_dup 5)) + (clobber (match_dup 6))])] + "" + " + { + rtx addr0, addr1; + + if (GET_CODE (operands[2]) != CONST_INT) + FAIL; + + if (INTVAL(operands[2]) > 127) + FAIL; + + addr0 = copy_to_mode_reg (Pmode, XEXP (operands[0], 0)); + addr1 = copy_to_mode_reg (Pmode, XEXP (operands[1], 0)); + + operands[5] = addr0; + operands[6] = addr1; + + operands[0] = gen_rtx (MEM, BLKmode, addr0); + operands[1] = gen_rtx (MEM, BLKmode, addr1); + }") + + (define_insn "" + [(set (mem:BLK (match_operand:QI 0 "register_operand" "a")) + (mem:BLK (match_operand:QI 1 "register_operand" "a"))) + (use (match_operand:QI 2 "const_int_operand" "n")) + (use (match_operand:QI 3 "immediate_operand" "i")) + (clobber (match_scratch:QI 4 "=x")) + (clobber (match_dup 0)) + (clobber (match_dup 1))] + "" + "* + { return output_block_move (operands); }") + + + ;; Floating point move insns + + + (define_expand "movhf" + [(set (match_operand:HF 0 "general_operand" "") + (match_operand:HF 1 "general_operand" ""))] + "" + " + { + if (emit_move_sequence (operands, HFmode)) + DONE; + }") + + (define_insn "match_movhf" + [(set (match_operand:HF 0 "nonimmediate_operand" "=A,Z,d,d,m,d,Y") + (match_operand:HF 1 "general_operand" "d,A,F,m,d,Y,d"))] + "" + "* + { + /* NOTE: When loading the register 16 bits at a time we + MUST load the high half FIRST (because the 1610 zeros + the low half) and then load the low half */ + + switch (which_alternative) + { + /* register to accumulator */ + case 0: + return \"%0=%1\"; + case 1: + return \"%u0=%u1\;%w0=%w1\"; + case 2: + output_dsp16xx_float_const(operands); + return \"\"; + case 3: + double_reg_from_memory(operands); + return \"\"; + case 4: + double_reg_to_memory(operands); + return \"\"; + case 5: + case 6: + return \"%u0=%u1\;%w0=%w1\"; + } + }" + [(set_attr "type" "move,move,load_i,load,store,load,store")]) + + + + (define_expand "reload_inhf" + [(set (match_operand:HF 0 "register_operand" "=r") + (match_operand:HF 1 "register_operand" "r")) + (clobber (match_operand:QI 2 "register_operand" "=&h"))] + "" + " + { + /* Check for an overlap of operand 2 (an accumulator) with + the msw of operand 0. If we have an overlap we must reverse + the order of the moves. */ + + if (REGNO(operands[2]) == REGNO(operands[0])) + { + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HFmode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HFmode), operands[2]); + } + else + { + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HFmode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HFmode), operands[2]); + } + + DONE; + }") + + (define_expand "reload_outhf" + [(set (match_operand:HF 0 "register_operand" "=r") + (match_operand:HF 1 "register_operand" "r")) + (clobber (match_operand:QI 2 "register_operand" "=&h"))] + "" + " + { + emit_move_insn (operands[2], operand_subword (operands[1], 0, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 0, 0, HFmode), operands[2]); + emit_move_insn (operands[2], operand_subword (operands[1], 1, 0, HFmode)); + emit_move_insn (operand_subword (operands[0], 1, 0, HFmode), operands[2]); + DONE; + }") + + + ;; + ;; CONVERSION INSTRUCTIONS + ;; + + (define_expand "extendqihi2" + [(clobber (match_dup 2)) + (set (match_dup 3) (match_operand:QI 1 "register_operand" "")) + (set (match_operand:HI 0 "register_operand" "") + (ashift:HI (match_dup 2) + (const_int 16))) + (set (match_dup 0) + (ashiftrt:HI (match_dup 0) (const_int 16)))] + "" + " + { + operands[2] = gen_reg_rtx (HImode); + operands[3] = gen_rtx (SUBREG, QImode, operands[2], 1); + }") + + ;;(define_insn "extendqihi2" + ;; [(set (match_operand:HI 0 "register_operand" "=A") + ;; (sign_extend:HI (match_operand:QI 1 "register_operand" "h")))] + ;; "" + ;; "%0 = %1 >> 16") + + ;;(define_insn "zero_extendqihi2" + ;; [(set (match_operand:HI 0 "register_operand" "=t,f,A,?d,?A") + ;; (zero_extend:HI (match_operand:QI 1 "register_operand" "w,z,ku,A,r")))] + ;; "" + ;; "* + ;; { + ;; switch (which_alternative) + ;; { + ;; case 0: + ;; case 1: + ;; return \"%0=0\"; + ;; + ;; case 2: + ;; if (REGNO(operands[1]) == (REGNO(operands[0]) + 1)) + ;; return \"%0=0\"; + ;; else + ;; return \"%w0=%1\;%0=0\"; + ;; case 3: + ;; return \"%w0=%1\;%0=0\"; + ;; + ;; case 4: + ;; if (REGNO(operands[1]) == REG_Y || REGNO(operands[1]) == REG_PROD + ;; || IS_ACCUM_REG(REGNO(operands[1]))) + ;; return \"move %w0=%1\;%0=0\"; + ;; else + ;; return \"%w0=%1\;%0=0\"; + ;; } + ;; }") + + (define_expand "zero_extendqihi2" + [(clobber (match_dup 2)) + (set (match_dup 3) (match_operand:QI 1 "register_operand" "")) + (set (match_operand:HI 0 "register_operand" "") + (ashift:HI (match_dup 2) + (const_int 16))) + (set (match_dup 0) + (lshiftrt:HI (match_dup 0) (const_int 16)))] + "" + " + { + operands[2] = gen_reg_rtx (HImode); + operands[3] = gen_rtx (SUBREG, QImode, operands[2], 1); + }") + + + (define_expand "floathihf2" + [(set (match_operand:HF 0 "register_operand" "") + (float:HF (match_operand:HI 1 "register_operand" "")))] + "" + " + { + if (!dsp16xx_floathihf2_libcall) + dsp16xx_floathihf2_libcall = gen_rtx (SYMBOL_REF, Pmode, FLOATHIHF2_LIBCALL); + + emit_library_call (dsp16xx_floathihf2_libcall, 1, HFmode, 1, + operands[1], HImode); + emit_move_insn (operands[0], hard_libcall_value(HFmode)); + DONE; + }") + + (define_expand "fix_trunchfhi2" + [(set (match_operand:HI 0 "register_operand" "") + (fix:HI (match_operand:HF 1 "register_operand" "")))] + "" + " + { + if (!dsp16xx_fixhfhi2_libcall) + dsp16xx_fixhfhi2_libcall = gen_rtx (SYMBOL_REF, Pmode, FIXHFHI2_LIBCALL); + + emit_library_call (dsp16xx_fixhfhi2_libcall, 1, HImode, 1, + operands[1], HFmode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + }") + + (define_expand "fixuns_trunchfhi2" + [(set (match_operand:HI 0 "register_operand" "") + (unsigned_fix:HI (match_operand:HF 1 "register_operand" "")))] + "" + " + { + rtx reg1 = gen_reg_rtx (HFmode); + rtx reg2 = gen_reg_rtx (HFmode); + rtx reg3 = gen_reg_rtx (HImode); + rtx label1 = gen_label_rtx (); + rtx label2 = gen_label_rtx (); + REAL_VALUE_TYPE offset = REAL_VALUE_LDEXP (1.0, 31); + + if (reg1) /* turn off complaints about unreached code */ + { + emit_move_insn (reg1, immed_real_const_1 (offset, HFmode)); + do_pending_stack_adjust (); + + emit_insn (gen_cmphf (operands[1], reg1)); + emit_jump_insn (gen_bge (label1)); + + emit_insn (gen_fix_trunchfhi2 (operands[0], operands[1])); + emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx, + gen_rtx (LABEL_REF, VOIDmode, label2))); + emit_barrier (); + + emit_label (label1); + emit_insn (gen_subhf3 (reg2, operands[1], reg1)); + emit_move_insn (reg3, GEN_INT (0x80000000));; + + emit_insn (gen_fix_trunchfhi2 (operands[0], reg2)); + emit_insn (gen_iorhi3 (operands[0], operands[0], reg3)); + + emit_label (label2); + + /* allow REG_NOTES to be set on last insn (labels don't have enough + fields, and can't be used for REG_NOTES anyway). */ + emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx)); + DONE; + } + }") + + ;; + ;; SHIFT INSTRUCTIONS + ;; + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 1)))] + "" + "%0=%1>>1" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 4)))] + "" + "%0=%1>>4" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 8)))] + "" + "%0=%1>>8" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 16)))] + "" + "%0=%1>>16" + [(set_attr "type" "special")]) + + ;; + ;; Arithmetic Right shift + + (define_expand "ashrhi3" + [(set (match_operand:HI 0 "register_operand" "") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!TARGET_BMU) + { + /* If we are shifting by a constant we can do it in 1 or more + 1600 core shift instructions. The core instructions can + shift by 1, 4, 8, or 16. */ + + if (GET_CODE(operands[2]) == CONST_INT) + ; + else + { + rtx label1 = gen_label_rtx (); + rtx label2 = gen_label_rtx (); + + #if 0 + if (!dsp16xx_ashrhi3_libcall) + dsp16xx_ashrhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, ASHRHI3_LIBCALL); + + emit_library_call (dsp16xx_ashrhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + #else + do_pending_stack_adjust (); + emit_insn (gen_tstqi (operands[2])); + emit_jump_insn (gen_bne (label1)); + emit_move_insn (operands[0], operands[1]); + emit_jump_insn (gen_jump (label2)); + emit_barrier (); + emit_label (label1); + + if (GET_CODE(operands[2]) != MEM) + { + rtx stack_slot; + + stack_slot = assign_stack_temp (QImode, GET_MODE_SIZE(QImode), 0); + stack_slot = change_address (stack_slot, VOIDmode, XEXP (stack_slot, 0)); + emit_move_insn (stack_slot, operands[2]); + operands[2] = stack_slot; + } + + emit_insn (gen_match_ashrhi3_nobmu (operands[0], operands[1], operands[2])); + emit_label (label2); + DONE; + #endif + } + } + }") + + (define_insn "match_ashrhi3_bmu" + [(set (match_operand:HI 0 "register_operand" "=A,A,A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A,A,!A") + (match_operand:QI 2 "nonmemory_operand" "B,I,h")))] + "TARGET_BMU" + "@ + %0=%1>>%2 + %0=%1>>%H2 + %0=%1>>%2" + [(set_attr "type" "shift,shift_i,shift")]) + + (define_insn "match_ashrhi3_nobmu" + [(set (match_operand:HI 0 "register_operand" "=A,A") + (ashiftrt:HI (match_operand:HI 1 "register_operand" "A,0") + (match_operand:QI 2 "general_operand" "n,m")))] + "!TARGET_BMU" + "* + { + if (which_alternative == 0) + { + emit_1600_core_shift (ASHIFTRT, operands, INTVAL(operands[2])); + return \"\"; + } + else + { + output_asm_insn (\"cloop=%2\", operands); + output_asm_insn (\"do 0 \{\", operands); + output_asm_insn (\"%0=%0>>1\", operands); + return \"\}\"; + } + }") + + + + ;; + ;; Logical Right Shift + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 1)))] + "" + "%0=%1>>1\;%0=%b0&0x7fff" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 4)))] + "" + "%0=%1>>4\;%0=%b0&0x0fff" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 8)))] + "" + "%0=%1>>8\;%0=%b0&0x00ff" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A") + (const_int 16)))] + "" + "%0=%1>>16\;%0=%b0&0x0000" + [(set_attr "type" "special")]) + + (define_expand "lshrhi3" + [(set (match_operand:HI 0 "register_operand" "") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!TARGET_BMU) + { + /* If we are shifting by a constant we can do it in 1 or more + 1600 core shift instructions. The core instructions can + shift by 1, 4, 8, or 16. */ + + if (GET_CODE(operands[2]) == CONST_INT) + emit_insn (gen_match_lshrhi3_nobmu (operands[0], operands[1], operands[2])); + else + { + rtx label1 = gen_label_rtx (); + rtx label2 = gen_label_rtx (); + #if 0 + if (!dsp16xx_lshrhi3_libcall) + dsp16xx_lshrhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, LSHRHI3_LIBCALL); + + emit_library_call (dsp16xx_lshrhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + #else + do_pending_stack_adjust (); + emit_insn (gen_tstqi (operands[2])); + emit_jump_insn (gen_bne (label1)); + emit_move_insn (operands[0], operands[1]); + emit_jump_insn (gen_jump (label2)); + emit_barrier (); + emit_label (label1); + + if (GET_CODE(operands[2]) != MEM) + { + rtx stack_slot; + + stack_slot = assign_stack_temp (QImode, GET_MODE_SIZE(QImode), 0); + stack_slot = change_address (stack_slot, VOIDmode, XEXP (stack_slot, 0)); + emit_move_insn (stack_slot, operands[2]); + operands[2] = stack_slot; + } + + emit_insn (gen_match_lshrhi3_nobmu (operands[0], operands[1], operands[2])); + emit_label (label2); + DONE; + #endif + } + } + }") + + (define_insn "match_lshrhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A,A,!A") + (match_operand:QI 2 "nonmemory_operand" "B,I,h")))] + "TARGET_BMU" + "@ + %0=%1>>>%2 + %0=%1>>>%H2 + %0=%1>>>%2" + [(set_attr "type" "shift,shift_i,shift")]) + + (define_insn "match_lshrhi3_nobmu" + [(set (match_operand:HI 0 "register_operand" "=A,A") + (lshiftrt:HI (match_operand:HI 1 "register_operand" "A,0") + (match_operand:QI 2 "general_operand" "n,m"))) + (clobber (match_scratch:QI 3 "=X,Y"))] + "!TARGET_BMU" + "* + { + if (which_alternative == 0) + { + emit_1600_core_shift (LSHIFTRT, operands, INTVAL(operands[2])); + return \"\"; + } + else + { + output_asm_insn (\"%3=psw\;psw=0\",operands); + output_asm_insn (\"cloop=%2\", operands); + output_asm_insn (\"do 0 \{\", operands); + output_asm_insn (\"%0=%0>>1\", operands); + output_asm_insn (\"\}\", operands); + return \"psw=%3\"; + } + }") + + + ;; + ;; Arithmetic Left shift + + ;; Start off with special case arithmetic left shift by 1,4,8 or 16. + + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "register_operand" "A") + (const_int 1)))] + "" + "%0=%1<<1" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "register_operand" "A") + (const_int 4)))] + "" + "%0=%1<<4" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "register_operand" "A") + (const_int 8)))] + "" + "%0=%1<<8" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (zero_extend:HI (match_operand:QI 1 "register_operand" "A")) + (const_int 16)))] + "" + "%0=%1<<16" + [(set_attr "type" "special")]) + + (define_insn "" + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "general_operand" "A") + (const_int 16)))] + "" + "%0=%1<<16" + [(set_attr "type" "special")]) + + + + ;; Normal Arithmetic Shift Left + + + (define_expand "ashlhi3" + [(set (match_operand:HI 0 "register_operand" "") + (ashift:HI (match_operand:HI 1 "register_operand" "") + (match_operand:QI 2 "nonmemory_operand" "")))] + "" + " + { + if (!TARGET_BMU) + { + /* If we are shifting by a constant we can do it in 1 or more + 1600 core shift instructions. The core instructions can + shift by 1, 4, 8, or 16. */ + + if (GET_CODE(operands[2]) == CONST_INT) + ; + else + { + rtx label1 = gen_label_rtx (); + rtx label2 = gen_label_rtx (); + #if 0 + if (!dsp16xx_ashlhi3_libcall) + dsp16xx_ashlhi3_libcall = gen_rtx (SYMBOL_REF, Pmode, ASHLHI3_LIBCALL); + + emit_library_call (dsp16xx_ashlhi3_libcall, 1, HImode, 2, + operands[1], HImode, + operands[2], QImode); + emit_move_insn (operands[0], hard_libcall_value(HImode)); + DONE; + #else + do_pending_stack_adjust (); + emit_insn (gen_tstqi (operands[2])); + emit_jump_insn (gen_bne (label1)); + emit_move_insn (operands[0], operands[1]); + emit_jump_insn (gen_jump (label2)); + emit_barrier (); + emit_label (label1); + + if (GET_CODE(operands[2]) != MEM) + { + rtx stack_slot; + + stack_slot = assign_stack_temp (QImode, GET_MODE_SIZE(QImode), 0); + stack_slot = change_address (stack_slot, VOIDmode, XEXP (stack_slot, 0)); + emit_move_insn (stack_slot, operands[2]); + operands[2] = stack_slot; + } + emit_insn (gen_match_ashlhi3_nobmu (operands[0], operands[1], operands[2])); + emit_label (label2); + DONE; + #endif + } + } + }") + + (define_insn "match_ashlhi3" + [(set (match_operand:HI 0 "register_operand" "=A,A,A") + (ashift:HI (match_operand:HI 1 "register_operand" "A,A,A") + (match_operand:QI 2 "nonmemory_operand" "B,I,!h")))] + "TARGET_BMU" + "@ + %0=%1<<%2\;move %u0=%u0 + %0=%1<<%H2\;move %u0=%u0 + %0=%1<<%2\;move %u0=%u0" + [(set_attr "type" "shift,shift_i,shift")]) + + (define_insn "match_ashlhi3_nobmu" + [(set (match_operand:HI 0 "register_operand" "=A,A") + (ashift:HI (match_operand:HI 1 "register_operand" "A,0") + (match_operand:QI 2 "general_operand" "n,m")))] + "!TARGET_BMU" + "* + { + if (which_alternative == 0) + { + emit_1600_core_shift (ASHIFT, operands, INTVAL(operands[2])); + return \"\"; + } + else + { + output_asm_insn (\"cloop=%2\", operands); + output_asm_insn (\"do 0 \{\", operands); + output_asm_insn (\"%0=%0<<1\", operands); + return \"\}\"; + } + }") + + + + ;; + ;; Jump Instructions + ;; + + (define_expand "beq" + [(set (pc) + (if_then_else (eq (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(EQ, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + (define_expand "bne" + [(set (pc) + (if_then_else (ne (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(NE, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bgt" + [(set (pc) + (if_then_else (gt (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(GT, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bge" + [(set (pc) + (if_then_else (ge (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(GE, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "blt" + [(set (pc) + (if_then_else (lt (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(LT, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "ble" + [(set (pc) + (if_then_else (le (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(LE, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bgtu" + [(set (pc) + (if_then_else (gtu (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(GTU, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bgeu" + [(set (pc) + (if_then_else (geu (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(GEU, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bltu" + [(set (pc) + (if_then_else (ltu (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(LTU, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_expand "bleu" + [(set (pc) + (if_then_else (leu (match_dup 1) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + " + { + if (dsp16xx_compare_gen == gen_compare_reg) + operands[1] = (*dsp16xx_compare_gen)(LEU, dsp16xx_compare_op0, dsp16xx_compare_op1); + else + operands[1] = (*dsp16xx_compare_gen)(dsp16xx_compare_op0); + }") + + + (define_insn "" + [(set (pc) + (if_then_else (match_operator 1 "comparison_operator" + [(cc0) (const_int 0)]) + (label_ref (match_operand 0 "" "")) + (pc)))] + "!TARGET_NEAR_JUMP" + "pt=%l0\;if %C1 goto pt" + [(set_attr "type" "cond_jump")]) + + (define_insn "" + [(set (pc) + (if_then_else (match_operator 1 "comparison_operator" + [(cc0) (const_int 0)]) + (label_ref (match_operand 0 "" "")) + (pc)))] + "TARGET_NEAR_JUMP" + "if %C1 goto %l0" + [(set_attr "type" "cond_jump")]) + + ;; + ;; Negated conditional jump instructions. + ;; These are necessary because jump optimization can turn + ;; direct-conditional branches into reverse-conditional + ;; branches. + + (define_insn "" + [(set (pc) + (if_then_else (match_operator 1 "comparison_operator" + [(cc0) (const_int 0)]) + (pc) + (label_ref (match_operand 0 "" ""))))] + "!TARGET_NEAR_JUMP" + "pt=%l0\;if %I1 goto pt" + [(set_attr "type" "cond_jump")]) + + (define_insn "" + [(set (pc) + (if_then_else (match_operator 1 "comparison_operator" + [(cc0) (const_int 0)]) + (pc) + (label_ref (match_operand 0 "" ""))))] + "TARGET_NEAR_JUMP" + "if %I1 goto %l0" + [(set_attr "type" "cond_jump")]) + + + ;; + ;; JUMPS + ;; + + (define_insn "jump" + [(set (pc) + (label_ref (match_operand 0 "" "")))] + "" + "* + { + if (TARGET_NEAR_JUMP) + return \"goto %l0\"; + else + return \"pt=%l0\;goto pt\"; + }" + [(set_attr "type" "jump")]) + + + (define_insn "indirect_jump" + [(set (pc) (match_operand:QI 0 "register_operand" "A"))] + "" + "pt=%0\;goto pt" + [(set_attr "type" "jump")]) + + (define_insn "tablejump" + [(set (pc) (match_operand:QI 0 "register_operand" "A")) + (use (label_ref (match_operand 1 "" "")))] + "" + "pt=%0\;goto pt" + [(set_attr "type" "jump")]) + + ;; + ;; FUNCTION CALLS + ;; + + ;; Call subroutine with no return value. + + + (define_expand "call" + [(parallel [(call (match_operand:QI 0 "" "") + (match_operand 1 "" "")) + (clobber (reg:QI 24))])] + "" + " + { + if (GET_CODE (operands[0]) == MEM + && ! call_address_operand (XEXP (operands[0], 0), QImode)) + operands[0] = gen_rtx (MEM, GET_MODE (operands[0]), + force_reg (Pmode, XEXP (operands[0], 0))); + }") + + (define_insn "" + [(parallel [(call (mem:QI (match_operand:QI 0 "call_address_operand" "hR")) + (match_operand 1 "" "")) + (clobber (reg:QI 24))])] + "" + "* + { + if (GET_CODE (operands[0]) == REG || + (GET_CODE(operands[0]) == SYMBOL_REF && !TARGET_NEAR_CALL)) + return \"pt=%0\;call pt\"; + else + return \"call %0\"; + }" + [(set_attr "type" "call")]) + + ;; Call subroutine with return value. + + (define_expand "call_value" + [(parallel [(set (match_operand 0 "register_operand" "=f") + (call (match_operand:QI 1 "call_address_operand" "hR") + (match_operand:QI 2 "" ""))) + (clobber (reg:QI 24))])] + "" + " + { + if (GET_CODE (operands[1]) == MEM + && ! call_address_operand (XEXP (operands[1], 0), QImode)) + operands[1] = gen_rtx (MEM, GET_MODE (operands[1]), + force_reg (Pmode, XEXP (operands[1], 0))); + }") + + (define_insn "" + [(parallel [(set (match_operand 0 "register_operand" "=f") + (call (mem:QI (match_operand:QI 1 "call_address_operand" "hR")) + (match_operand:QI 2 "" ""))) + (clobber (reg:QI 24))])] + "" + "* + { + if (GET_CODE (operands[1]) == REG || + (GET_CODE(operands[1]) == SYMBOL_REF && !TARGET_NEAR_CALL)) + return \"pt=%1\;call pt\"; + else + return \"call %1\"; + }" + [(set_attr "type" "call")]) + + + (define_expand "untyped_call" + [(parallel [(call (match_operand 0 "" "") + (const_int 0)) + (match_operand 1 "" "") + (match_operand 2 "" "")])] + "" + " + { + int i; + + emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx)); + + for (i = 0; i < XVECLEN (operands[2], 0); i++) + { + rtx set = XVECEXP (operands[2], 0, i); + emit_move_insn (SET_DEST (set), SET_SRC (set)); + } + + /* The optimizer does not know that the call sets the function value + registers we stored in the result block. We avoid problems by + claiming that all hard registers are used and clobbered at this + point. */ + emit_insn (gen_blockage ()); + + DONE; + }") + + ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and + ;; all of memory. This blocks insns from being moved across this point. + + (define_insn "blockage" + [(unspec_volatile [(const_int 0)] 0)] + "" + "") + + (define_insn "nop" + [(const_int 0)] + "" + "nop" + [(set_attr "type" "nop")]) + + ;; + ;; PEEPHOLE PATTERNS + ;; + + + (define_peephole + [(set (match_operand:QI 0 "register_operand" "=A") + (reg:QI 16)) + (call (mem:QI (match_dup 0)) + (match_operand 1 "" "i"))] + "" + "call pt") + + + (define_peephole + [(set (match_operand:QI 0 "register_operand" "=A") + (reg:QI 16)) + (set (match_operand 1 "" "") + (call (mem:QI (match_dup 0)) + (match_operand 2 "" "i")))] + "" + "call pt") + + (define_peephole + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "register_operand" "A") + (const_int 16))) + (set (match_operand:HI 2 "register_operand" "") + (match_dup 0)) + (set (match_dup 0) + (ashiftrt:HI (match_dup 0) (const_int 16))) + (set (match_dup 2) + (match_dup 0))] + "" + "%0=%1<<16\;%0=%0>>16\;%u2=%u0\;%w2=%w0") + + (define_peephole + [(set (match_operand:HI 0 "register_operand" "=A") + (ashift:HI (match_operand:HI 1 "register_operand" "A") + (const_int 16))) + (set (match_operand:HI 2 "register_operand" "") + (match_dup 0)) + (set (match_dup 0) + (lshiftrt:HI (match_dup 0) (const_int 16))) + (set (match_dup 2) + (match_dup 0))] + "" + "%0=%1<<16\;%0=%0>>16\;%0=%b0&0x0000\;%u2=%u0\;%w2=%w0") diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/dsp16xx/xm-dsp16xx.h gcc-2.6.1/config/dsp16xx/xm-dsp16xx.h *** gcc-2.6.0/config/dsp16xx/xm-dsp16xx.h --- gcc-2.6.1/config/dsp16xx/xm-dsp16xx.h Fri Sep 9 13:27:54 1994 *************** *** 0 **** --- 1,45 ---- + /* Configuration file for GNU CC for AT&T DSP1600. + Copyright (C) 1993 Free Software Foundation, Inc. + Contributed by Michael Collison (collison@world.std.com). + + 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 1, 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. */ + + /* #defines that need visibility everywhere. */ + #define FALSE 0 + #define TRUE 1 + + /* This describes the machine the compiler is hosted on. */ + #define HOST_BITS_PER_CHAR 8 + #define HOST_BITS_PER_SHORT 16 + #define HOST_BITS_PER_INT 16 + #define HOST_BITS_PER_LONG 32 + #define HOST_BITS_PER_LONGLONG 64 + + /* Arguments to use with `exit'. */ + #define SUCCESS_EXIT_CODE 0 + #define FATAL_EXIT_CODE 33 + + /* If compiled with GNU C, use the built-in alloca */ + #ifdef __GNUC__ + #define alloca __builtin_alloca + #else + #define USE_C_ALLOCA + #endif + + /* target machine dependencies. + tm.h is a symbolic link to the actual target specific file. */ + #include "tm.h" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/fp-bit.c gcc-2.6.1/config/fp-bit.c *** gcc-2.6.0/config/fp-bit.c Mon Jul 11 18:31:20 1994 --- gcc-2.6.1/config/fp-bit.c Mon Sep 12 14:25:17 1994 *************** *** 1,7 **** /* This is a software floating point library which can be used instead of the floating point routines in libgcc1.c for targets without hardware ! floating point. ! This implements IEEE 754 format arithmetic, but does not provide a mechanism for setting the rounding mode, or for generating or handling exceptions. --- 1,38 ---- /* This is a software floating point library which can be used instead of the floating point routines in libgcc1.c for targets without hardware ! floating point. */ ! /* Copyright (C) 1994 Free Software Foundation, Inc. ! ! This file 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. ! ! In addition to the permissions in the GNU General Public License, the ! Free Software Foundation gives you unlimited permission to link the ! compiled version of this file with other programs, and to distribute ! those programs without any restriction coming from the use of this ! file. (The General Public License restrictions do apply in other ! respects; for example, they cover modification of the file, and ! distribution when not linked into another program.) ! ! This file 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 this program; see the file COPYING. If not, write to ! the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ ! ! /* As a special exception, if you link this library with other files, ! some of which are compiled with GCC, to produce an executable, ! this library does not by itself cause the resulting executable ! to be covered by the GNU General Public License. ! This exception does not however invalidate any other reasons why ! the executable file might be covered by the GNU General Public License. */ ! ! /* This implements IEEE 754 format arithmetic, but does not provide a mechanism for setting the rounding mode, or for generating or handling exceptions. *************** *** 8,15 **** The original code by Steve Chamberlain, hacked by Mark Eichin and Jim ! Wilson, all of Cygnus Support. - This file is in the public domain. */ - /* The intended way to use this file is to make two copies, add `#define FLOAT' to one copy, then compile both copies and add them to libgcc.a. */ --- 39,44 ---- The original code by Steve Chamberlain, hacked by Mark Eichin and Jim ! Wilson, all of Cygnus Support. */ /* The intended way to use this file is to make two copies, add `#define FLOAT' to one copy, then compile both copies and add them to libgcc.a. */ *************** *** 207,212 **** } fp_number_type; ! typedef ! union { FLO_type value; --- 236,240 ---- } fp_number_type; ! typedef union { FLO_type value; *************** *** 217,227 **** { #ifndef FLOAT_BIT_ORDER_MISMATCH ! unsigned int sign:1; ! unsigned int exp:EXPBITS; ! fractype fraction:FRACBITS; #else ! fractype fraction:FRACBITS; ! unsigned int exp:EXPBITS; ! unsigned int sign:1; #endif } --- 245,255 ---- { #ifndef FLOAT_BIT_ORDER_MISMATCH ! unsigned int sign:1 __attribute__ ((packed)); ! unsigned int exp:EXPBITS __attribute__ ((packed)); ! fractype fraction:FRACBITS __attribute__ ((packed)); #else ! fractype fraction:FRACBITS __attribute__ ((packed)); ! unsigned int exp:EXPBITS __attribute__ ((packed)); ! unsigned int sign:1 __attribute__ ((packed)); #endif } *************** *** 228,232 **** bits; } - FLO_union_type; --- 256,259 ---- *************** *** 688,694 **** /* Doing a 64*64 to 128 */ { ! UDItype nl = a->fraction.ll; UDItype nh = a->fraction.ll >> 32; ! UDItype ml = b->fraction.ll; UDItype mh = b->fraction.ll >>32; UDItype pp_ll = ml * nl; --- 715,721 ---- /* Doing a 64*64 to 128 */ { ! UDItype nl = a->fraction.ll & 0xffffffff; UDItype nh = a->fraction.ll >> 32; ! UDItype ml = b->fraction.ll & 0xffffffff; UDItype mh = b->fraction.ll >>32; UDItype pp_ll = ml * nl; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/fx80/fx80.h gcc-2.6.1/config/fx80/fx80.h *** gcc-2.6.0/config/fx80/fx80.h Sun Apr 10 06:59:14 1994 --- gcc-2.6.1/config/fx80/fx80.h Sat Jul 30 14:11:43 1994 *************** *** 1268,1272 **** else \ fprintf (FILE, "#0x%x", u1.i); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ --- 1268,1272 ---- else \ fprintf (FILE, "#0x%x", u1.i); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/fx80/fx80.md gcc-2.6.1/config/fx80/fx80.md *** gcc-2.6.0/config/fx80/fx80.md Sun Apr 10 07:07:41 1994 --- gcc-2.6.1/config/fx80/fx80.md Wed Aug 17 17:40:28 1994 *************** *** 2239,2247 **** (define_expand "casesi_2" ! [(set (match_operand:SI 0 "" "") (mem:HI (match_operand:SI 1 "" ""))) ;; The USE here is so that at least one jump-insn will refer to the label, ;; to keep it alive in jump_optimize. (parallel [(set (pc) ! (plus:SI (pc) (match_dup 0))) (use (label_ref (match_operand 2 "" "")))])] "" --- 2239,2247 ---- (define_expand "casesi_2" ! [(set (match_operand:HI 0 "" "") (mem:HI (match_operand:SI 1 "" ""))) ;; The USE here is so that at least one jump-insn will refer to the label, ;; to keep it alive in jump_optimize. (parallel [(set (pc) ! (plus:SI (pc) (sign_extend:SI (match_dup 0)))) (use (label_ref (match_operand 2 "" "")))])] "" *************** *** 2254,2258 **** ;; We don't use these for generating the RTL, but we must describe ;; the operands here. ! [(match_operand:SI 0 "general_operand" "") (match_operand:SI 1 "immediate_operand" "") (match_operand:SI 2 "general_operand" "") --- 2254,2258 ---- ;; We don't use these for generating the RTL, but we must describe ;; the operands here. ! [(match_operand:HI 0 "general_operand" "") (match_operand:SI 1 "immediate_operand" "") (match_operand:SI 2 "general_operand" "") *************** *** 2286,2290 **** (define_insn "" [(set (pc) ! (plus:SI (pc) (match_operand:HI 0 "general_operand" "r"))) (use (label_ref (match_operand 1 "" "")))] "" --- 2286,2291 ---- (define_insn "" [(set (pc) ! (plus:SI (pc) ! (sign_extend:SI (match_operand:HI 0 "general_operand" "r")))) (use (label_ref (match_operand 1 "" "")))] "" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/gmicro/gmicro.h gcc-2.6.1/config/gmicro/gmicro.h *** gcc-2.6.0/config/gmicro/gmicro.h Sat Oct 2 04:18:01 1993 --- gcc-2.6.1/config/gmicro/gmicro.h Sat Jul 30 15:04:14 1994 *************** *** 1,7 **** /* Definitions of target machine for GNU compiler. Gmicro (TRON) version. - Ported by Masanobu Yuhara, Fujitsu Laboratories LTD. - (yuhara@flab.fujitsu.co.jp) - Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,6 ---- /* Definitions of target machine for GNU compiler. Gmicro (TRON) version. Copyright (C) 1987, 1988, 1989 Free Software Foundation, Inc. + Contributed by Masanobu Yuhara, Fujitsu Laboratories LTD. + (yuhara@flab.fujitsu.co.jp) This file is part of GNU CC. *************** *** 17,27 **** GNU General Public License for more details. - Among other things, the copyright - notice and this notice must be preserved on all copies. - 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. ! */ --- 16,22 ---- 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. */ *************** *** 1585,1589 **** else \ fprintf (FILE, "#h'%x", u1.i); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ --- 1580,1584 ---- else \ fprintf (FILE, "#h'%x", u1.i); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/h8300/h8300.c gcc-2.6.1/config/h8300/h8300.c *** gcc-2.6.0/config/h8300/h8300.c Mon Jul 11 18:47:11 1994 --- gcc-2.6.1/config/h8300/h8300.c Tue Jul 19 20:30:00 1994 *************** *** 1107,1110 **** --- 1107,1111 ---- break; case SImode: + case SFmode: fprintf (file, "%s", names_extended[REGNO (x)]); break; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/h8300/h8300.md gcc-2.6.1/config/h8300/h8300.md *** gcc-2.6.0/config/h8300/h8300.md Mon Jul 11 18:47:18 1994 --- gcc-2.6.1/config/h8300/h8300.md Fri Jul 22 14:32:11 1994 *************** *** 808,812 **** [(set (match_operand:HI 0 "register_operand" "=r") (and:HI (match_operand:HI 1 "register_operand" "%0") ! (match_operand:HI 2 "nonmemory_operand" "ri")))] "" "* --- 808,812 ---- [(set (match_operand:HI 0 "register_operand" "=r") (and:HI (match_operand:HI 1 "register_operand" "%0") ! (match_operand:HI 2 "nonmemory_operand" "rn")))] "" "* *************** *** 873,877 **** [(set (match_operand:HI 0 "general_operand" "=r,r") (ior:HI (match_operand:HI 1 "general_operand" "%0,0") ! (match_operand:HI 2 "general_operand" "J,ri")))] "" "* --- 873,877 ---- [(set (match_operand:HI 0 "general_operand" "=r,r") (ior:HI (match_operand:HI 1 "general_operand" "%0,0") ! (match_operand:HI 2 "general_operand" "J,rn")))] "" "* *************** *** 962,966 **** [(set (match_operand:HI 0 "register_operand" "=r") (xor:HI (match_operand:HI 1 "general_operand" "%0") ! (match_operand:HI 2 "nonmemory_operand" "ri")))] "" "* --- 962,966 ---- [(set (match_operand:HI 0 "register_operand" "=r") (xor:HI (match_operand:HI 1 "general_operand" "%0") ! (match_operand:HI 2 "nonmemory_operand" "rn")))] "" "* diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/h8300/lib1funcs.asm gcc-2.6.1/config/h8300/lib1funcs.asm *** gcc-2.6.0/config/h8300/lib1funcs.asm Mon Jul 11 18:44:44 1994 --- gcc-2.6.1/config/h8300/lib1funcs.asm Sat Jul 16 16:44:14 1994 *************** *** 2,7 **** ;; Contributed by Steve Chamberlain. ;; sac@cygnus.com - ;; This file is in the public domain. /* Assembler register definitions. */ --- 2,37 ---- ;; Contributed by Steve Chamberlain. ;; sac@cygnus.com + /* Copyright (C) 1994 Free Software Foundation, Inc. + + This file 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. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file with other programs, and to distribute + those programs without any restriction coming from the use of this + file. (The General Public License restrictions do apply in other + respects; for example, they cover modification of the file, and + distribution when not linked into another program.) + + This file 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 this program; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + /* Assembler register definitions. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i370/mvs.h gcc-2.6.1/config/i370/mvs.h *** gcc-2.6.0/config/i370/mvs.h Sun Oct 3 15:42:13 1993 --- gcc-2.6.1/config/i370/mvs.h Wed Jul 27 19:05:26 1994 *************** *** 1171,1184 **** if (j % MVS_ASCII_TEXT_LENGTH == 0) \ fprintf (FILE, "\tDC\tC'%c", c); \ ! else \ ! { \ ! if ( c == '\'' ) \ ! fprintf (FILE, "%c%c", c, c); \ ! else \ ! fprintf (FILE, "%c", c); \ ! if (j % MVS_ASCII_TEXT_LENGTH \ ! == MVS_ASCII_TEXT_LENGTH - 1) \ ! fprintf (FILE, "'\n" ); \ ! } \ } \ } \ --- 1171,1180 ---- if (j % MVS_ASCII_TEXT_LENGTH == 0) \ fprintf (FILE, "\tDC\tC'%c", c); \ ! if ( c == '\'' ) \ ! fprintf (FILE, "%c%c", c, c); \ ! else \ ! fprintf (FILE, "%c", c); \ ! if (j % MVS_ASCII_TEXT_LENGTH == MVS_ASCII_TEXT_LENGTH - 1) \ ! fprintf (FILE, "'\n" ); \ } \ } \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/bsd386.h gcc-2.6.1/config/i386/bsd386.h *** gcc-2.6.0/config/i386/bsd386.h --- gcc-2.6.1/config/i386/bsd386.h Mon Jul 25 08:52:41 1994 *************** *** 0 **** --- 1,18 ---- + /* Configuration for an i386 running BSDI's BSD/386 1.1 as the target + machine. */ + + #include "i386/386bsd.h" + + /* We exist mostly to add -Dbsdi and such to the predefines. */ + + #undef CPP_PREDEFINES + #define CPP_PREDEFINES "-Dunix -Di386 -Dbsdi -D__i386__ -D__bsdi__ -D____386BSD____ -D__386BSD__ -DBSD_NET2 -Asystem(unix) -Asystem(bsd) -Acpu(i386) -Amachine(i386)" + + #undef WCHAR_TYPE + #define WCHAR_TYPE "int" + + #undef WCHAR_UNSIGNED + #define WCHAR_UNSIGNED 0 + + #undef WCHAR_TYPE_SIZE + #define WCHAR_TYPE_SIZE 32 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/config-nt.bat gcc-2.6.1/config/i386/config-nt.bat *** gcc-2.6.0/config/i386/config-nt.bat --- gcc-2.6.1/config/i386/config-nt.bat Tue Oct 11 19:10:00 1994 *************** *** 0 **** --- 1,32 ---- + echo Configuring GCC for Windows NT on Intel x86 + rem This batch file assumes a unix-type "sed" program + + copy config\i386\xm-winnt.h config.h + copy config\i386\xm-winnt.h hconfig.h + copy config\i386\xm-winnt.h tconfig.h + copy config\i386\winnt.h tm.h + copy config\i386\i386.md md + copy config\i386\i386.c aux-output.c + + rem This batch file assumes a unix-type "sed" program + + echo # Makefile generated by "config-nt.bat"> Makefile + echo all.nt: cccp.exe cc1.exe xgcc.exe ld-winnt.exe>> Makefile + sed -f config/i386/config-nt.sed Makefile.in >> Makefile + + set LANG= + + if not exist cp\make-lang.in goto no_cp + sed -f config/i386/config-nt.sed cp\make-lang.in >> Makefile + sed -f config/i386/config-nt.sed cp\makefile.in > cp\Makefile + set LANG=%LANG% c++.& + :no_cp + + echo lang.mostlyclean: %LANG% | sed "s/&/mostlyclean/g" >> Makefile + echo lang.clean: %LANG% | sed "s/&/clean/g" >> Makefile + echo lang.distclean: %LANG% | sed "s/&/distclean/g" >> Makefile + echo lang.realclean: %LANG% | sed "s/&/realclean/g" >> Makefile + + echo #define MULTILIB_SELECT ". ;" > multilib.h1 + copy multilib.h1 multilib.h + del multilib.h1 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/config-nt.sed gcc-2.6.1/config/i386/config-nt.sed *** gcc-2.6.0/config/i386/config-nt.sed --- gcc-2.6.1/config/i386/config-nt.sed Sun Oct 30 10:10:31 1994 *************** *** 0 **** --- 1,91 ---- + #/\.o[ ]*:/ s/config.status// + /^multilib.h/ s/multilib/not-multilib/ + /^target=/ c\ + target=winnt3.1 + /^xmake_file=/ d + /^tmake_file=/ d + /^version=/ c\ + version=2.6.1 + s/CC = cc/CC = cl/ + s/CFLAGS = -g/CFLAGS =/ + s/:\$/: \$/g + s/<\ *\$(srcdir)\//< $(srcdir)\\/g + s/^ \$(srcdir)\/move-if-change/ copy/ + s/^USE_/# USE_/ + s/`echo \$(srcdir)\///g + s/ | sed 's,\^\\\.\/,,'`//g + s/^ cd \$(srcdir)[ ]*;/ / + /^stamp-attrtab/,/copy/ { + /\\/d + /fi/d + /copy/ i\ + genattrtab md > tmp-attrtab.c + } + /^enquire[ ]*:/ s/\$(GCC_PARTS)//g + /^enquire.o[ ]*:/ s/\$(GCC_PASSES)//g + /^GCC_FOR_TARGET =/ c\ + GCC_FOR_TARGET = gcc + s/; *@true// + /^OBJS.*stamp-objlist/ s?`cat ../stamp-objlist`?@../stamp-objlist? + s/^\(SUBDIR_OBSTACK *=\).*$/\1 ..\/obstack.o/ + s/^\(SUBDIR_USE_ALLOCA *=\).*$/\1/ + s/^\(SUBDIR_MALLOC *=\).*$/\1/ + /####target/ i\ + EXTRA_PROGRAMS="ld-winnt.exe" \ + \ + ld.obj: $(srcdir)/config/winnt/ld.c \ + cl -D_SYSV -DWINNT -D_M_IX86_ -D_X86_ -D__STDC__=0 -DALMOST_STDC \\\ + -I. -I$(srcdir) -I$(srcdir)/config -c $(srcdir)/config/winnt/ld.c \ + \ + ld-winnt.exe: ld.obj \ + link32 -align:0x1000 -subsystem:console -entry:mainCRTStartup \\\ + -stack:1000000,1000000 -out:ld-winnt.exe ld.obj libc.lib kernel32.lib \ + copy ld-winnt.exe ld.exe + /####host/ r config/i386/x-winnt + s/^C c:/Cc:/ + s/\${OBJS}/\$(OBJS)/g + s/\${SYSTEM_HEADER_DIR}/\$(SYSTEM_HEADER_DIR)/g + s/\${HOST_CC}/\$(HOST_CC)/g + s/ \${srcdir}\// /g + s/\${mainversion}/\$(mainversion)/g + s/\ $(srcdir)\/move-if-change$// + s/\$(srcdir)\/move-if-change/copy/g + /^# USE_HOST_OBSTACK/ i\ + USE_HOST_OBSTACK=obstack.obj + /^# USE_ALLOCA/ i\ + USE_ALLOCA=alloca.obj + /^# USE_HOST_ALLOCA/ i\ + USE_HOST_ALLOCA=alloca.obj + s/^ALLOCA =/ALLOCA = alloca.obj/ + s/^ALLOCA_FINISH = true/ALLOCA_FINISH =/ + s/ \.\// / + s/^bi-\([a-z]*\) *:/bi-\1.exe :/ + s/ bi-\([a-z]*\)$/ bi-\1.exe/ + s/ bi-\([a-z]*\) / bi-\1.exe /g + s/^gen\([a-z]*\) *:/gen\1.exe :/ + s/ gen\([a-z]*\)$/ gen\1.exe/ + s/ gen\([a-z]*\) / gen\1.exe /g + s/genmultilib.exe/genmultilib/g + s/^cccp *:/cccp.exe :/ + s/cccp$/cccp.exe/ + s/cccp /cccp.exe / + s/^cpp *:/cpp.exe :/ + s/cpp$/cpp.exe/ + s/cpp /cpp.exe / + s/^cc1 *:/cc1.exe :/ + s/cc1$/cc1.exe/ + s/cc1 /cc1.exe / + s/^cc1obj *:/cc1obj.exe :/ + s/cc1obj$/cc1obj.exe/ + s/cc1obj /cc1obj.exe / + s/^xgcc *:/xgcc.exe :/ + s/xgcc$/xgcc.exe/ + s/xgcc /xgcc.exe / + s/\.o *:/.obj :/ + s/\.o$/.obj/ + s/\.o /.obj /g + s/-rm -f cpp.exe/del cpp.exe/ + s/ln cccp.exe cpp.exe/copy cccp.exe cpp.exe/ + s/\$(CC) \$(ALL_CFLAGS) \$(LDFLAGS) -o /link32 $(LDFLAGS) -out:/ + s/\$(HOST_CC) \$(HOST_CFLAGS) \$(HOST_LDFLAGS) -o /link32 $(HOST_LDFLAGS) -out:/ + s/^\ // diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/freebsd.h gcc-2.6.1/config/i386/freebsd.h *** gcc-2.6.0/config/i386/freebsd.h Thu Jul 14 12:55:33 1994 --- gcc-2.6.1/config/i386/freebsd.h Tue Oct 18 20:59:52 1994 *************** *** 224,304 **** "%{!nostdlib:%{!r*:%{!e*:-e start}}} -dc -dp %{static:-Bstatic} %{assert*}" - /* This section copied from i386/osfrose.h */ - - /* A C statement or compound statement to output to FILE some - assembler code to initialize basic-block profiling for the current - object module. This code should call the subroutine - `__bb_init_func' once per object module, passing it as its sole - argument the address of a block allocated in the object module. - - The name of the block is a local symbol made with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. - - The first word of this block is a flag which will be nonzero if the - object module has already been initialized. So test this word - first, and do not call `__bb_init_func' if the flag is nonzero. */ - - #undef FUNCTION_BLOCK_PROFILER - #define FUNCTION_BLOCK_PROFILER(STREAM, LABELNO) \ - do \ - { \ - if (!flag_pic) \ - { \ - fprintf (STREAM, "\tcmpl $0,%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl $%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tcall ___bb_init_func\n"); \ - fprintf (STREAM, "0:\n"); \ - } \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX0@GOT(%ebx),%eax\n"); \ - fprintf (STREAM, "\tcmpl $0,(%eax)\n"); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tcall ___bb_init_func@PLT\n"); \ - fprintf (STREAM, "0:\n"); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - - /* A C statement or compound statement to increment the count - associated with the basic block number BLOCKNO. Basic blocks are - numbered separately from zero within each compilation. The count - associated with block number BLOCKNO is at index BLOCKNO in a - vector of words; the name of this array is a local symbol made - with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. */ - - #undef BLOCK_PROFILER - #define BLOCK_PROFILER(STREAM, BLOCKNO) \ - do \ - { \ - if (!flag_pic) \ - fprintf (STREAM, "\tincl %sPBX2+%d\n", LPREFIX, (BLOCKNO)*4); \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX2@GOT(%ebx),%eax\n", LPREFIX); \ - fprintf (STREAM, "\tincl %d(%eax)\n", (BLOCKNO)*4); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - /* This is defined when gcc is compiled in the BSD-directory-tree, and must * make up for the gap to all the stuff done in the GNU-makefiles. --- 224,227 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/gnu.h gcc-2.6.1/config/i386/gnu.h *** gcc-2.6.0/config/i386/gnu.h --- gcc-2.6.1/config/i386/gnu.h Fri Oct 7 19:15:23 1994 *************** *** 0 **** --- 1,17 ---- + /* Configuration for an i386 running GNU as the target machine. */ + + /* We do want to add an underscore to the front of each user symbol. + i386/gas.h checks this. */ + #define YES_UNDERSCORES + + #include "i386/gstabs.h" + + /* Get perform_* macros to build libgcc.a. */ + #include "i386/perform.h" + + #undef CPP_PREDEFINES + #define CPP_PREDEFINES "-Dunix -Di386 -DMACH -Asystem(unix) -Asystem(mach) -Acpu(i386) -Amachine(i386) -D__GNU__ -D__HURD__ -Asystem(gnu)" + + /* Don't default to pcc-struct-return, because gcc is the only compiler, and + we want to retain compatibility with older gcc versions. */ + #define DEFAULT_PCC_STRUCT_RETURN 0 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/go32.h gcc-2.6.1/config/i386/go32.h *** gcc-2.6.0/config/i386/go32.h Fri Oct 29 11:48:06 1993 --- gcc-2.6.1/config/i386/go32.h Fri Jul 22 09:32:54 1994 *************** *** 1,4 **** --- 1,7 ---- /* Configuration for an i386 running MS-DOS with djgpp/go32. */ + /* Don't assume anything about the header files. */ + #define NO_IMPLICIT_EXTERN_C + #define YES_UNDERSCORES diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/i386.c gcc-2.6.1/config/i386/i386.c *** gcc-2.6.0/config/i386/i386.c Tue Apr 12 07:40:53 1994 --- gcc-2.6.1/config/i386/i386.c Fri Oct 7 15:45:14 1994 *************** *** 1,4 **** ! /* Subroutines for insn-output.c for Intel 80386. ! Copyright (C) 1988, 1992 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- ! /* Subroutines for insn-output.c for Intel X86. ! Copyright (C) 1988, 1992, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 75,80 **** generate branch and scc insns here. */ ! struct rtx_def *i386_compare_op0, *i386_compare_op1; struct rtx_def *(*i386_compare_gen)(), *(*i386_compare_gen_eq)(); /* Output an insn whose source is a 386 integer register. SRC is the --- 75,223 ---- generate branch and scc insns here. */ ! struct rtx_def *i386_compare_op0 = NULL_RTX; ! struct rtx_def *i386_compare_op1 = NULL_RTX; struct rtx_def *(*i386_compare_gen)(), *(*i386_compare_gen_eq)(); + + /* Register allocation order */ + char *i386_reg_alloc_order = (char *)0; + static char regs_allocated[FIRST_PSEUDO_REGISTER]; + + + /* Sometimes certain combinations of command options do not make + sense on a particular target machine. You can define a macro + `OVERRIDE_OPTIONS' to take account of this. This macro, if + defined, is executed once just after all the command options have + been parsed. + + Don't use this macro to turn on various extra optimizations for + `-O'. That is what `OPTIMIZATION_OPTIONS' is for. */ + + void + override_options () + { + int ch, i, regno; + + #ifdef SUBTARGET_OVERRIDE_OPTIONS + SUBTARGET_OVERRIDE_OPTIONS; + #endif + + /* Validate registers in register allocation order */ + if (i386_reg_alloc_order) + { + for (i = 0; (ch = i386_reg_alloc_order[i]) != '\0'; i++) + { + switch (ch) + { + case 'a': regno = 0; break; + case 'd': regno = 1; break; + case 'c': regno = 2; break; + case 'b': regno = 3; break; + case 'S': regno = 4; break; + case 'D': regno = 5; break; + case 'B': regno = 6; break; + + default: fatal ("Register '%c' is unknown", ch); + } + + if (regs_allocated[regno]) + fatal ("Register '%c' was already specified in the allocation order", ch); + + regs_allocated[regno] = 1; + } + } + } + + /* A C statement (sans semicolon) to choose the order in which to + allocate hard registers for pseudo-registers local to a basic + block. + + Store the desired register order in the array `reg_alloc_order'. + Element 0 should be the register to allocate first; element 1, the + next register; and so on. + + The macro body should not assume anything about the contents of + `reg_alloc_order' before execution of the macro. + + On most machines, it is not necessary to define this macro. */ + + void + order_regs_for_local_alloc () + { + int i, ch, order, regno; + + /* User specified the register allocation order */ + if (i386_reg_alloc_order) + { + for (i = order = 0; (ch = i386_reg_alloc_order[i]) != '\0'; i++) + { + switch (ch) + { + case 'a': regno = 0; break; + case 'd': regno = 1; break; + case 'c': regno = 2; break; + case 'b': regno = 3; break; + case 'S': regno = 4; break; + case 'D': regno = 5; break; + case 'B': regno = 6; break; + } + + reg_alloc_order[order++] = regno; + } + + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + { + if (!regs_allocated[i]) + reg_alloc_order[order++] = i; + } + } + + /* If users did not specify a register allocation order, favor eax + normally except if DImode variables are used, in which case + favor edx before eax, which seems to cause less spill register + not found messages. */ + else + { + rtx insn; + + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) + reg_alloc_order[i] = i; + + if (optimize) + { + int use_dca = FALSE; + + for (insn = get_insns (); insn; insn = NEXT_INSN (insn)) + { + if (GET_CODE (insn) == INSN) + { + rtx set = NULL_RTX; + rtx pattern = PATTERN (insn); + + if (GET_CODE (pattern) == SET) + set = pattern; + + else if ((GET_CODE (pattern) == PARALLEL + || GET_CODE (pattern) == SEQUENCE) + && GET_CODE (XVECEXP (pattern, 0, 0)) == SET) + set = XVECEXP (pattern, 0, 0); + + if (set && GET_MODE (SET_SRC (set)) == DImode) + { + use_dca = TRUE; + break; + } + } + } + + if (use_dca) + { + reg_alloc_order[0] = 1; /* edx */ + reg_alloc_order[1] = 2; /* ecx */ + reg_alloc_order[2] = 0; /* eax */ + } + } + } + } + /* Output an insn whose source is a 386 integer register. SRC is the *************** *** 236,239 **** --- 379,383 ---- } + /* Output an insn to add the constant N to the register X. */ *************** *** 244,260 **** { rtx xops[2]; ! xops[1] = x; ! if (n < 0) { ! xops[0] = GEN_INT (-n); ! output_asm_insn (AS2 (sub%L0,%0,%1), xops); } else if (n > 0) { ! xops[0] = GEN_INT (n); ! output_asm_insn (AS2 (add%L0,%0,%1), xops); } } /* Output assembler code to perform a doubleword move insn with operands OPERANDS. */ --- 388,410 ---- { rtx xops[2]; ! xops[0] = x; ! ! if (n == -1) ! output_asm_insn (AS1 (dec%L0,%0), xops); ! else if (n == 1) ! output_asm_insn (AS1 (inc%L0,%0), xops); ! else if (n < 0) { ! xops[1] = GEN_INT (-n); ! output_asm_insn (AS2 (sub%L0,%1,%0), xops); } else if (n > 0) { ! xops[1] = GEN_INT (n); ! output_asm_insn (AS2 (add%L0,%1,%0), xops); } } + /* Output assembler code to perform a doubleword move insn with operands OPERANDS. */ *************** *** 588,591 **** --- 738,934 ---- return ""; } + + + #define MAX_TMPS 2 /* max temporary registers used */ + + /* Output the appropriate code to move push memory on the stack */ + + char * + output_move_pushmem (operands, insn, length, tmp_start, n_operands) + rtx operands[]; + rtx insn; + int length; + int tmp_start; + int n_operands; + { + + struct { + char *load; + char *push; + rtx xops[2]; + } tmp_info[MAX_TMPS]; + + rtx src = operands[1]; + int max_tmps = 0; + int offset = 0; + int stack_p = reg_overlap_mentioned_p (stack_pointer_rtx, src); + int stack_offset = 0; + int i, num_tmps; + rtx xops[1]; + + if (!offsettable_memref_p (src)) + fatal_insn ("Source is not offsettable", insn); + + if ((length & 3) != 0) + fatal_insn ("Pushing non-word aligned size", insn); + + /* Figure out which temporary registers we have available */ + for (i = tmp_start; i < n_operands; i++) + { + if (GET_CODE (operands[i]) == REG) + { + if (reg_overlap_mentioned_p (operands[i], src)) + continue; + + tmp_info[ max_tmps++ ].xops[1] = operands[i]; + if (max_tmps == MAX_TMPS) + break; + } + } + + if (max_tmps == 0) + for (offset = length - 4; offset >= 0; offset -= 4) + { + xops[0] = adj_offsettable_operand (src, offset + stack_offset); + output_asm_insn (AS1(push%L0,%0), xops); + if (stack_p) + stack_offset += 4; + } + + else + for (offset = length - 4; offset >= 0; ) + { + for (num_tmps = 0; num_tmps < max_tmps && offset >= 0; num_tmps++) + { + tmp_info[num_tmps].load = AS2(mov%L0,%0,%1); + tmp_info[num_tmps].push = AS1(push%L0,%1); + tmp_info[num_tmps].xops[0] = adj_offsettable_operand (src, offset + stack_offset); + offset -= 4; + } + + for (i = 0; i < num_tmps; i++) + output_asm_insn (tmp_info[i].load, tmp_info[i].xops); + + for (i = 0; i < num_tmps; i++) + output_asm_insn (tmp_info[i].push, tmp_info[i].xops); + + if (stack_p) + stack_offset += 4*num_tmps; + } + + return ""; + } + + + + /* Output the appropriate code to move data between two memory locations */ + + char * + output_move_memory (operands, insn, length, tmp_start, n_operands) + rtx operands[]; + rtx insn; + int length; + int tmp_start; + int n_operands; + { + struct { + char *load; + char *store; + rtx xops[3]; + } tmp_info[MAX_TMPS]; + + rtx dest = operands[0]; + rtx src = operands[1]; + rtx qi_tmp = NULL_RTX; + int max_tmps = 0; + int offset = 0; + int i, num_tmps; + rtx xops[3]; + + if (GET_CODE (dest) == MEM + && GET_CODE (XEXP (dest, 0)) == PRE_INC + && XEXP (XEXP (dest, 0), 0) == stack_pointer_rtx) + return output_move_pushmem (operands, insn, length, tmp_start, n_operands); + + if (!offsettable_memref_p (src)) + fatal_insn ("Source is not offsettable", insn); + + if (!offsettable_memref_p (dest)) + fatal_insn ("Destination is not offsettable", insn); + + /* Figure out which temporary registers we have available */ + for (i = tmp_start; i < n_operands; i++) + { + if (GET_CODE (operands[i]) == REG) + { + if ((length & 1) != 0 && !qi_tmp && QI_REG_P (operands[i])) + qi_tmp = operands[i]; + + if (reg_overlap_mentioned_p (operands[i], dest)) + fatal_insn ("Temporary register overlaps the destination", insn); + + if (reg_overlap_mentioned_p (operands[i], src)) + fatal_insn ("Temporary register overlaps the source", insn); + + tmp_info[ max_tmps++ ].xops[2] = operands[i]; + if (max_tmps == MAX_TMPS) + break; + } + } + + if (max_tmps == 0) + fatal_insn ("No scratch registers were found to do memory->memory moves", insn); + + if ((length & 1) != 0) + { + if (!qi_tmp) + fatal_insn ("No byte register found when moving odd # of bytes.", insn); + } + + while (length > 1) + { + for (num_tmps = 0; num_tmps < max_tmps; num_tmps++) + { + if (length >= 4) + { + tmp_info[num_tmps].load = AS2(mov%L0,%1,%2); + tmp_info[num_tmps].store = AS2(mov%L0,%2,%0); + tmp_info[num_tmps].xops[0] = adj_offsettable_operand (dest, offset); + tmp_info[num_tmps].xops[1] = adj_offsettable_operand (src, offset); + offset += 4; + length -= 4; + } + else if (length >= 2) + { + tmp_info[num_tmps].load = AS2(mov%W0,%1,%2); + tmp_info[num_tmps].store = AS2(mov%W0,%2,%0); + tmp_info[num_tmps].xops[0] = adj_offsettable_operand (dest, offset); + tmp_info[num_tmps].xops[1] = adj_offsettable_operand (src, offset); + offset += 2; + length -= 2; + } + else + break; + } + + for (i = 0; i < num_tmps; i++) + output_asm_insn (tmp_info[i].load, tmp_info[i].xops); + + for (i = 0; i < num_tmps; i++) + output_asm_insn (tmp_info[i].store, tmp_info[i].xops); + } + + if (length == 1) + { + xops[0] = adj_offsettable_operand (dest, offset); + xops[1] = adj_offsettable_operand (src, offset); + xops[2] = qi_tmp; + output_asm_insn (AS2(mov%B0,%1,%2), xops); + output_asm_insn (AS2(mov%B0,%2,%0), xops); + } + + return ""; + } + int *************** *** 742,850 **** } - /* Return a legitimate reference for ORIG (an address) using the - register REG. If REG is 0, a new pseudo is generated. - - There are three types of references that must be handled: - - 1. Global data references must load the address from the GOT, via - the PIC reg. An insn is emitted to do this load, and the reg is - returned. - - 2. Static data references must compute the address as an offset - from the GOT, whose base is in the PIC reg. An insn is emitted to - compute the address into a reg, and the reg is returned. Static - data objects have SYMBOL_REF_FLAG set to differentiate them from - global data objects. - - 3. Constant pool addresses must be handled special. They are - considered legitimate addresses, but only if not used with regs. - When printed, the output routines know to print the reference with the - PIC reg, even though the PIC reg doesn't appear in the RTL. - - GO_IF_LEGITIMATE_ADDRESS rejects symbolic references unless the PIC - reg also appears in the address (except for constant pool references, - noted above). - - "switch" statements also require special handling when generating - PIC code. See comments by the `casesi' insn in i386.md for details. */ - - rtx - legitimize_pic_address (orig, reg) - rtx orig; - rtx reg; - { - rtx addr = orig; - rtx new = orig; - - if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF) - { - if (GET_CODE (addr) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (addr)) - reg = new = orig; - else - { - if (reg == 0) - reg = gen_reg_rtx (Pmode); - - if (GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_FLAG (addr)) - new = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, orig); - else - new = gen_rtx (MEM, Pmode, - gen_rtx (PLUS, Pmode, - pic_offset_table_rtx, orig)); - - emit_move_insn (reg, new); - } - current_function_uses_pic_offset_table = 1; - return reg; - } - else if (GET_CODE (addr) == CONST || GET_CODE (addr) == PLUS) - { - rtx base; - - if (GET_CODE (addr) == CONST) - { - addr = XEXP (addr, 0); - if (GET_CODE (addr) != PLUS) - abort (); - } - - if (XEXP (addr, 0) == pic_offset_table_rtx) - return orig; - - if (reg == 0) - reg = gen_reg_rtx (Pmode); - - base = legitimize_pic_address (XEXP (addr, 0), reg); - addr = legitimize_pic_address (XEXP (addr, 1), - base == reg ? NULL_RTX : reg); - - if (GET_CODE (addr) == CONST_INT) - return plus_constant (base, INTVAL (addr)); - - if (GET_CODE (addr) == PLUS && CONSTANT_P (XEXP (addr, 1))) - { - base = gen_rtx (PLUS, Pmode, base, XEXP (addr, 0)); - addr = XEXP (addr, 1); - } - return gen_rtx (PLUS, Pmode, base, addr); - } - return new; - } - - /* Emit insns to move operands[1] into operands[0]. */ - - void - emit_pic_move (operands, mode) - rtx *operands; - enum machine_mode mode; - { - rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode); - - if (GET_CODE (operands[0]) == MEM && SYMBOLIC_CONST (operands[1])) - operands[1] = (rtx) force_reg (SImode, operands[1]); - else - operands[1] = legitimize_pic_address (operands[1], temp); - } - /* This function generates the assembly code for function entry. FILE is an stdio stream to output the code to. --- 1085,1088 ---- *************** *** 940,943 **** --- 1178,1182 ---- } + /* This function generates the assembly code for function exit. FILE is an stdio stream to output the code to. *************** *** 1013,1017 **** /* On i486, mov & pop is faster than "leave". */ ! if (TARGET_486) { xops[0] = frame_pointer_rtx; --- 1252,1256 ---- /* On i486, mov & pop is faster than "leave". */ ! if (!TARGET_386) { xops[0] = frame_pointer_rtx; *************** *** 1052,1055 **** --- 1291,1815 ---- output_asm_insn ("ret", xops); } + + + /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression + that is a valid memory address for an instruction. + The MODE argument is the machine mode for the MEM expression + that wants to use this address. + + On x86, legitimate addresses are: + base movl (base),reg + displacement movl disp,reg + base + displacement movl disp(base),reg + index + base movl (base,index),reg + (index + base) + displacement movl disp(base,index),reg + index*scale movl (,index,scale),reg + index*scale + disp movl disp(,index,scale),reg + index*scale + base movl (base,index,scale),reg + (index*scale + base) + disp movl disp(base,index,scale),reg + + In each case, scale can be 1, 2, 4, 8. */ + + /* This is exactly the same as print_operand_addr, except that + it recognizes addresses instead of printing them. + + It only recognizes address in canonical form. LEGITIMIZE_ADDRESS should + convert common non-canonical forms to canonical form so that they will + be recognized. */ + + #define ADDR_INVALID(msg,insn) \ + do { \ + if (TARGET_DEBUG_ADDR) \ + { \ + fprintf (stderr, msg); \ + debug_rtx (insn); \ + } \ + } while (0) + + int + legitimate_address_p (mode, addr, strict) + enum machine_mode mode; + register rtx addr; + int strict; + { + rtx base = NULL_RTX; + rtx indx = NULL_RTX; + rtx scale = NULL_RTX; + rtx disp = NULL_RTX; + + if (TARGET_DEBUG_ADDR) + { + fprintf (stderr, + "\n==========\nGO_IF_LEGITIMATE_ADDRESS, mode = %s, strict = %d\n", + GET_MODE_NAME (mode), strict); + + debug_rtx (addr); + } + + if (GET_CODE (addr) == REG || GET_CODE (addr) == SUBREG) + base = addr; /* base reg */ + + else if (GET_CODE (addr) == PLUS) + { + rtx op0 = XEXP (addr, 0); + rtx op1 = XEXP (addr, 1); + enum rtx_code code0 = GET_CODE (op0); + enum rtx_code code1 = GET_CODE (op1); + + if (code0 == REG || code0 == SUBREG) + { + if (code1 == REG || code1 == SUBREG) + { + indx = op0; /* index + base */ + base = op1; + } + + else + { + base = op0; /* base + displacement */ + disp = op1; + } + } + + else if (code0 == MULT) + { + indx = XEXP (op0, 0); + scale = XEXP (op0, 1); + + if (code1 == REG || code1 == SUBREG) + base = op1; /* index*scale + base */ + + else + disp = op1; /* index*scale + disp */ + } + + else if (code0 == PLUS && GET_CODE (XEXP (op0, 0)) == MULT) + { + indx = XEXP (XEXP (op0, 0), 0); /* index*scale + base + disp */ + scale = XEXP (XEXP (op0, 0), 1); + base = XEXP (op0, 1); + disp = op1; + } + + else if (code0 == PLUS) + { + indx = XEXP (op0, 0); /* index + base + disp */ + base = XEXP (op0, 1); + disp = op1; + } + + else + { + ADDR_INVALID ("PLUS subcode is not valid.\n", op0); + return FALSE; + } + } + + else if (GET_CODE (addr) == MULT) + { + indx = XEXP (addr, 0); /* index*scale */ + scale = XEXP (addr, 1); + } + + else + disp = addr; /* displacement */ + + /* Allow arg pointer and stack pointer as index if there is not scaling */ + if (base && indx && !scale + && (indx == arg_pointer_rtx || indx == stack_pointer_rtx)) + { + rtx tmp = base; + base = indx; + indx = tmp; + } + + /* Validate base register */ + /* Don't allow SUBREG's here, it can lead to spill failures when the base + is one word out of a two word structure, which is represented internally + as a DImode int. */ + if (base) + { + if (GET_CODE (base) != REG) + { + ADDR_INVALID ("Base is not a register.\n", base); + return FALSE; + } + + if ((strict && !REG_OK_FOR_BASE_STRICT_P (base)) + || (!strict && !REG_OK_FOR_BASE_NONSTRICT_P (base))) + { + ADDR_INVALID ("Base is not valid.\n", base); + return FALSE; + } + } + + /* Validate index register */ + /* Don't allow SUBREG's here, it can lead to spill failures when the index + is one word out of a two word structure, which is represented internally + as a DImode int. */ + if (indx) + { + if (GET_CODE (indx) != REG) + { + ADDR_INVALID ("Index is not a register.\n", indx); + return FALSE; + } + + if ((strict && !REG_OK_FOR_INDEX_STRICT_P (indx)) + || (!strict && !REG_OK_FOR_INDEX_NONSTRICT_P (indx))) + { + ADDR_INVALID ("Index is not valid.\n", indx); + return FALSE; + } + } + else if (scale) + abort (); /* scale w/o index illegal */ + + /* Validate scale factor */ + if (scale) + { + HOST_WIDE_INT value; + + if (GET_CODE (scale) != CONST_INT) + { + ADDR_INVALID ("Scale is not valid.\n", scale); + return FALSE; + } + + value = INTVAL (scale); + if (value != 1 && value != 2 && value != 4 && value != 8) + { + ADDR_INVALID ("Scale is not a good multiplier.\n", scale); + return FALSE; + } + } + + /* Validate displacement */ + if (disp) + { + if (!CONSTANT_ADDRESS_P (disp)) + { + ADDR_INVALID ("Displacement is not valid.\n", disp); + return FALSE; + } + + if (GET_CODE (disp) == CONST_DOUBLE) + { + ADDR_INVALID ("Displacement is a const_double.\n", disp); + return FALSE; + } + + if (flag_pic && SYMBOLIC_CONST (disp) && base != pic_offset_table_rtx + && (indx != pic_offset_table_rtx || scale != NULL_RTX)) + { + ADDR_INVALID ("Displacement is an invalid pic reference.\n", disp); + return FALSE; + } + + if (HALF_PIC_P () && HALF_PIC_ADDRESS_P (disp) + && (base != NULL_RTX || indx != NULL_RTX)) + { + ADDR_INVALID ("Displacement is an invalid half-pic reference.\n", disp); + return FALSE; + } + } + + if (TARGET_DEBUG_ADDR) + fprintf (stderr, "Address is valid.\n"); + + /* Everything looks valid, return true */ + return TRUE; + } + + + /* Return a legitimate reference for ORIG (an address) using the + register REG. If REG is 0, a new pseudo is generated. + + There are three types of references that must be handled: + + 1. Global data references must load the address from the GOT, via + the PIC reg. An insn is emitted to do this load, and the reg is + returned. + + 2. Static data references must compute the address as an offset + from the GOT, whose base is in the PIC reg. An insn is emitted to + compute the address into a reg, and the reg is returned. Static + data objects have SYMBOL_REF_FLAG set to differentiate them from + global data objects. + + 3. Constant pool addresses must be handled special. They are + considered legitimate addresses, but only if not used with regs. + When printed, the output routines know to print the reference with the + PIC reg, even though the PIC reg doesn't appear in the RTL. + + GO_IF_LEGITIMATE_ADDRESS rejects symbolic references unless the PIC + reg also appears in the address (except for constant pool references, + noted above). + + "switch" statements also require special handling when generating + PIC code. See comments by the `casesi' insn in i386.md for details. */ + + rtx + legitimize_pic_address (orig, reg) + rtx orig; + rtx reg; + { + rtx addr = orig; + rtx new = orig; + + if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF) + { + if (GET_CODE (addr) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (addr)) + reg = new = orig; + else + { + if (reg == 0) + reg = gen_reg_rtx (Pmode); + + if ((GET_CODE (addr) == SYMBOL_REF && SYMBOL_REF_FLAG (addr)) + || GET_CODE (addr) == LABEL_REF) + new = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, orig); + else + new = gen_rtx (MEM, Pmode, + gen_rtx (PLUS, Pmode, + pic_offset_table_rtx, orig)); + + emit_move_insn (reg, new); + } + current_function_uses_pic_offset_table = 1; + return reg; + } + else if (GET_CODE (addr) == CONST || GET_CODE (addr) == PLUS) + { + rtx base; + + if (GET_CODE (addr) == CONST) + { + addr = XEXP (addr, 0); + if (GET_CODE (addr) != PLUS) + abort (); + } + + if (XEXP (addr, 0) == pic_offset_table_rtx) + return orig; + + if (reg == 0) + reg = gen_reg_rtx (Pmode); + + base = legitimize_pic_address (XEXP (addr, 0), reg); + addr = legitimize_pic_address (XEXP (addr, 1), + base == reg ? NULL_RTX : reg); + + if (GET_CODE (addr) == CONST_INT) + return plus_constant (base, INTVAL (addr)); + + if (GET_CODE (addr) == PLUS && CONSTANT_P (XEXP (addr, 1))) + { + base = gen_rtx (PLUS, Pmode, base, XEXP (addr, 0)); + addr = XEXP (addr, 1); + } + return gen_rtx (PLUS, Pmode, base, addr); + } + return new; + } + + + /* Emit insns to move operands[1] into operands[0]. */ + + void + emit_pic_move (operands, mode) + rtx *operands; + enum machine_mode mode; + { + rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode); + + if (GET_CODE (operands[0]) == MEM && SYMBOLIC_CONST (operands[1])) + operands[1] = (rtx) force_reg (SImode, operands[1]); + else + operands[1] = legitimize_pic_address (operands[1], temp); + } + + + /* Try machine-dependent ways of modifying an illegitimate address + to be legitimate. If we find one, return the new, valid address. + This macro is used in only one place: `memory_address' in explow.c. + + OLDX is the address as it was before break_out_memory_refs was called. + In some cases it is useful to look at this to decide what needs to be done. + + MODE and WIN are passed so that this macro can use + GO_IF_LEGITIMATE_ADDRESS. + + It is always safe for this macro to do nothing. It exists to recognize + opportunities to optimize the output. + + For the 80386, we handle X+REG by loading X into a register R and + using R+REG. R will go in a general reg and indexing will be used. + However, if REG is a broken-out memory address or multiplication, + nothing needs to be done because REG can certainly go in a general reg. + + When -fpic is used, special handling is needed for symbolic references. + See comments by legitimize_pic_address in i386.c for details. */ + + rtx + legitimize_address (x, oldx, mode) + register rtx x; + register rtx oldx; + enum machine_mode mode; + { + int changed = 0; + unsigned log; + + if (TARGET_DEBUG_ADDR) + { + fprintf (stderr, "\n==========\nLEGITIMIZE_ADDRESS, mode = %s\n", GET_MODE_NAME (mode)); + debug_rtx (x); + } + + if (flag_pic && SYMBOLIC_CONST (x)) + return legitimize_pic_address (x, 0); + + /* Canonicalize shifts by 0, 1, 2, 3 into multiply */ + if (GET_CODE (x) == ASHIFT + && GET_CODE (XEXP (x, 1)) == CONST_INT + && (log = (unsigned)exact_log2 (INTVAL (XEXP (x, 1)))) < 4) + { + changed = 1; + x = gen_rtx (MULT, Pmode, + force_reg (Pmode, XEXP (x, 0)), + GEN_INT (1 << log)); + } + + if (GET_CODE (x) == PLUS) + { + /* Canonicalize shifts by 0, 1, 2, 3 into multiply */ + if (GET_CODE (XEXP (x, 0)) == ASHIFT + && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT + && (log = (unsigned)exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) < 4) + { + changed = 1; + XEXP (x, 0) = gen_rtx (MULT, Pmode, + force_reg (Pmode, XEXP (XEXP (x, 0), 0)), + GEN_INT (1 << log)); + } + + if (GET_CODE (XEXP (x, 1)) == ASHIFT + && GET_CODE (XEXP (XEXP (x, 1), 1)) == CONST_INT + && (log = (unsigned)exact_log2 (INTVAL (XEXP (XEXP (x, 1), 1)))) < 4) + { + changed = 1; + XEXP (x, 1) = gen_rtx (MULT, Pmode, + force_reg (Pmode, XEXP (XEXP (x, 1), 0)), + GEN_INT (1 << log)); + } + + /* Put multiply first if it isn't already */ + if (GET_CODE (XEXP (x, 1)) == MULT) + { + rtx tmp = XEXP (x, 0); + XEXP (x, 0) = XEXP (x, 1); + XEXP (x, 1) = tmp; + changed = 1; + } + + /* Canonicalize (plus (mult (reg) (const)) (plus (reg) (const))) + into (plus (plus (mult (reg) (const)) (reg)) (const)). This can be + created by virtual register instantiation, register elimination, and + similar optimizations. */ + if (GET_CODE (XEXP (x, 0)) == MULT && GET_CODE (XEXP (x, 1)) == PLUS) + { + changed = 1; + x = gen_rtx (PLUS, Pmode, + gen_rtx (PLUS, Pmode, XEXP (x, 0), XEXP (XEXP (x, 1), 0)), + XEXP (XEXP (x, 1), 1)); + } + + /* Canonicalize (plus (plus (mult (reg) (const)) (plus (reg) (const))) const) + into (plus (plus (mult (reg) (const)) (reg)) (const)). */ + else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == PLUS + && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT + && GET_CODE (XEXP (XEXP (x, 0), 1)) == PLUS + && CONSTANT_P (XEXP (x, 1))) + { + rtx constant, other; + + if (GET_CODE (XEXP (x, 1)) == CONST_INT) + { + constant = XEXP (x, 1); + other = XEXP (XEXP (XEXP (x, 0), 1), 1); + } + else if (GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 1)) == CONST_INT) + { + constant = XEXP (XEXP (XEXP (x, 0), 1), 1); + other = XEXP (x, 1); + } + else + constant = 0; + + if (constant) + { + changed = 1; + x = gen_rtx (PLUS, Pmode, + gen_rtx (PLUS, Pmode, XEXP (XEXP (x, 0), 0), + XEXP (XEXP (XEXP (x, 0), 1), 0)), + plus_constant (other, INTVAL (constant))); + } + } + + if (changed && legitimate_address_p (mode, x, FALSE)) + return x; + + if (GET_CODE (XEXP (x, 0)) == MULT) + { + changed = 1; + XEXP (x, 0) = force_operand (XEXP (x, 0), 0); + } + + if (GET_CODE (XEXP (x, 1)) == MULT) + { + changed = 1; + XEXP (x, 1) = force_operand (XEXP (x, 1), 0); + } + + if (changed + && GET_CODE (XEXP (x, 1)) == REG + && GET_CODE (XEXP (x, 0)) == REG) + return x; + + if (flag_pic && SYMBOLIC_CONST (XEXP (x, 1))) + { + changed = 1; + x = legitimize_pic_address (x, 0); + } + + if (changed && legitimate_address_p (mode, x, FALSE)) + return x; + + if (GET_CODE (XEXP (x, 0)) == REG) + { + register rtx temp = gen_reg_rtx (Pmode); + register rtx val = force_operand (XEXP (x, 1), temp); + if (val != temp) + emit_move_insn (temp, val); + + XEXP (x, 1) = temp; + return x; + } + + else if (GET_CODE (XEXP (x, 1)) == REG) + { + register rtx temp = gen_reg_rtx (Pmode); + register rtx val = force_operand (XEXP (x, 0), temp); + if (val != temp) + emit_move_insn (temp, val); + + XEXP (x, 0) = temp; + return x; + } + } + + return x; + } + /* Print an integer constant expression in assembler syntax. Addition *************** *** 1090,1094 **** else if (code == 'P') fprintf (file, "@PLT"); ! else if (GET_CODE (x) == LABEL_REF || ! SYMBOL_REF_FLAG (x)) fprintf (file, "@GOT"); else --- 1850,1856 ---- else if (code == 'P') fprintf (file, "@PLT"); ! else if (GET_CODE (x) == LABEL_REF) ! fprintf (file, "@GOTOFF"); ! else if (! SYMBOL_REF_FLAG (x)) fprintf (file, "@GOT"); else *************** *** 1412,1424 **** if (addr != 0) { ! if (GET_CODE (addr) == LABEL_REF) output_asm_label (addr); else ! { ! if (flag_pic) ! output_pic_addr_const (file, addr, 0); ! else ! output_addr_const (file, addr); ! } } --- 2174,2185 ---- if (addr != 0) { ! if (flag_pic) ! output_pic_addr_const (file, addr, 0); ! ! else if (GET_CODE (addr) == LABEL_REF) output_asm_label (addr); + else ! output_addr_const (file, addr); } *************** *** 1654,1683 **** } ! /* Return 1 if this is a valid conversion operation on a 387. ! OP is the expression matched, and MODE is its mode. */ ! ! int ! convert_387_op (op, mode) ! register rtx op; ! enum machine_mode mode; ! { ! if (mode != VOIDmode && mode != GET_MODE (op)) ! return 0; ! ! switch (GET_CODE (op)) ! { ! case FLOAT: ! return GET_MODE (XEXP (op, 0)) == SImode; ! ! case FLOAT_EXTEND: ! return ((mode == DFmode && GET_MODE (XEXP (op, 0)) == SFmode) ! || (mode == XFmode && GET_MODE (XEXP (op, 0)) == DFmode) ! || (mode == XFmode && GET_MODE (XEXP (op, 0)) == SFmode)); ! ! default: ! return 0; ! } ! } ! /* Return 1 if this is a valid shift or rotate operation on a 386. OP is the expression matched, and MODE is its mode. */ --- 2415,2419 ---- } ! /* Return 1 if this is a valid shift or rotate operation on a 386. OP is the expression matched, and MODE is its mode. */ *************** *** 1801,1807 **** if (STACK_TOP_P (operands[0])) ! return strcat (buf, AS2 (,%y2,%0)); else ! return strcat (buf, AS2 (,%2,%0)); case MINUS: --- 2537,2543 ---- if (STACK_TOP_P (operands[0])) ! return strcat (buf, AS2C (%y2,%0)); else ! return strcat (buf, AS2C (%2,%0)); case MINUS: *************** *** 1836,1840 **** { if (STACK_TOP_P (operands[1])) ! return strcat (buf, AS2 (,%y2,%0)); else return strcat (buf, AS2 (r,%y1,%0)); --- 2572,2576 ---- { if (STACK_TOP_P (operands[1])) ! return strcat (buf, AS2C (%y2,%0)); else return strcat (buf, AS2 (r,%y1,%0)); *************** *** 1841,1845 **** } else if (STACK_TOP_P (operands[1])) ! return strcat (buf, AS2 (,%1,%0)); else return strcat (buf, AS2 (r,%2,%0)); --- 2577,2581 ---- } else if (STACK_TOP_P (operands[1])) ! return strcat (buf, AS2C (%1,%0)); else return strcat (buf, AS2 (r,%2,%0)); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/i386.h gcc-2.6.1/config/i386/i386.h *** gcc-2.6.0/config/i386/i386.h Thu Jun 16 06:36:31 1994 --- gcc-2.6.1/config/i386/i386.h Wed Oct 19 16:52:09 1994 *************** *** 1,3 **** ! /* Definitions of target machine for GNU compiler for Intel 80386. Copyright (C) 1988, 1992, 1994 Free Software Foundation, Inc. --- 1,3 ---- ! /* Definitions of target machine for GNU compiler for Intel X86 (386, 486, pentium) Copyright (C) 1988, 1992, 1994 Free Software Foundation, Inc. *************** *** 63,74 **** #endif ! /* Compile 80387 insns for floating point (not library calls). */ ! #define TARGET_80387 (target_flags & 1) ! /* Compile code for an i486. */ ! #define TARGET_486 (target_flags & 2) /* Compile using ret insn that pops args. This will not work unless you use prototypes at least for all functions that can take varying numbers of args. */ ! #define TARGET_RTD (target_flags & 8) /* Compile passing first two args in regs 0 and 1. This exists only to test compiler features that will --- 63,90 ---- #endif ! /* Masks for the -m switches */ ! #define MASK_80387 000000000001 /* Hardware floating point */ ! #define MASK_486 000000000002 /* 80486 specific */ ! #define MASK_NOTUSED 000000000004 /* bit not currently used */ ! #define MASK_RTD 000000000010 /* Use ret that pops args */ ! #define MASK_REGPARM 000000000020 /* Pass args in eax, edx */ ! #define MASK_SVR3_SHLIB 000000000040 /* Uninit locals into bss */ ! #define MASK_IEEE_FP 000000000100 /* IEEE fp comparisons */ ! #define MASK_FLOAT_RETURNS 000000000200 /* Return float in st(0) */ ! #define MASK_NO_FANCY_MATH_387 000000000400 /* Disable sin, cos, sqrt */ ! ! /* Temporary codegen switches */ ! #define MASK_DEBUG_ADDR 000001000000 /* Debug GO_IF_LEGITIMATE_ADDRESS */ ! #define MASK_NO_WIDE_MULTIPLY 000002000000 /* Disable 32x32->64 multiplies */ ! #define MASK_NO_MOVE 000004000000 /* Don't generate mem->mem */ ! ! /* Use the floating point instructions */ ! #define TARGET_80387 (target_flags & MASK_80387) ! /* Compile using ret insn that pops args. This will not work unless you use prototypes at least for all functions that can take varying numbers of args. */ ! #define TARGET_RTD (target_flags & MASK_RTD) ! /* Compile passing first two args in regs 0 and 1. This exists only to test compiler features that will *************** *** 75,83 **** be needed for RISC chips. It is not usable and is not intended to be usable on this cpu. */ ! #define TARGET_REGPARM (target_flags & 020) /* Put uninitialized locals into bss, not data. Meaningful only on svr3. */ ! #define TARGET_SVR3_SHLIB (target_flags & 040) /* Use IEEE floating point comparisons. These handle correctly the cases --- 91,99 ---- be needed for RISC chips. It is not usable and is not intended to be usable on this cpu. */ ! #define TARGET_REGPARM (target_flags & MASK_RTD) /* Put uninitialized locals into bss, not data. Meaningful only on svr3. */ ! #define TARGET_SVR3_SHLIB (target_flags & MASK_SVR3_SHLIB) /* Use IEEE floating point comparisons. These handle correctly the cases *************** *** 84,88 **** where the result of a comparison is unordered. Normally SIGFPE is generated in such cases, in which case this isn't needed. */ ! #define TARGET_IEEE_FP (target_flags & 0100) /* Functions that return a floating point value may return that value --- 100,104 ---- where the result of a comparison is unordered. Normally SIGFPE is generated in such cases, in which case this isn't needed. */ ! #define TARGET_IEEE_FP (target_flags & MASK_IEEE_FP) /* Functions that return a floating point value may return that value *************** *** 89,137 **** in the 387 FPU or in 386 integer registers. If set, this flag causes the 387 to be used, which is compatible with most calling conventions. */ ! #define TARGET_FLOAT_RETURNS_IN_80387 (target_flags & 0200) /* Disable generation of FP sin, cos and sqrt operations for 387. This is because FreeBSD lacks these in the math-emulator-code */ ! #define TARGET_NO_FANCY_MATH_387 (target_flags & 0400) ! /* Macro to define tables used to set the flags. ! This is a list in braces of pairs in braces, ! each pair being { "NAME", VALUE } ! where VALUE is the bits to set or minus the bits to clear. ! An empty string NAME is used to identify the default VALUE. */ ! ! #define TARGET_SWITCHES \ ! { { "80387", 1}, \ ! { "no-80387", -1}, \ ! { "soft-float", -1}, \ ! { "no-soft-float", 1}, \ ! { "486", 2}, \ ! { "no-486", -2}, \ ! { "386", -2}, \ ! { "rtd", 8}, \ ! { "no-rtd", -8}, \ ! { "regparm", 020}, \ ! { "no-regparm", -020}, \ ! { "svr3-shlib", 040}, \ ! { "no-svr3-shlib", -040}, \ ! { "ieee-fp", 0100}, \ ! { "no-ieee-fp", -0100}, \ ! { "fp-ret-in-387", 0200}, \ ! { "no-fp-ret-in-387", -0200}, \ ! { "no-fancy-math-387", 0400}, \ ! { "fancy-math-387", -0400}, \ ! SUBTARGET_SWITCHES \ ! { "", TARGET_DEFAULT | TARGET_CPU_DEFAULT}} ! /* This is meant to be redefined in the host dependent files */ ! #define SUBTARGET_SWITCHES ! #define OVERRIDE_OPTIONS \ ! { \ ! SUBTARGET_OVERRIDE_OPTIONS \ ! } ! /* This is meant to be redefined in the host dependent files */ ! #define SUBTARGET_OVERRIDE_OPTIONS /* target machine storage layout */ --- 105,190 ---- in the 387 FPU or in 386 integer registers. If set, this flag causes the 387 to be used, which is compatible with most calling conventions. */ ! #define TARGET_FLOAT_RETURNS_IN_80387 (target_flags & MASK_FLOAT_RETURNS) /* Disable generation of FP sin, cos and sqrt operations for 387. This is because FreeBSD lacks these in the math-emulator-code */ ! #define TARGET_NO_FANCY_MATH_387 (target_flags & MASK_NO_FANCY_MATH_387) ! /* Temporary switches for tuning code generation */ ! /* Disable 32x32->64 bit multiplies that are used for long long multiplies ! and division by constants, but sometimes cause reload problems. */ ! #define TARGET_NO_WIDE_MULTIPLY (target_flags & MASK_NO_WIDE_MULTIPLY) ! #define TARGET_WIDE_MULTIPLY (!TARGET_NO_WIDE_MULTIPLY) ! ! /* Debug GO_IF_LEGITIMATE_ADDRESS */ ! #define TARGET_DEBUG_ADDR (target_flags & MASK_DEBUG_ADDR) ! ! /* Hack macros for tuning code generation */ ! #define TARGET_MOVE ((target_flags & MASK_NO_MOVE) == 0) /* Don't generate memory->memory */ ! ! /* Specific hardware switches */ ! #define TARGET_486 (target_flags & MASK_486) /* 80486DX, 80486SX, 80486DX[24] */ ! #define TARGET_386 (!TARGET_486) /* 80386 */ ! ! #define TARGET_SWITCHES \ ! { { "80387", MASK_80387 }, \ ! { "no-80387", -MASK_80387 }, \ ! { "hard-float", MASK_80387 }, \ ! { "soft-float", -MASK_80387 }, \ ! { "no-soft-float", MASK_80387 }, \ ! { "386", -MASK_486 }, \ ! { "no-386", MASK_486 }, \ ! { "486", MASK_486 }, \ ! { "no-486", -MASK_486 }, \ ! { "rtd", MASK_RTD }, \ ! { "no-rtd", -MASK_RTD }, \ ! { "regparm", MASK_REGPARM }, \ ! { "no-regparm", -MASK_REGPARM }, \ ! { "svr3-shlib", MASK_SVR3_SHLIB }, \ ! { "no-svr3-shlib", -MASK_SVR3_SHLIB }, \ ! { "ieee-fp", MASK_IEEE_FP }, \ ! { "no-ieee-fp", -MASK_IEEE_FP }, \ ! { "fp-ret-in-387", MASK_FLOAT_RETURNS }, \ ! { "no-fp-ret-in-387", -MASK_FLOAT_RETURNS }, \ ! { "no-fancy-math-387", MASK_NO_FANCY_MATH_387 }, \ ! { "fancy-math-387", -MASK_NO_FANCY_MATH_387 }, \ ! { "no-wide-multiply", MASK_NO_WIDE_MULTIPLY }, \ ! { "wide-multiply", -MASK_NO_WIDE_MULTIPLY }, \ ! { "debug-addr", MASK_DEBUG_ADDR }, \ ! { "no-debug-addr", -MASK_DEBUG_ADDR }, \ ! { "move", -MASK_NO_MOVE }, \ ! { "no-move", MASK_NO_MOVE }, \ ! SUBTARGET_SWITCHES \ ! { "", TARGET_DEFAULT | TARGET_CPU_DEFAULT}} ! ! /* This macro is similar to `TARGET_SWITCHES' but defines names of ! command options that have values. Its definition is an ! initializer with a subgrouping for each command option. ! ! Each subgrouping contains a string constant, that defines the ! fixed part of the option name, and the address of a variable. The ! variable, type `char *', is set to the variable part of the given ! option if the fixed part matches. The actual option name is made ! by appending `-m' to the specified name. */ ! #define TARGET_OPTIONS \ ! { { "reg-alloc=", &i386_reg_alloc_order }, \ ! SUBTARGET_OPTIONS } ! ! /* Sometimes certain combinations of command options do not make ! sense on a particular target machine. You can define a macro ! `OVERRIDE_OPTIONS' to take account of this. This macro, if ! defined, is executed once just after all the command options have ! been parsed. ! Don't use this macro to turn on various extra optimizations for ! `-O'. That is what `OPTIMIZATION_OPTIONS' is for. */ ! #define OVERRIDE_OPTIONS override_options () ! ! /* These are meant to be redefined in the host dependent files */ ! #define SUBTARGET_SWITCHES ! #define SUBTARGET_OPTIONS ! /* target machine storage layout */ *************** *** 264,273 **** late and fixed registers last. Note that, in general, we prefer registers listed in CALL_USED_REGISTERS, keeping the others ! available for storage of persistent values. */ #define REG_ALLOC_ORDER \ ! /*dx,cx,ax,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7,arg*/ \ ! { 1, 2, 0, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } /* Macro to conditionally modify fixed_regs/call_used_regs. */ #define CONDITIONAL_REGISTER_USAGE \ --- 317,354 ---- late and fixed registers last. Note that, in general, we prefer registers listed in CALL_USED_REGISTERS, keeping the others ! available for storage of persistent values. ! ! Three different versions of REG_ALLOC_ORDER have been tried: ! ! If the order is edx, ecx, eax, ... it produces a slightly faster compiler, ! but slower code on simple functions returning values in eax. + If the order is eax, ecx, edx, ... it causes reload to abort when compiling + perl 4.036 due to not being able to create a DImode register (to hold a 2 + word union). + + If the order is eax, edx, ecx, ... it produces better code for simple + functions, and a slightly slower compiler. Users complained about the code + generated by allocating edx first, so restore the 'natural' order of things. */ + #define REG_ALLOC_ORDER \ ! /*ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7,arg*/ \ ! { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } ! ! /* A C statement (sans semicolon) to choose the order in which to ! allocate hard registers for pseudo-registers local to a basic ! block. ! ! Store the desired register order in the array `reg_alloc_order'. ! Element 0 should be the register to allocate first; element 1, the ! next register; and so on. + The macro body should not assume anything about the contents of + `reg_alloc_order' before execution of the macro. + + On most machines, it is not necessary to define this macro. */ + + #define ORDER_REGS_FOR_LOCAL_ALLOC order_regs_for_local_alloc () + /* Macro to conditionally modify fixed_regs/call_used_regs. */ #define CONDITIONAL_REGISTER_USAGE \ *************** *** 382,385 **** --- 463,487 ---- 0 means push the value on the stack like an argument. */ #define STRUCT_VALUE 0 + + /* A C expression which can inhibit the returning of certain function + values in registers, based on the type of value. A nonzero value + says to return the function value in memory, just as large + structures are always returned. Here TYPE will be a C expression + of type `tree', representing the data type of the value. + + Note that values of mode `BLKmode' must be explicitly handled by + this macro. Also, the option `-fpcc-struct-return' takes effect + regardless of this macro. On most systems, it is possible to + leave the macro undefined; this causes a default definition to be + used, whose value is the constant 1 for `BLKmode' values, and 0 + otherwise. + + Do not use this macro to indicate that structures and unions + should always be returned in memory. You should instead use + `DEFAULT_PCC_STRUCT_RETURN' to indicate this. */ + + #define RETURN_IN_MEMORY(TYPE) \ + ((TYPE_MODE (TYPE) == BLKmode) || int_size_in_bytes (TYPE) > 12) + /* Define the classes of registers for register constraints in the *************** *** 449,453 **** 0xf, /* Q_REGS */ \ 0x10, 0x20, /* SIREG, DIREG */ \ ! 0x1007f, /* INDEX_REGS */ \ 0x100ff, /* GENERAL_REGS */ \ 0x0100, 0x0200, /* FP_TOP_REG, FP_SECOND_REG */ \ --- 551,555 ---- 0xf, /* Q_REGS */ \ 0x10, 0x20, /* SIREG, DIREG */ \ ! 0x07f, /* INDEX_REGS */ \ 0x100ff, /* GENERAL_REGS */ \ 0x0100, 0x0200, /* FP_TOP_REG, FP_SECOND_REG */ \ *************** *** 460,464 **** or could index an array. */ - extern enum reg_class regclass_map[FIRST_PSEUDO_REGISTER]; #define REGNO_REG_CLASS(REGNO) (regclass_map[REGNO]) --- 562,565 ---- *************** *** 592,595 **** --- 693,722 ---- (FLOAT_CLASS_P (CLASS) ? 1 : \ ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) + + /* A C expression whose value is nonzero if pseudos that have been + assigned to registers of class CLASS would likely be spilled + because registers of CLASS are needed for spill registers. + + The default value of this macro returns 1 if CLASS has exactly one + register and zero otherwise. On most machines, this default + should be used. Only define this macro to some other expression + if pseudo allocated by `local-alloc.c' end up in memory because + their hard registers were needed for spill regisers. If this + macro returns nonzero for those classes, those pseudos will only + be allocated by `global.c', which knows how to reallocate the + pseudo to another register. If there would not be another + register available for reallocation, you should not change the + definition of this macro since the only effect of such a + definition would be to slow down register allocation. */ + + #define CLASS_LIKELY_SPILLED_P(CLASS) \ + (((CLASS) == AREG) \ + || ((CLASS) == DREG) \ + || ((CLASS) == CREG) \ + || ((CLASS) == BREG) \ + || ((CLASS) == AD_REGS) \ + || ((CLASS) == SIREG) \ + || ((CLASS) == DIREG)) + /* Stack layout; function entry, exit and calling. */ *************** *** 763,766 **** --- 890,989 ---- } + /* A C statement or compound statement to output to FILE some + assembler code to initialize basic-block profiling for the current + object module. This code should call the subroutine + `__bb_init_func' once per object module, passing it as its sole + argument the address of a block allocated in the object module. + + The name of the block is a local symbol made with this statement: + + ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); + + Of course, since you are writing the definition of + `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you + can take a short cut in the definition of this macro and use the + name that you know will result. + + The first word of this block is a flag which will be nonzero if the + object module has already been initialized. So test this word + first, and do not call `__bb_init_func' if the flag is nonzero. */ + + #undef FUNCTION_BLOCK_PROFILER + #define FUNCTION_BLOCK_PROFILER(STREAM, LABELNO) \ + do \ + { \ + static int num_func = 0; \ + rtx xops[8]; \ + char block_table[80], false_label[80]; \ + \ + ASM_GENERATE_INTERNAL_LABEL (block_table, "LPBX", 0); \ + ASM_GENERATE_INTERNAL_LABEL (false_label, "LPBZ", num_func); \ + \ + xops[0] = const0_rtx; \ + xops[1] = gen_rtx (SYMBOL_REF, VOIDmode, block_table); \ + xops[2] = gen_rtx (MEM, Pmode, gen_rtx (SYMBOL_REF, VOIDmode, false_label)); \ + xops[3] = gen_rtx (MEM, Pmode, gen_rtx (SYMBOL_REF, VOIDmode, "__bb_init_func")); \ + xops[4] = gen_rtx (MEM, Pmode, xops[1]); \ + xops[5] = stack_pointer_rtx; \ + xops[6] = GEN_INT (4); \ + xops[7] = gen_rtx (REG, Pmode, 0); /* eax */ \ + \ + CONSTANT_POOL_ADDRESS_P (xops[1]) = TRUE; \ + CONSTANT_POOL_ADDRESS_P (xops[2]) = TRUE; \ + \ + output_asm_insn (AS2(cmp%L4,%0,%4), xops); \ + output_asm_insn (AS1(jne,%2), xops); \ + \ + if (!flag_pic) \ + output_asm_insn (AS1(push%L1,%1), xops); \ + else \ + { \ + output_asm_insn (AS2 (lea%L7,%a1,%7), xops); \ + output_asm_insn (AS1 (push%L7,%7), xops); \ + } \ + \ + output_asm_insn (AS1(call,%P3), xops); \ + output_asm_insn (AS2(add%L0,%6,%5), xops); \ + ASM_OUTPUT_INTERNAL_LABEL (STREAM, "LPBZ", num_func); \ + num_func++; \ + } \ + while (0) + + + /* A C statement or compound statement to increment the count + associated with the basic block number BLOCKNO. Basic blocks are + numbered separately from zero within each compilation. The count + associated with block number BLOCKNO is at index BLOCKNO in a + vector of words; the name of this array is a local symbol made + with this statement: + + ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); + + Of course, since you are writing the definition of + `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you + can take a short cut in the definition of this macro and use the + name that you know will result. */ + + #define BLOCK_PROFILER(STREAM, BLOCKNO) \ + do \ + { \ + rtx xops[1], cnt_rtx; \ + char counts[80]; \ + \ + ASM_GENERATE_INTERNAL_LABEL (counts, "LPBX", 2); \ + cnt_rtx = gen_rtx (SYMBOL_REF, VOIDmode, counts); \ + SYMBOL_REF_FLAG (cnt_rtx) = TRUE; \ + \ + if (BLOCKNO) \ + cnt_rtx = plus_constant (cnt_rtx, (BLOCKNO)*4); \ + \ + if (flag_pic) \ + cnt_rtx = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, cnt_rtx); \ + \ + xops[0] = gen_rtx (MEM, SImode, cnt_rtx); \ + output_asm_insn (AS1(inc%L0,%0), xops); \ + } \ + while (0) + /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, the stack pointer does not matter. The value is tested only in *************** *** 926,959 **** been eliminated by then. */ - #ifndef REG_OK_STRICT - - /* Nonzero if X is a hard reg that can be used as an index or if - it is a pseudo reg. */ ! #define REG_OK_FOR_INDEX_P(X) \ ! (REGNO (X) < STACK_POINTER_REGNUM \ || REGNO (X) >= FIRST_PSEUDO_REGISTER) ! /* Nonzero if X is a hard reg that can be used as a base reg ! of if it is a pseudo reg. */ ! /* ?wfs */ ! ! #define REG_OK_FOR_BASE_P(X) \ ! (REGNO (X) <= STACK_POINTER_REGNUM \ ! || REGNO (X) == ARG_POINTER_REGNUM \ ! || REGNO(X) >= FIRST_PSEUDO_REGISTER) ! #define REG_OK_FOR_STRREG_P(X) \ (REGNO (X) == 4 || REGNO (X) == 5 || REGNO (X) >= FIRST_PSEUDO_REGISTER) ! #else ! ! /* Nonzero if X is a hard reg that can be used as an index. */ ! #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) ! /* Nonzero if X is a hard reg that can be used as a base reg. */ ! #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) ! #define REG_OK_FOR_STRREG_P(X) \ (REGNO_OK_FOR_DIREG_P (REGNO (X)) || REGNO_OK_FOR_SIREG_P (REGNO (X))) #endif --- 1149,1181 ---- been eliminated by then. */ ! /* Non strict versions, pseudos are ok */ ! #define REG_OK_FOR_INDEX_NONSTRICT_P(X) \ ! (REGNO (X) < STACK_POINTER_REGNUM \ || REGNO (X) >= FIRST_PSEUDO_REGISTER) ! #define REG_OK_FOR_BASE_NONSTRICT_P(X) \ ! (REGNO (X) <= STACK_POINTER_REGNUM \ ! || REGNO (X) == ARG_POINTER_REGNUM \ ! || REGNO (X) >= FIRST_PSEUDO_REGISTER) ! #define REG_OK_FOR_STRREG_NONSTRICT_P(X) \ (REGNO (X) == 4 || REGNO (X) == 5 || REGNO (X) >= FIRST_PSEUDO_REGISTER) ! /* Strict versions, hard registers only */ ! #define REG_OK_FOR_INDEX_STRICT_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) ! #define REG_OK_FOR_BASE_STRICT_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) ! #define REG_OK_FOR_STRREG_STRICT_P(X) \ (REGNO_OK_FOR_DIREG_P (REGNO (X)) || REGNO_OK_FOR_SIREG_P (REGNO (X))) + #ifndef REG_OK_STRICT + #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_INDEX_NONSTRICT_P(X) + #define REG_OK_FOR_BASE_P(X) REG_OK_FOR_BASE_NONSTRICT_P(X) + #define REG_OK_FOR_STRREG_P(X) REG_OK_FOR_STRREG_NONSTRICT_P(X) + + #else + #define REG_OK_FOR_INDEX_P(X) REG_OK_FOR_INDEX_STRICT_P(X) + #define REG_OK_FOR_BASE_P(X) REG_OK_FOR_BASE_STRICT_P(X) + #define REG_OK_FOR_STRREG_P(X) REG_OK_FOR_STRREG_STRICT_P(X) #endif *************** *** 981,1040 **** #define LEGITIMATE_CONSTANT_P(X) 1 ! #define GO_IF_INDEXABLE_BASE(X, ADDR) \ ! if (GET_CODE (X) == REG && REG_OK_FOR_BASE_P (X)) goto ADDR ! ! #define LEGITIMATE_INDEX_REG_P(X) \ ! (GET_CODE (X) == REG && REG_OK_FOR_INDEX_P (X)) ! ! /* Return 1 if X is an index or an index times a scale. */ ! ! #define LEGITIMATE_INDEX_P(X) \ ! (LEGITIMATE_INDEX_REG_P (X) \ ! || (GET_CODE (X) == MULT \ ! && LEGITIMATE_INDEX_REG_P (XEXP (X, 0)) \ ! && GET_CODE (XEXP (X, 1)) == CONST_INT \ ! && (INTVAL (XEXP (X, 1)) == 2 \ ! || INTVAL (XEXP (X, 1)) == 4 \ ! || INTVAL (XEXP (X, 1)) == 8))) ! ! /* Go to ADDR if X is an index term, a base reg, or a sum of those. */ ! ! #define GO_IF_INDEXING(X, ADDR) \ ! { if (LEGITIMATE_INDEX_P (X)) goto ADDR; \ ! GO_IF_INDEXABLE_BASE (X, ADDR); \ ! if (GET_CODE (X) == PLUS && LEGITIMATE_INDEX_P (XEXP (X, 0))) \ ! { GO_IF_INDEXABLE_BASE (XEXP (X, 1), ADDR); } \ ! if (GET_CODE (X) == PLUS && LEGITIMATE_INDEX_P (XEXP (X, 1))) \ ! { GO_IF_INDEXABLE_BASE (XEXP (X, 0), ADDR); } } ! ! /* We used to allow this, but it isn't ever used. ! || ((GET_CODE (X) == POST_DEC || GET_CODE (X) == POST_INC) \ ! && REG_P (XEXP (X, 0)) \ ! && REG_OK_FOR_STRREG_P (XEXP (X, 0))) \ ! */ ! #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ { \ ! if (CONSTANT_ADDRESS_P (X) \ ! && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (X))) \ goto ADDR; \ - GO_IF_INDEXING (X, ADDR); \ - if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \ - { \ - rtx x0 = XEXP (X, 0); \ - if (! flag_pic || ! SYMBOLIC_CONST (XEXP (X, 1))) \ - { GO_IF_INDEXING (x0, ADDR); } \ - else if (x0 == pic_offset_table_rtx) \ - goto ADDR; \ - else if (GET_CODE (x0) == PLUS) \ - { \ - if (XEXP (x0, 0) == pic_offset_table_rtx) \ - { GO_IF_INDEXABLE_BASE (XEXP (x0, 1), ADDR); } \ - if (XEXP (x0, 1) == pic_offset_table_rtx) \ - { GO_IF_INDEXABLE_BASE (XEXP (x0, 0), ADDR); } \ - } \ - } \ } /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. --- 1203,1222 ---- #define LEGITIMATE_CONSTANT_P(X) 1 ! #ifdef REG_OK_STRICT ! #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ ! { \ ! if (legitimate_address_p (MODE, X, 1)) \ ! goto ADDR; \ ! } ! #else ! #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ { \ ! if (legitimate_address_p (MODE, X, 0)) \ goto ADDR; \ } + #endif + /* Try machine-dependent ways of modifying an illegitimate address to be legitimate. If we find one, return the new, valid address. *************** *** 1058,1093 **** See comments by legitimize_pic_address in i386.c for details. */ ! #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \ ! { extern rtx legitimize_pic_address (); \ ! int ch = (X) != (OLDX); \ ! if (flag_pic && SYMBOLIC_CONST (X)) \ ! { \ ! (X) = legitimize_pic_address (X, 0); \ ! if (memory_address_p (MODE, X)) \ ! goto WIN; \ ! } \ ! if (GET_CODE (X) == PLUS) \ ! { if (GET_CODE (XEXP (X, 0)) == MULT) \ ! ch = 1, XEXP (X, 0) = force_operand (XEXP (X, 0), 0); \ ! if (GET_CODE (XEXP (X, 1)) == MULT) \ ! ch = 1, XEXP (X, 1) = force_operand (XEXP (X, 1), 0); \ ! if (ch && GET_CODE (XEXP (X, 1)) == REG \ ! && GET_CODE (XEXP (X, 0)) == REG) \ ! goto WIN; \ ! if (flag_pic && SYMBOLIC_CONST (XEXP (X, 1))) \ ! ch = 1, (X) = legitimize_pic_address (X, 0); \ ! if (ch) { GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); } \ ! if (GET_CODE (XEXP (X, 0)) == REG) \ ! { register rtx temp = gen_reg_rtx (Pmode); \ ! register rtx val = force_operand (XEXP (X, 1), temp); \ ! if (val != temp) emit_move_insn (temp, val); \ ! XEXP (X, 1) = temp; \ ! goto WIN; } \ ! else if (GET_CODE (XEXP (X, 1)) == REG) \ ! { register rtx temp = gen_reg_rtx (Pmode); \ ! register rtx val = force_operand (XEXP (X, 0), temp); \ ! if (val != temp) emit_move_insn (temp, val); \ ! XEXP (X, 0) = temp; \ ! goto WIN; }}} /* Nonzero if the constant value X is a legitimate general operand --- 1240,1250 ---- See comments by legitimize_pic_address in i386.c for details. */ ! #define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \ ! { \ ! rtx orig_x = (X); \ ! (X) = legitimize_address (X, OLDX, MODE); \ ! if (memory_address_p (MODE, X)) \ ! goto WIN; \ ! } /* Nonzero if the constant value X is a legitimate general operand *************** *** 1313,1317 **** since it hasn't been defined! */ - extern struct rtx_def *i386_compare_op0, *i386_compare_op1; extern struct rtx_def *(*i386_compare_gen)(), *(*i386_compare_gen_eq)(); --- 1470,1473 ---- *************** *** 1658,1661 **** --- 1814,1871 ---- #define RET return "" #define AT_SP(mode) (gen_rtx (MEM, (mode), stack_pointer_rtx)) + + /* Functions in i386.c */ + extern void override_options (); + extern void order_regs_for_local_alloc (); + extern void output_op_from_reg (); + extern void output_to_reg (); + extern char *singlemove_string (); + extern char *output_move_double (); + extern char *output_move_memory (); + extern char *output_move_pushmem (); + extern int standard_80387_constant_p (); + extern char *output_move_const_single (); + extern int symbolic_operand (); + extern int call_insn_operand (); + extern int expander_call_insn_operand (); + extern int symbolic_reference_mentioned_p (); + extern void emit_pic_move (); + extern void function_prologue (); + extern int simple_386_epilogue (); + extern void function_epilogue (); + extern int legitimate_address_p (); + extern struct rtx_def *legitimize_pic_address (); + extern struct rtx_def *legitimize_address (); + extern void print_operand (); + extern void print_operand_address (); + extern void notice_update_cc (); + extern void split_di (); + extern int binary_387_op (); + extern int shift_op (); + extern int VOIDmode_compare_op (); + extern char *output_387_binary_op (); + extern char *output_fix_trunc (); + extern char *output_float_compare (); + extern char *output_fp_cc0_set (); + extern void save_386_machine_status (); + extern void restore_386_machine_status (); + extern void clear_386_stack_locals (); + extern struct rtx_def *assign_386_stack_local (); + + /* Variables in i386.c */ + extern char *i386_reg_alloc_order; /* register allocation order */ + extern char *hi_reg_name[]; /* names for 16 bit regs */ + extern char *qi_reg_name[]; /* names for 8 bit regs (low) */ + extern char *qi_high_reg_name[]; /* names for 8 bit regs (high) */ + extern enum reg_class regclass_map[]; /* smalled class containing REGNO */ + extern struct rtx_def *i386_compare_op0; /* operand 0 for comparisons */ + extern struct rtx_def *i386_compare_op1; /* operand 1 for comparisons */ + + /* External variables used */ + extern int optimize; /* optimization level */ + extern int obey_regdecls; /* TRUE if stupid register allocation */ + + /* External functions used */ + extern struct rtx_def *force_operand (); /* diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/i386.md gcc-2.6.1/config/i386/i386.md *** gcc-2.6.0/config/i386/i386.md Tue Jun 14 22:44:41 1994 --- gcc-2.6.1/config/i386/i386.md Mon Oct 31 16:16:33 1994 *************** *** 1,3 **** ! ;; GCC machine description for Intel 80386. ;; Copyright (C) 1988, 1994 Free Software Foundation, Inc. ;; Mostly by William Schelter. --- 1,3 ---- ! ;; GCC machine description for Intel X86. ;; Copyright (C) 1988, 1994 Free Software Foundation, Inc. ;; Mostly by William Schelter. *************** *** 158,162 **** output_asm_insn (AS1 (fstp,%y0), operands); ! return (char *) output_fp_cc0_set (insn); }") --- 158,162 ---- output_asm_insn (AS1 (fstp,%y0), operands); ! return output_fp_cc0_set (insn); }") *************** *** 191,195 **** output_asm_insn (AS1 (fstp,%y0), operands); ! return (char *) output_fp_cc0_set (insn); }") --- 191,195 ---- output_asm_insn (AS1 (fstp,%y0), operands); ! return output_fp_cc0_set (insn); }") *************** *** 224,228 **** output_asm_insn (AS1 (fstp,%y0), operands); ! return (char *) output_fp_cc0_set (insn); }") --- 224,228 ---- output_asm_insn (AS1 (fstp,%y0), operands); ! return output_fp_cc0_set (insn); }") *************** *** 350,354 **** "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 350,354 ---- "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 360,364 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 360,364 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 370,374 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 370,374 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 380,384 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 380,384 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 390,394 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 390,394 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 398,402 **** (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 398,402 ---- (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 408,412 **** "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 408,412 ---- "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 418,422 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 418,422 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 428,432 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 428,432 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 438,442 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 438,442 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 448,452 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 448,452 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 456,460 **** (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") ;; These two insns will never be generated by combine due to the mode of --- 456,460 ---- (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") ;; These two insns will never be generated by combine due to the mode of *************** *** 467,471 **** ; (clobber (match_scratch:HI 2 "=a"))] ; "TARGET_80387" ! ; "* return (char *) output_float_compare (insn, operands);") ; ;(define_insn "" --- 467,471 ---- ; (clobber (match_scratch:HI 2 "=a"))] ; "TARGET_80387" ! ; "* return output_float_compare (insn, operands);") ; ;(define_insn "" *************** *** 476,480 **** ; (clobber (match_scratch:HI 2 "=a"))] ; "TARGET_80387" ! ; "* return (char *) output_float_compare (insn, operands);") (define_insn "cmpsf_cc_1" --- 476,480 ---- ; (clobber (match_scratch:HI 2 "=a"))] ; "TARGET_80387" ! ; "* return output_float_compare (insn, operands);") (define_insn "cmpsf_cc_1" *************** *** 486,490 **** "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 486,490 ---- "TARGET_80387 && (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM)" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 496,500 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 496,500 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 506,510 **** (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_insn "" --- 506,510 ---- (clobber (match_scratch:HI 3 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_insn "" *************** *** 514,518 **** (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return (char *) output_float_compare (insn, operands);") (define_expand "cmpxf" --- 514,518 ---- (clobber (match_scratch:HI 2 "=a"))] "TARGET_80387" ! "* return output_float_compare (insn, operands);") (define_expand "cmpxf" *************** *** 741,745 **** [(set (match_operand:SI 0 "push_operand" "=<") (match_operand:SI 1 "general_operand" "g"))] ! "! TARGET_486" "push%L0 %1") --- 741,745 ---- [(set (match_operand:SI 0 "push_operand" "=<") (match_operand:SI 1 "general_operand" "g"))] ! "TARGET_386" "push%L0 %1") *************** *** 749,754 **** (define_insn "" [(set (match_operand:SI 0 "push_operand" "=<") (match_operand:SI 1 "general_operand" "ri"))] ! "TARGET_486" "push%L0 %1") --- 749,760 ---- (define_insn "" [(set (match_operand:SI 0 "push_operand" "=<") + (match_operand:SI 1 "nonmemory_operand" "ri"))] + "!TARGET_386 && TARGET_MOVE" + "push%L0 %1") + + (define_insn "" + [(set (match_operand:SI 0 "push_operand" "=<") (match_operand:SI 1 "general_operand" "ri"))] ! "!TARGET_386 && !TARGET_MOVE" "push%L0 %1") *************** *** 768,771 **** --- 774,786 ---- if (flag_pic && SYMBOLIC_CONST (operands[1])) emit_pic_move (operands, SImode); + + /* Don't generate memory->memory moves, go through a register */ + else if (TARGET_MOVE + && (reload_in_progress | reload_completed) == 0 + && GET_CODE (operands[0]) == MEM + && GET_CODE (operands[1]) == MEM) + { + operands[1] = force_reg (SImode, operands[1]); + } }") *************** *** 775,779 **** [(set (match_operand:SI 0 "general_operand" "=g,r") (match_operand:SI 1 "general_operand" "ri,m"))] ! "" "* { --- 790,794 ---- [(set (match_operand:SI 0 "general_operand" "=g,r") (match_operand:SI 1 "general_operand" "ri,m"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 794,797 **** --- 809,815 ---- return AS1 (inc%L0,%0); + if (flag_pic && SYMBOLIC_CONST (operands[1])) + return AS2 (lea%L0,%a1,%0); + return AS2 (mov%L0,%1,%0); }") *************** *** 800,812 **** [(set (match_operand:HI 0 "push_operand" "=<") (match_operand:HI 1 "general_operand" "g"))] ! "" "push%W0 %1") ;; On i486, an incl and movl are both faster than incw and movw. ! (define_insn "movhi" [(set (match_operand:HI 0 "general_operand" "=g,r") (match_operand:HI 1 "general_operand" "ri,m"))] ! "" "* { --- 818,858 ---- [(set (match_operand:HI 0 "push_operand" "=<") (match_operand:HI 1 "general_operand" "g"))] ! "TARGET_386" "push%W0 %1") + (define_insn "" + [(set (match_operand:HI 0 "push_operand" "=<") + (match_operand:HI 1 "nonmemory_operand" "ri"))] + "!TARGET_386 && TARGET_MOVE" + "push%W0 %1") + + (define_insn "" + [(set (match_operand:HI 0 "push_operand" "=<") + (match_operand:HI 1 "general_operand" "ri"))] + "!TARGET_386 && !TARGET_MOVE" + "push%W0 %1") + ;; On i486, an incl and movl are both faster than incw and movw. ! (define_expand "movhi" ! [(set (match_operand:HI 0 "general_operand" "") ! (match_operand:HI 1 "general_operand" ""))] ! "" ! " ! { ! /* Don't generate memory->memory moves, go through a register */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && GET_CODE (operands[1]) == MEM) ! { ! operands[1] = force_reg (HImode, operands[1]); ! } ! }") ! ! (define_insn "" [(set (match_operand:HI 0 "general_operand" "=g,r") (match_operand:HI 1 "general_operand" "ri,m"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 838,845 **** }") ! (define_insn "movstricthi" [(set (strict_low_part (match_operand:HI 0 "general_operand" "+g,r")) (match_operand:HI 1 "general_operand" "ri,m"))] ! "" "* { --- 884,907 ---- }") ! (define_expand "movstricthi" ! [(set (strict_low_part (match_operand:HI 0 "general_operand" "")) ! (match_operand:HI 1 "general_operand" ""))] ! "" ! " ! { ! /* Don't generate memory->memory moves, go through a register */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && GET_CODE (operands[1]) == MEM) ! { ! operands[1] = force_reg (HImode, operands[1]); ! } ! }") ! ! (define_insn "" [(set (strict_low_part (match_operand:HI 0 "general_operand" "+g,r")) (match_operand:HI 1 "general_operand" "ri,m"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 869,874 **** (define_insn "" [(set (match_operand:QI 0 "push_operand" "=<") ! (match_operand:QI 1 "general_operand" "q"))] "" "* { --- 931,952 ---- (define_insn "" [(set (match_operand:QI 0 "push_operand" "=<") ! (match_operand:QI 1 "immediate_operand" "n"))] "" + "* return AS1 (push%W0,%1);") + + (define_insn "" + [(set (match_operand:QI 0 "push_operand" "=<") + (match_operand:QI 1 "nonimmediate_operand" "q"))] + "!TARGET_MOVE" + "* + { + operands[1] = gen_rtx (REG, HImode, REGNO (operands[1])); + return AS1 (push%W0,%1); + }") + + (define_insn "" + [(set (match_operand:QI 0 "push_operand" "=<") + (match_operand:QI 1 "register_operand" "q"))] + "TARGET_MOVE" "* { *************** *** 882,889 **** ;; or writes %ah, %bh, %ch, %dh. ! (define_insn "movqi" [(set (match_operand:QI 0 "general_operand" "=q,*r,qm") (match_operand:QI 1 "general_operand" "*g,q,qn"))] ! "" "* { --- 960,983 ---- ;; or writes %ah, %bh, %ch, %dh. ! (define_expand "movqi" ! [(set (match_operand:QI 0 "general_operand" "") ! (match_operand:QI 1 "general_operand" ""))] ! "" ! " ! { ! /* Don't generate memory->memory moves, go through a register */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && GET_CODE (operands[1]) == MEM) ! { ! operands[1] = force_reg (QImode, operands[1]); ! } ! }") ! ! (define_insn "" [(set (match_operand:QI 0 "general_operand" "=q,*r,qm") (match_operand:QI 1 "general_operand" "*g,q,qn"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 920,927 **** ;; faster. ! (define_insn "movstrictqi" [(set (strict_low_part (match_operand:QI 0 "general_operand" "+qm,q")) (match_operand:QI 1 "general_operand" "*qn,m"))] ! "" "* { --- 1014,1037 ---- ;; faster. ! (define_expand "movstrictqi" ! [(set (strict_low_part (match_operand:QI 0 "general_operand" "")) ! (match_operand:QI 1 "general_operand" ""))] ! "" ! " ! { ! /* Don't generate memory->memory moves, go through a register */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && GET_CODE (operands[1]) == MEM) ! { ! operands[1] = force_reg (QImode, operands[1]); ! } ! }") ! ! (define_insn "" [(set (strict_low_part (match_operand:QI 0 "general_operand" "+qm,q")) (match_operand:QI 1 "general_operand" "*qn,m"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 952,959 **** }") ! (define_insn "" [(set (match_operand:SF 0 "push_operand" "=<,<") (match_operand:SF 1 "general_operand" "gF,f"))] ! "" "* { --- 1062,1102 ---- }") ! (define_expand "movsf" ! [(set (match_operand:SF 0 "general_operand" "") ! (match_operand:SF 1 "general_operand" ""))] ! "" ! " ! { ! /* Special case memory->memory moves and pushes */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && (GET_CODE (operands[1]) == MEM || push_operand (operands[0], SFmode))) ! { ! rtx (*genfunc) PROTO((rtx, rtx)) = (push_operand (operands[0], SFmode)) ! ? gen_movsf_push ! : gen_movsf_mem; ! ! emit_insn ((*genfunc) (operands[0], operands[1])); ! DONE; ! } ! ! /* If we are loading a floating point constant that isn't 0 or 1 into a register, ! indicate we need the pic register loaded. This could be optimized into stores ! of constants if the target eventually moves to memory, but better safe than ! sorry. */ ! if (flag_pic ! && GET_CODE (operands[0]) != MEM ! && GET_CODE (operands[1]) == CONST_DOUBLE ! && !standard_80387_constant_p (operands[1])) ! { ! current_function_uses_pic_offset_table = 1; ! } ! }") ! ! (define_insn "movsf_push_nomove" [(set (match_operand:SF 0 "push_operand" "=<,<") (match_operand:SF 1 "general_operand" "gF,f"))] ! "!TARGET_MOVE" "* { *************** *** 980,991 **** }") ! ;; Allow MEM-MEM moves before reload. The reload class for such a ! ;; move will be ALL_REGS. PREFERRED_RELOAD_CLASS will narrow this to ! ;; GENERAL_REGS. For the purposes of regclass, prefer FLOAT_REGS. ! (define_insn "movsf" [(set (match_operand:SF 0 "general_operand" "=*rfm,*rf,f,!*rm") (match_operand:SF 1 "general_operand" "*rf,*rfm,fG,fF"))] ! "" "* { --- 1123,1181 ---- }") ! (define_insn "movsf_push" ! [(set (match_operand:SF 0 "push_operand" "=<,<,<,<") ! (match_operand:SF 1 "general_operand" "rF,f,m,m")) ! (clobber (match_scratch:SI 2 "=X,X,r,X"))] ! "" ! "* ! { ! if (STACK_REG_P (operands[1])) ! { ! rtx xops[3]; ! ! if (! STACK_TOP_P (operands[1])) ! abort (); ! ! xops[0] = AT_SP (SFmode); ! xops[1] = GEN_INT (4); ! xops[2] = stack_pointer_rtx; ! ! output_asm_insn (AS2 (sub%L2,%1,%2), xops); ! ! if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG)) ! output_asm_insn (AS1 (fstp%S0,%0), xops); ! else ! output_asm_insn (AS1 (fst%S0,%0), xops); ! RET; ! } ! ! else if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != REG) ! return AS1 (push%L1,%1); ! ! else ! { ! output_asm_insn (AS2 (mov%L2,%1,%2), operands); ! return AS1 (push%L2,%2); ! } ! }") ! ! ;; Special memory<->memory pattern that combine will recreate from the ! ;; moves to pseudos. ! (define_insn "movsf_mem" ! [(set (match_operand:SF 0 "memory_operand" "=m") ! (match_operand:SF 1 "memory_operand" "m")) ! (clobber (match_scratch:SI 2 "=&r"))] ! "" ! "* ! { ! output_asm_insn (AS2 (mov%L2,%1,%2), operands); ! return AS2 (mov%L0,%2,%0); ! }") ! ;; For the purposes of regclass, prefer FLOAT_REGS. ! (define_insn "movsf_normal" [(set (match_operand:SF 0 "general_operand" "=*rfm,*rf,f,!*rm") (match_operand:SF 1 "general_operand" "*rf,*rfm,fG,fF"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 1029,1033 **** if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return (char *) output_move_const_single (operands); if (STACK_TOP_P (operands[0])) --- 1219,1223 ---- if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return output_move_const_single (operands); if (STACK_TOP_P (operands[0])) *************** *** 1036,1047 **** /* Handle all SFmode moves not involving the 387 */ ! return (char *) singlemove_string (operands); }") ! ;;should change to handle the memory operands[1] without doing df push.. ! (define_insn "" [(set (match_operand:DF 0 "push_operand" "=<,<") (match_operand:DF 1 "general_operand" "gF,f"))] ! "" "* { --- 1226,1283 ---- /* Handle all SFmode moves not involving the 387 */ ! return singlemove_string (operands); }") ! (define_insn "swapsf" ! [(set (match_operand:SF 0 "register_operand" "f") ! (match_operand:SF 1 "register_operand" "f")) ! (set (match_dup 1) ! (match_dup 0))] ! "" ! "* ! { ! if (STACK_TOP_P (operands[0])) ! return AS1 (fxch,%1); ! else ! return AS1 (fxch,%0); ! }") ! ! (define_expand "movdf" ! [(set (match_operand:DF 0 "general_operand" "") ! (match_operand:DF 1 "general_operand" ""))] ! "" ! " ! { ! /* Special case memory->memory moves and pushes */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && (GET_CODE (operands[1]) == MEM || push_operand (operands[0], DFmode))) ! { ! rtx (*genfunc) PROTO((rtx, rtx)) = (push_operand (operands[0], DFmode)) ! ? gen_movdf_push ! : gen_movdf_mem; ! ! emit_insn ((*genfunc) (operands[0], operands[1])); ! DONE; ! } ! ! /* If we are loading a floating point constant that isn't 0 or 1 into a register, ! indicate we need the pic register loaded. This could be optimized into stores ! of constants if the target eventually moves to memory, but better safe than ! sorry. */ ! if (flag_pic ! && GET_CODE (operands[0]) != MEM ! && GET_CODE (operands[1]) == CONST_DOUBLE ! && !standard_80387_constant_p (operands[1])) ! { ! current_function_uses_pic_offset_table = 1; ! } ! }") ! ! (define_insn "movdf_push_nomove" [(set (match_operand:DF 0 "push_operand" "=<,<") (match_operand:DF 1 "general_operand" "gF,f"))] ! "!TARGET_MOVE" "* { *************** *** 1064,1092 **** } else ! return (char *) output_move_double (operands); }") ! (define_insn "swapdf" ! [(set (match_operand:DF 0 "register_operand" "f") ! (match_operand:DF 1 "register_operand" "f")) ! (set (match_dup 1) ! (match_dup 0))] "" "* { ! if (STACK_TOP_P (operands[0])) ! return AS1 (fxch,%1); else ! return AS1 (fxch,%0); }") ! ;; Allow MEM-MEM moves before reload. The reload class for such a ! ;; move will be ALL_REGS. PREFERRED_RELOAD_CLASS will narrow this to ! ;; GENERAL_REGS. For the purposes of regclass, prefer FLOAT_REGS. ! ! (define_insn "movdf" ! [(set (match_operand:DF 0 "general_operand" "=*rfm,*rf,f,!*rm") ! (match_operand:DF 1 "general_operand" "*rf,*rfm,fG,fF"))] "" "* { --- 1300,1352 ---- } else ! return output_move_double (operands); }") ! (define_insn "movdf_push" ! [(set (match_operand:DF 0 "push_operand" "=<,<,<,<,<") ! (match_operand:DF 1 "general_operand" "rF,f,o,o,o")) ! (clobber (match_scratch:SI 2 "=X,X,&r,&r,X")) ! (clobber (match_scratch:SI 3 "=X,X,&r,X,X"))] "" "* { ! if (STACK_REG_P (operands[1])) ! { ! rtx xops[3]; ! ! xops[0] = AT_SP (SFmode); ! xops[1] = GEN_INT (8); ! xops[2] = stack_pointer_rtx; ! ! output_asm_insn (AS2 (sub%L2,%1,%2), xops); ! ! if (find_regno_note (insn, REG_DEAD, FIRST_STACK_REG)) ! output_asm_insn (AS1 (fstp%Q0,%0), xops); ! else ! output_asm_insn (AS1 (fst%Q0,%0), xops); ! ! RET; ! } ! ! else if (GET_CODE (operands[1]) != MEM) ! return output_move_double (operands); ! else ! return output_move_pushmem (operands, insn, GET_MODE_SIZE (DFmode), 2, 4); }") ! (define_insn "movdf_mem" ! [(set (match_operand:DF 0 "memory_operand" "=o,o") ! (match_operand:DF 1 "memory_operand" "o,o")) ! (clobber (match_scratch:SI 2 "=&r,&r")) ! (clobber (match_scratch:SI 3 "=&r,X"))] "" + "* return output_move_memory (operands, insn, GET_MODE_SIZE (DFmode), 2, 4);") + + ;; For the purposes of regclass, prefer FLOAT_REGS. + (define_insn "movdf_normal" + [(set (match_operand:DF 0 "general_operand" "=f,fm,!*rf,!*rm") + (match_operand:DF 1 "general_operand" "fmG,f,*rfm,*rfF"))] + "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 1130,1134 **** if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return (char *) output_move_const_single (operands); if (STACK_TOP_P (operands[0])) --- 1390,1394 ---- if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return output_move_const_single (operands); if (STACK_TOP_P (operands[0])) *************** *** 1137,1147 **** /* Handle all DFmode moves not involving the 387 */ ! return (char *) output_move_double (operands); }") ! (define_insn "" [(set (match_operand:XF 0 "push_operand" "=<,<") (match_operand:XF 1 "general_operand" "gF,f"))] ! "" "* { --- 1397,1455 ---- /* Handle all DFmode moves not involving the 387 */ ! return output_move_double (operands); }") ! (define_insn "swapdf" ! [(set (match_operand:DF 0 "register_operand" "f") ! (match_operand:DF 1 "register_operand" "f")) ! (set (match_dup 1) ! (match_dup 0))] ! "" ! "* ! { ! if (STACK_TOP_P (operands[0])) ! return AS1 (fxch,%1); ! else ! return AS1 (fxch,%0); ! }") ! ! (define_expand "movxf" ! [(set (match_operand:XF 0 "general_operand" "") ! (match_operand:XF 1 "general_operand" ""))] ! "" ! " ! { ! /* Special case memory->memory moves and pushes */ ! if (TARGET_MOVE ! && (reload_in_progress | reload_completed) == 0 ! && GET_CODE (operands[0]) == MEM ! && (GET_CODE (operands[1]) == MEM || push_operand (operands[0], XFmode))) ! { ! rtx (*genfunc) PROTO((rtx, rtx)) = (push_operand (operands[0], XFmode)) ! ? gen_movxf_push ! : gen_movxf_mem; ! ! emit_insn ((*genfunc) (operands[0], operands[1])); ! DONE; ! } ! ! /* If we are loading a floating point constant that isn't 0 or 1 into a register, ! indicate we need the pic register loaded. This could be optimized into stores ! of constants if the target eventually moves to memory, but better safe than ! sorry. */ ! if (flag_pic ! && GET_CODE (operands[0]) != MEM ! && GET_CODE (operands[1]) == CONST_DOUBLE ! && !standard_80387_constant_p (operands[1])) ! { ! current_function_uses_pic_offset_table = 1; ! } ! }") ! ! ! (define_insn "movxf_push_nomove" [(set (match_operand:XF 0 "push_operand" "=<,<") (match_operand:XF 1 "general_operand" "gF,f"))] ! "!TARGET_MOVE" "* { *************** *** 1162,1188 **** } else ! return (char *) output_move_double (operands); }") ! (define_insn "swapxf" ! [(set (match_operand:XF 0 "register_operand" "f") ! (match_operand:XF 1 "register_operand" "f")) ! (set (match_dup 1) ! (match_dup 0))] "" "* { ! if (STACK_TOP_P (operands[0])) ! return AS1 (fxch,%1); else ! return AS1 (fxch,%0); }") ! (define_insn "movxf" [(set (match_operand:XF 0 "general_operand" "=f,fm,!*rf,!*rm") (match_operand:XF 1 "general_operand" "fmG,f,*rfm,*rfF"))] ! ;; [(set (match_operand:XF 0 "general_operand" "=*rf,*rfm,f,!*rm") ! ;; (match_operand:XF 1 "general_operand" "*rfm,*rf,fG,fF"))] ! "" "* { --- 1470,1520 ---- } else ! return output_move_double (operands); }") ! (define_insn "movxf_push" ! [(set (match_operand:XF 0 "push_operand" "=<,<,<,<,<") ! (match_operand:XF 1 "general_operand" "rF,f,o,o,o")) ! (clobber (match_scratch:SI 2 "=X,X,&r,&r,X")) ! (clobber (match_scratch:SI 3 "=X,X,&r,X,X"))] "" "* { ! if (STACK_REG_P (operands[1])) ! { ! rtx xops[3]; ! ! xops[0] = AT_SP (SFmode); ! xops[1] = GEN_INT (12); ! xops[2] = stack_pointer_rtx; ! ! output_asm_insn (AS2 (sub%L2,%1,%2), xops); ! output_asm_insn (AS1 (fstp%T0,%0), xops); ! if (! find_regno_note (insn, REG_DEAD, FIRST_STACK_REG)) ! output_asm_insn (AS1 (fld%T0,%0), xops); ! ! RET; ! } ! ! else if (GET_CODE (operands[1]) != MEM ! || GET_CODE (operands[2]) != REG) ! return output_move_double (operands); ! else ! return output_move_pushmem (operands, insn, GET_MODE_SIZE (XFmode), 2, 4); }") ! (define_insn "movxf_mem" ! [(set (match_operand:XF 0 "memory_operand" "=o,o") ! (match_operand:XF 1 "memory_operand" "o,o")) ! (clobber (match_scratch:SI 2 "=&r,&r")) ! (clobber (match_scratch:SI 3 "=&r,X"))] ! "" ! "* return output_move_memory (operands, insn, GET_MODE_SIZE (XFmode), 2, 4);") ! ! (define_insn "movxf_normal" [(set (match_operand:XF 0 "general_operand" "=f,fm,!*rf,!*rm") (match_operand:XF 1 "general_operand" "fmG,f,*rfm,*rfF"))] ! "(!TARGET_MOVE || GET_CODE (operands[0]) != MEM) || (GET_CODE (operands[1]) != MEM)" "* { *************** *** 1227,1231 **** if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return (char *) output_move_const_single (operands); if (STACK_TOP_P (operands[0])) --- 1559,1563 ---- if (STACK_TOP_P (operands[0]) && GET_CODE (operands[1]) == CONST_DOUBLE) ! return output_move_const_single (operands); if (STACK_TOP_P (operands[0])) *************** *** 1234,1257 **** /* Handle all XFmode moves not involving the 387 */ ! return (char *) output_move_double (operands); }") (define_insn "" ! [(set (match_operand:DI 0 "push_operand" "=<") ! (match_operand:DI 1 "general_operand" "roiF"))] "" "* { ! return (char *) output_move_double (operands); }") (define_insn "movdi" ! [(set (match_operand:DI 0 "general_operand" "=r,rm") ! (match_operand:DI 1 "general_operand" "m,riF"))] "" "* { ! return (char *) output_move_double (operands); }") ;;- conversion instructions --- 1566,1617 ---- /* Handle all XFmode moves not involving the 387 */ ! return output_move_double (operands); ! }") ! ! (define_insn "swapxf" ! [(set (match_operand:XF 0 "register_operand" "f") ! (match_operand:XF 1 "register_operand" "f")) ! (set (match_dup 1) ! (match_dup 0))] ! "" ! "* ! { ! if (STACK_TOP_P (operands[0])) ! return AS1 (fxch,%1); ! else ! return AS1 (fxch,%0); }") (define_insn "" ! [(set (match_operand:DI 0 "push_operand" "=<,<,<,<") ! (match_operand:DI 1 "general_operand" "riF,o,o,o")) ! (clobber (match_scratch:SI 2 "=X,&r,&r,X")) ! (clobber (match_scratch:SI 3 "=X,&r,X,X"))] "" "* { ! if (GET_CODE (operands[1]) != MEM) ! return output_move_double (operands); ! ! else ! return output_move_pushmem (operands, insn, GET_MODE_SIZE (DImode), 2, 4); }") (define_insn "movdi" ! [(set (match_operand:DI 0 "general_operand" "=o,o,r,rm") ! (match_operand:DI 1 "general_operand" "o,o,m,riF")) ! (clobber (match_scratch:SI 2 "=&r,&r,X,X")) ! (clobber (match_scratch:SI 3 "=&r,X,X,X"))] "" "* { ! rtx low[2], high[2], xop[6]; ! ! if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM) ! return output_move_double (operands); ! else ! return output_move_memory (operands, insn, GET_MODE_SIZE (DImode), 2, 4); }") + ;;- conversion instructions *************** *** 1268,1272 **** "* { ! if ((TARGET_486 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { --- 1628,1632 ---- "* { ! if ((!TARGET_386 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { *************** *** 1292,1296 **** "* { ! if ((TARGET_486 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { --- 1652,1656 ---- "* { ! if ((!TARGET_386 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { *************** *** 1316,1320 **** "* { ! if ((TARGET_486 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { --- 1676,1680 ---- "* { ! if ((!TARGET_386 || REGNO (operands[0]) == 0) && REG_P (operands[1]) && REGNO (operands[0]) == REGNO (operands[1])) { *************** *** 1779,1783 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") (define_insn "" --- 2139,2143 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") (define_insn "" *************** *** 1789,1793 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") (define_insn "" --- 2149,2153 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") (define_insn "" *************** *** 1799,1803 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") ;; Signed MODE_FLOAT conversion to SImode. --- 2159,2163 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") ;; Signed MODE_FLOAT conversion to SImode. *************** *** 1852,1856 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") (define_insn "" --- 2212,2216 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") (define_insn "" *************** *** 1861,1865 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") (define_insn "" --- 2221,2225 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") (define_insn "" *************** *** 1870,1874 **** (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return (char *) output_fix_trunc (insn, operands);") ;; Conversion between fixed point and floating point. --- 2230,2234 ---- (clobber (match_scratch:SI 4 "=&q"))] "TARGET_80387" ! "* return output_fix_trunc (insn, operands);") ;; Conversion between fixed point and floating point. *************** *** 2020,2036 **** (define_insn "adddi3" ! [(set (match_operand:DI 0 "general_operand" "=&r,ro") ! (plus:DI (match_operand:DI 1 "general_operand" "%0,0") ! (match_operand:DI 2 "general_operand" "o,riF")))] "" "* { ! rtx low[3], high[3]; CC_STATUS_INIT; split_di (operands, 3, low, high); ! if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0) { output_asm_insn (AS2 (add%L0,%2,%0), low); --- 2380,2444 ---- (define_insn "adddi3" ! [(set (match_operand:DI 0 "general_operand" "=&r,ro,o,&r,ro,o,&r,o,o,o") ! (plus:DI (match_operand:DI 1 "general_operand" "%0,0,0,o,riF,o,or,riF,riF,o") ! (match_operand:DI 2 "general_operand" "o,riF,o,0,0,0,oriF,riF,o,o"))) ! (clobber (match_scratch:SI 3 "=X,X,&r,X,X,&r,X,X,&r,&r"))] "" "* { ! rtx low[3], high[3], xops[7], temp; CC_STATUS_INIT; + if (rtx_equal_p (operands[0], operands[2])) + { + temp = operands[1]; + operands[1] = operands[2]; + operands[2] = temp; + } + split_di (operands, 3, low, high); + if (!rtx_equal_p (operands[0], operands[1])) + { + xops[0] = high[0]; + xops[1] = low[0]; + xops[2] = high[1]; + xops[3] = low[1]; + + if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM) + { + output_asm_insn (AS2 (mov%L1,%3,%1), xops); + output_asm_insn (AS2 (mov%L0,%2,%0), xops); + } + else + { + xops[4] = high[2]; + xops[5] = low[2]; + xops[6] = operands[3]; + output_asm_insn (AS2 (mov%L6,%3,%6), xops); + output_asm_insn (AS2 (add%L6,%5,%6), xops); + output_asm_insn (AS2 (mov%L1,%6,%1), xops); + output_asm_insn (AS2 (mov%L6,%2,%6), xops); + output_asm_insn (AS2 (adc%L6,%4,%6), xops); + output_asm_insn (AS2 (mov%L0,%6,%0), xops); + RET; + } + } + + if (GET_CODE (operands[3]) == REG && GET_CODE (operands[2]) != REG) + { + xops[0] = high[0]; + xops[1] = low[0]; + xops[2] = high[2]; + xops[3] = low[2]; + xops[4] = operands[3]; + + output_asm_insn (AS2 (mov%L4,%3,%4), xops); + output_asm_insn (AS2 (add%L1,%4,%1), xops); + output_asm_insn (AS2 (mov%L4,%2,%4), xops); + output_asm_insn (AS2 (adc%L0,%4,%0), xops); + } ! else if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0) { output_asm_insn (AS2 (add%L0,%2,%0), low); *************** *** 2037,2042 **** --- 2445,2452 ---- output_asm_insn (AS2 (adc%L0,%2,%0), high); } + else output_asm_insn (AS2 (add%L0,%2,%0), high); + RET; }") *************** *** 2057,2077 **** return AS2 (add%L0,%1,%0); ! if (! TARGET_486 || ! REG_P (operands[2])) ! { ! CC_STATUS_INIT; ! if (operands[2] == stack_pointer_rtx) ! { ! rtx temp; ! temp = operands[1]; ! operands[1] = operands[2]; ! operands[2] = temp; ! } ! if (operands[2] != stack_pointer_rtx) ! { ! operands[1] = SET_SRC (PATTERN (insn)); ! return AS2 (lea%L0,%a1,%0); ! } } --- 2467,2484 ---- return AS2 (add%L0,%1,%0); ! if (operands[2] == stack_pointer_rtx) ! { ! rtx temp; ! temp = operands[1]; ! operands[1] = operands[2]; ! operands[2] = temp; ! } ! if (operands[2] != stack_pointer_rtx) ! { ! CC_STATUS_INIT; ! operands[1] = SET_SRC (PATTERN (insn)); ! return AS2 (lea%L0,%a1,%0); } *************** *** 2172,2176 **** ;; addsi3 is faster, so put this after. ! (define_insn "" [(set (match_operand:SI 0 "register_operand" "=r") (match_operand:QI 1 "address_operand" "p"))] --- 2579,2583 ---- ;; addsi3 is faster, so put this after. ! (define_insn "movsi_lea" [(set (match_operand:SI 0 "register_operand" "=r") (match_operand:QI 1 "address_operand" "p"))] *************** *** 2224,2234 **** (define_insn "subdi3" ! [(set (match_operand:DI 0 "general_operand" "=&r,ro") ! (minus:DI (match_operand:DI 1 "general_operand" "0,0") ! (match_operand:DI 2 "general_operand" "o,riF")))] "" "* { ! rtx low[3], high[3]; CC_STATUS_INIT; --- 2631,2642 ---- (define_insn "subdi3" ! [(set (match_operand:DI 0 "general_operand" "=&r,ro,&r,o,o") ! (minus:DI (match_operand:DI 1 "general_operand" "0,0,roiF,riF,o") ! (match_operand:DI 2 "general_operand" "o,riF,roiF,riF,o"))) ! (clobber (match_scratch:SI 3 "=X,X,X,X,&r"))] "" "* { ! rtx low[3], high[3], xops[7]; CC_STATUS_INIT; *************** *** 2236,2240 **** split_di (operands, 3, low, high); ! if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0) { output_asm_insn (AS2 (sub%L0,%2,%0), low); --- 2644,2689 ---- split_di (operands, 3, low, high); ! if (!rtx_equal_p (operands[0], operands[1])) ! { ! xops[0] = high[0]; ! xops[1] = low[0]; ! xops[2] = high[1]; ! xops[3] = low[1]; ! ! if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != MEM) ! { ! output_asm_insn (AS2 (mov%L1,%3,%1), xops); ! output_asm_insn (AS2 (mov%L0,%2,%0), xops); ! } ! else ! { ! xops[4] = high[2]; ! xops[5] = low[2]; ! xops[6] = operands[3]; ! output_asm_insn (AS2 (mov%L6,%3,%6), xops); ! output_asm_insn (AS2 (sub%L6,%5,%6), xops); ! output_asm_insn (AS2 (mov%L1,%6,%1), xops); ! output_asm_insn (AS2 (mov%L6,%2,%6), xops); ! output_asm_insn (AS2 (sbb%L6,%4,%6), xops); ! output_asm_insn (AS2 (mov%L0,%6,%0), xops); ! RET; ! } ! } ! ! if (GET_CODE (operands[3]) == REG) ! { ! xops[0] = high[0]; ! xops[1] = low[0]; ! xops[2] = high[2]; ! xops[3] = low[2]; ! xops[4] = operands[3]; ! ! output_asm_insn (AS2 (mov%L4,%3,%4), xops); ! output_asm_insn (AS2 (sub%L1,%4,%1), xops); ! output_asm_insn (AS2 (mov%L4,%2,%4), xops); ! output_asm_insn (AS2 (sbb%L0,%4,%0), xops); ! } ! ! else if (GET_CODE (low[2]) != CONST_INT || INTVAL (low[2]) != 0) { output_asm_insn (AS2 (sub%L0,%2,%0), low); *************** *** 2241,2244 **** --- 2690,2694 ---- output_asm_insn (AS2 (sbb%L0,%2,%0), high); } + else output_asm_insn (AS2 (sub%L0,%2,%0), high); *************** *** 2362,2366 **** (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "%0")) (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))))] ! "" "mul%L0 %2") --- 2812,2816 ---- (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "%0")) (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))))] ! "TARGET_WIDE_MULTIPLY" "mul%L0 %2") *************** *** 2369,2373 **** (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "%0")) (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))))] ! "" "imul%L0 %2") --- 2819,2841 ---- (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "%0")) (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))))] ! "TARGET_WIDE_MULTIPLY" ! "imul%L0 %2") ! ! (define_insn "umulsi3_highpart" ! [(set (match_operand:SI 0 "register_operand" "=d") ! (truncate:SI (lshiftrt:DI (mult:DI (zero_extend:DI (match_operand:SI 1 "register_operand" "%a")) ! (zero_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))) ! (const_int 32)))) ! (clobber (match_scratch:SI 3 "=a"))] ! "TARGET_WIDE_MULTIPLY" ! "mul%L0 %2") ! ! (define_insn "smulsi3_highpart" ! [(set (match_operand:SI 0 "register_operand" "=d") ! (truncate:SI (lshiftrt:DI (mult:DI (sign_extend:DI (match_operand:SI 1 "register_operand" "%a")) ! (sign_extend:DI (match_operand:SI 2 "nonimmediate_operand" "rm"))) ! (const_int 32)))) ! (clobber (match_scratch:SI 3 "=a"))] ! "TARGET_WIDE_MULTIPLY" "imul%L0 %2") *************** *** 2534,2538 **** && (! REG_P (operands[1]) || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0) ! && (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1]))) { /* ??? tege: Should forget CC_STATUS only if we clobber a --- 3002,3006 ---- && (! REG_P (operands[1]) || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0) ! && (TARGET_386 || ! rtx_equal_p (operands[0], operands[1]))) { /* ??? tege: Should forget CC_STATUS only if we clobber a *************** *** 2550,2554 **** && (! REG_P (operands[1]) || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0) ! && (! TARGET_486 || ! rtx_equal_p (operands[0], operands[1]))) { /* ??? tege: Should forget CC_STATUS only if we clobber a --- 3018,3022 ---- && (! REG_P (operands[1]) || REGNO (operands[0]) != 0 || REGNO (operands[1]) != 0) ! && (TARGET_386 || ! rtx_equal_p (operands[0], operands[1]))) { /* ??? tege: Should forget CC_STATUS only if we clobber a *************** *** 3193,3197 **** if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1])) { ! if (TARGET_486 && INTVAL (operands[2]) == 1) { output_asm_insn (AS2 (mov%L0,%1,%0), operands); --- 3661,3665 ---- if (REG_P (operands[0]) && REGNO (operands[0]) != REGNO (operands[1])) { ! if (!TARGET_386 && INTVAL (operands[2]) == 1) { output_asm_insn (AS2 (mov%L0,%1,%0), operands); *************** *** 3694,3698 **** (match_operand:SI 2 "general_operand" "r")) (match_operand:SI 3 "const_int_operand" "n"))] ! "! TARGET_486 && GET_CODE (operands[2]) != CONST_INT" "* { --- 4162,4166 ---- (match_operand:SI 2 "general_operand" "r")) (match_operand:SI 3 "const_int_operand" "n"))] ! "TARGET_386 && GET_CODE (operands[2]) != CONST_INT" "* { *************** *** 3712,3716 **** (match_operand:SI 1 "general_operand" "r")) (match_operand:SI 2 "general_operand" "0")))] ! "! TARGET_486 && GET_CODE (operands[1]) != CONST_INT" "* { --- 4180,4184 ---- (match_operand:SI 1 "general_operand" "r")) (match_operand:SI 2 "general_operand" "0")))] ! "TARGET_386 && GET_CODE (operands[1]) != CONST_INT" "* { *************** *** 3725,3729 **** (ashift:SI (const_int 1) (match_operand:SI 2 "general_operand" "r"))))] ! "! TARGET_486 && GET_CODE (operands[2]) != CONST_INT" "* { --- 4193,4197 ---- (ashift:SI (const_int 1) (match_operand:SI 2 "general_operand" "r"))))] ! "TARGET_386 && GET_CODE (operands[2]) != CONST_INT" "* { *************** *** 4743,4750 **** "call %P1") (define_expand "untyped_call" ! [(parallel [(call (match_operand:QI 0 "indirect_operand" "") (const_int 0)) ! (match_operand:BLK 1 "memory_operand" "") (match_operand 2 "" "")])] "" --- 5211,5220 ---- "call %P1") + ;; Call subroutine returning any type. + (define_expand "untyped_call" ! [(parallel [(call (match_operand 0 "" "") (const_int 0)) ! (match_operand 1 "" "") (match_operand 2 "" "")])] "" *************** *** 4751,4866 **** " { ! rtx addr; ! ! if (flag_pic) ! current_function_uses_pic_offset_table = 1; ! ! /* With half-pic, force the address into a register. */ ! addr = XEXP (operands[0], 0); ! if (GET_CODE (addr) != REG && HALF_PIC_P () && !CONSTANT_ADDRESS_P (addr)) ! XEXP (operands[0], 0) = force_reg (Pmode, addr); ! ! operands[1] = change_address (operands[1], DImode, XEXP (operands[1], 0)); ! if (! expander_call_insn_operand (operands[1], QImode)) ! operands[1] ! = change_address (operands[1], VOIDmode, ! copy_to_mode_reg (Pmode, XEXP (operands[1], 0))); ! }") ! (define_insn "" ! [(call (match_operand:QI 0 "call_insn_operand" "m") ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "")] ! "" ! "* ! { ! rtx addr = operands[1]; ! if (GET_CODE (operands[0]) == MEM ! && ! CONSTANT_ADDRESS_P (XEXP (operands[0], 0))) { ! operands[0] = XEXP (operands[0], 0); ! output_asm_insn (AS1 (call,%*%0), operands); } - else - output_asm_insn (AS1 (call,%P0), operands); - - operands[2] = gen_rtx (REG, SImode, 0); - output_asm_insn (AS2 (mov%L2,%2,%1), operands); - - operands[2] = gen_rtx (REG, SImode, 1); - operands[1] = adj_offsettable_operand (addr, 4); - output_asm_insn (AS2 (mov%L2,%2,%1), operands); - - operands[1] = adj_offsettable_operand (addr, 8); - return AS1 (fnsave,%1); - }") ! (define_insn "" ! [(call (mem:QI (match_operand:SI 0 "symbolic_operand" "")) ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "")] ! "!HALF_PIC_P ()" ! "* ! { ! rtx addr = operands[1]; ! ! output_asm_insn (AS1 (call,%P0), operands); ! ! operands[2] = gen_rtx (REG, SImode, 0); ! output_asm_insn (AS2 (mov%L2,%2,%1), operands); ! ! operands[2] = gen_rtx (REG, SImode, 1); ! operands[1] = adj_offsettable_operand (addr, 4); ! output_asm_insn (AS2 (mov%L2,%2,%1), operands); ! ! operands[1] = adj_offsettable_operand (addr, 8); ! return AS1 (fnsave,%1); ! }") ! ! ;; We use fnsave and frstor to save and restore the floating point result. ! ;; These are expensive instructions and require a large space to save the ! ;; FPU state. An more complicated alternative is to use fnstenv to store ! ;; the FPU environment and test whether the stack top is valid. Store the ! ;; result of the test, and if it is valid, pop and save the value. The ! ;; untyped_return would check the test and optionally push the saved value. - (define_expand "untyped_return" - [(match_operand:BLK 0 "memory_operand" "") - (match_operand 1 "" "")] - "" - " - { - rtx valreg1 = gen_rtx (REG, SImode, 0); - rtx valreg2 = gen_rtx (REG, SImode, 1); - rtx result = operands[0]; - - /* Restore the FPU state. */ - emit_insn (gen_update_return (change_address (result, SImode, - plus_constant (XEXP (result, 0), - 8)))); - - /* Reload the function value registers. */ - emit_move_insn (valreg1, change_address (result, SImode, XEXP (result, 0))); - emit_move_insn (valreg2, - change_address (result, SImode, - plus_constant (XEXP (result, 0), 4))); - - /* Put USE insns before the return. */ - emit_insn (gen_rtx (USE, VOIDmode, valreg1)); - emit_insn (gen_rtx (USE, VOIDmode, valreg2)); - - /* Construct the return. */ - expand_null_return (); - DONE; }") ! (define_insn "update_return" ! [(unspec:SI [(match_operand:SI 0 "memory_operand" "m")] 0)] "" ! "frstor %0") ;; Insn emitted into the body of a function to return from a function. --- 5221,5250 ---- " { ! int i; ! emit_call_insn (gen_call (operands[0], const0_rtx, NULL, const0_rtx)); ! for (i = 0; i < XVECLEN (operands[2], 0); i++) { ! rtx set = XVECEXP (operands[2], 0, i); ! emit_move_insn (SET_DEST (set), SET_SRC (set)); } ! /* The optimizer does not know that the call sets the function value ! registers we stored in the result block. We avoid problems by ! claiming that all hard registers are used and clobbered at this ! point. */ ! emit_insn (gen_blockage ()); DONE; }") ! ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and ! ;; all of memory. This blocks insns from being moved across this point. ! ! (define_insn "blockage" ! [(unspec_volatile [(const_int 0)] 0)] "" ! "") ;; Insn emitted into the body of a function to return from a function. *************** *** 5154,5158 **** (match_operand:DF 2 "nonimmediate_operand" "fm,0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5538,5542 ---- (match_operand:DF 2 "nonimmediate_operand" "fm,0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5162,5166 **** (match_operand:DF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5546,5550 ---- (match_operand:DF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5170,5174 **** (match_operand:XF 2 "nonimmediate_operand" "f,0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5554,5558 ---- (match_operand:XF 2 "nonimmediate_operand" "f,0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5178,5182 **** (match_operand:XF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5562,5566 ---- (match_operand:XF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5186,5190 **** (match_operand:XF 2 "general_operand" "0,f")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5570,5574 ---- (match_operand:XF 2 "general_operand" "0,f")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5194,5198 **** (float:XF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5578,5582 ---- (float:XF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5203,5207 **** (match_operand:SF 2 "general_operand" "fm,0"))]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5587,5591 ---- (match_operand:SF 2 "general_operand" "fm,0"))]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5211,5215 **** (match_operand:DF 2 "general_operand" "0,f")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5595,5599 ---- (match_operand:DF 2 "general_operand" "0,f")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5219,5223 **** (float:DF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5603,5607 ---- (float:DF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5228,5232 **** (match_operand:SF 2 "general_operand" "fm,0"))]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5612,5616 ---- (match_operand:SF 2 "general_operand" "fm,0"))]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5236,5240 **** (match_operand:SF 2 "nonimmediate_operand" "fm,0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5620,5624 ---- (match_operand:SF 2 "nonimmediate_operand" "fm,0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5244,5248 **** (match_operand:SF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_insn "" --- 5628,5632 ---- (match_operand:SF 2 "general_operand" "0")]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_insn "" *************** *** 5252,5256 **** (float:SF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return (char *) output_387_binary_op (insn, operands);") (define_expand "strlensi" --- 5636,5640 ---- (float:SF (match_operand:SI 2 "general_operand" "rm"))]))] "TARGET_80387" ! "* return output_387_binary_op (insn, operands);") (define_expand "strlensi" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/linux.h gcc-2.6.1/config/i386/linux.h *** gcc-2.6.0/config/i386/linux.h Tue Jun 14 17:42:25 1994 --- gcc-2.6.1/config/i386/linux.h Mon Oct 10 10:10:04 1994 *************** *** 78,82 **** #undef STARTFILE_SPEC ! #define STARTFILE_SPEC "%{pg:gcrt0.o%s} %{!pg:%{p:gcrt0.o%s} %{!p:crt0.o%s}}" --- 78,82 ---- #undef STARTFILE_SPEC ! #define STARTFILE_SPEC "%{pg:gcrt0.o%s} %{!pg:%{p:gcrt0.o%s} %{!p:crt0.o%s}} %{static:-static}" *************** *** 94,98 **** --- 94,100 ---- /* Don't default to pcc-struct-return, because gcc is the only compiler, and we want to retain compatibility with older gcc versions. */ + #ifndef LINUX_ELF #define DEFAULT_PCC_STRUCT_RETURN 0 + #endif /* We need that too. */ *************** *** 107,108 **** --- 109,113 ---- #define LINK_SPEC "%{v:-dll-verbose} %{m486:-m486}" #endif + + /* Get perform_* macros to build libgcc.a. */ + #include "i386/perform.h" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/linuxelf.h gcc-2.6.1/config/i386/linuxelf.h *** gcc-2.6.0/config/i386/linuxelf.h Fri Oct 8 17:41:03 1993 --- gcc-2.6.1/config/i386/linuxelf.h Mon Oct 10 10:10:04 1994 *************** *** 22,28 **** /* The svr4 ABI for the i386 says that records and unions are returned in memory. */ ! #undef RETURN_IN_MEMORY ! #define RETURN_IN_MEMORY(TYPE) \ ! (TYPE_MODE (TYPE) == BLKmode) /* This is how to output an element of a case-vector that is relative. This is only used for PIC code. See comments by the `casesi' insn in --- 22,27 ---- /* The svr4 ABI for the i386 says that records and unions are returned in memory. */ ! #undef DEFAULT_PCC_STRUCT_RETURN ! #define DEFAULT_PCC_STRUCT_RETURN 1 /* This is how to output an element of a case-vector that is relative. This is only used for PIC code. See comments by the `casesi' insn in diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/lynx-ng.h gcc-2.6.1/config/i386/lynx-ng.h *** gcc-2.6.0/config/i386/lynx-ng.h Mon Jul 11 16:29:25 1994 --- gcc-2.6.1/config/i386/lynx-ng.h Fri Sep 23 16:11:28 1994 *************** *** 29,30 **** --- 29,36 ---- #define LINK_SPEC "-P1000 %{msystem-v:-V} %{mcoff:-k}" + /* Apparently LynxOS clobbers ebx when you call into the OS. */ + + #undef CALL_USED_REGISTERS + #define CALL_USED_REGISTERS \ + /*ax,dx,cx,bx,si,di,bp,sp,st,st1,st2,st3,st4,st5,st6,st7,arg*/ \ + { 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/netbsd-i386.h gcc-2.6.1/config/i386/netbsd-i386.h *** gcc-2.6.0/config/i386/netbsd-i386.h Thu Jul 14 12:56:12 1994 --- gcc-2.6.1/config/i386/netbsd-i386.h Tue Oct 18 20:59:53 1994 *************** *** 78,155 **** } \ } - - /* A C statement or compound statement to output to FILE some - assembler code to initialize basic-block profiling for the current - object module. This code should call the subroutine - `__bb_init_func' once per object module, passing it as its sole - argument the address of a block allocated in the object module. - - The name of the block is a local symbol made with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. - - The first word of this block is a flag which will be nonzero if the - object module has already been initialized. So test this word - first, and do not call `__bb_init_func' if the flag is nonzero. */ - - #undef FUNCTION_BLOCK_PROFILER - #define FUNCTION_BLOCK_PROFILER(STREAM, LABELNO) \ - do \ - { \ - if (!flag_pic) \ - { \ - fprintf (STREAM, "\tcmpl $0,%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl $%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tcall ___bb_init_func\n"); \ - fprintf (STREAM, "0:\n"); \ - } \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX0@GOT(%ebx),%eax\n"); \ - fprintf (STREAM, "\tcmpl $0,(%eax)\n"); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tcall ___bb_init_func@PLT\n"); \ - fprintf (STREAM, "0:\n"); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - - /* A C statement or compound statement to increment the count - associated with the basic block number BLOCKNO. Basic blocks are - numbered separately from zero within each compilation. The count - associated with block number BLOCKNO is at index BLOCKNO in a - vector of words; the name of this array is a local symbol made - with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. */ - - #undef BLOCK_PROFILER - #define BLOCK_PROFILER(STREAM, BLOCKNO) \ - do \ - { \ - if (!flag_pic) \ - fprintf (STREAM, "\tincl %sPBX2+%d\n", LPREFIX, (BLOCKNO)*4); \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX2@GOT(%ebx),%eax\n", LPREFIX); \ - fprintf (STREAM, "\tincl %d(%eax)\n", (BLOCKNO)*4); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - --- 78,79 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/osfrose.h gcc-2.6.1/config/i386/osfrose.h *** gcc-2.6.0/config/i386/osfrose.h Tue Jul 12 10:54:57 1994 --- gcc-2.6.1/config/i386/osfrose.h Wed Oct 26 17:14:11 1994 *************** *** 49,59 **** || (CHAR) == 'z') ! #define MASK_HALF_PIC 0x40000000 /* Mask for half-pic code */ ! #define MASK_HALF_PIC_DEBUG 0x20000000 /* Debug flag */ ! #define MASK_ELF 0x10000000 /* ELF not rose */ ! #define MASK_NO_IDENT 0x08000000 /* suppress .ident */ ! #define MASK_NO_UNDERSCORES 0x04000000 /* suppress leading _ */ ! #define MASK_LARGE_ALIGN 0x02000000 /* align to >word boundaries */ ! #define MASK_NO_MCOUNT 0x01000000 /* profiling uses mcount_ptr */ #define TARGET_HALF_PIC (target_flags & MASK_HALF_PIC) --- 49,59 ---- || (CHAR) == 'z') ! #define MASK_HALF_PIC 010000000000 /* Mask for half-pic code */ ! #define MASK_HALF_PIC_DEBUG 004000000000 /* Debug flag */ ! #define MASK_ELF 002000000000 /* ELF not rose */ ! #define MASK_NO_IDENT 001000000000 /* suppress .ident */ ! #define MASK_NO_UNDERSCORES 000400000000 /* suppress leading _ */ ! #define MASK_LARGE_ALIGN 000200000000 /* align to >word boundaries */ ! #define MASK_NO_MCOUNT 000100000000 /* profiling uses mcount_ptr */ #define TARGET_HALF_PIC (target_flags & MASK_HALF_PIC) *************** *** 68,87 **** #undef SUBTARGET_SWITCHES ! #define SUBTARGET_SWITCHES \ ! { "half-pic", MASK_HALF_PIC}, \ ! { "no-half-pic", -MASK_HALF_PIC}, \ ! { "debug-half-pic", MASK_HALF_PIC_DEBUG}, \ ! { "debugb", MASK_HALF_PIC_DEBUG}, \ ! { "elf", MASK_ELF}, \ ! { "rose", -MASK_ELF}, \ ! { "ident", -MASK_NO_IDENT}, \ ! { "no-ident", MASK_NO_IDENT}, \ ! { "underscores", -MASK_NO_UNDERSCORES}, \ ! { "no-underscores", MASK_NO_UNDERSCORES}, \ ! { "large-align", MASK_LARGE_ALIGN}, \ ! { "no-large-align",-MASK_LARGE_ALIGN}, \ ! { "mcount", -MASK_NO_MCOUNT}, \ ! { "mcount-ptr", MASK_NO_MCOUNT}, \ ! { "no-mcount", MASK_NO_MCOUNT}, /* OSF/rose uses stabs, not dwarf. */ --- 68,87 ---- #undef SUBTARGET_SWITCHES ! #define SUBTARGET_SWITCHES \ ! { "half-pic", MASK_HALF_PIC}, \ ! { "no-half-pic", -MASK_HALF_PIC}, \ ! { "debug-half-pic", MASK_HALF_PIC_DEBUG}, \ ! { "debugb", MASK_HALF_PIC_DEBUG}, \ ! { "elf", MASK_ELF}, \ ! { "rose", -MASK_ELF}, \ ! { "ident", -MASK_NO_IDENT}, \ ! { "no-ident", MASK_NO_IDENT}, \ ! { "underscores", -MASK_NO_UNDERSCORES}, \ ! { "no-underscores", MASK_NO_UNDERSCORES}, \ ! { "large-align", MASK_LARGE_ALIGN}, \ ! { "no-large-align", -MASK_LARGE_ALIGN}, \ ! { "mcount", -MASK_NO_MCOUNT}, \ ! { "mcount-ptr", MASK_NO_MCOUNT}, \ ! { "no-mcount", MASK_NO_MCOUNT}, /* OSF/rose uses stabs, not dwarf. */ *************** *** 179,184 **** #define WCHAR_TYPE_SIZE BITS_PER_WORD ! /* Temporarily turn off long double being 96 bits. */ #undef LONG_DOUBLE_TYPE_SIZE /* This macro generates the assembly code for function entry. --- 179,193 ---- #define WCHAR_TYPE_SIZE BITS_PER_WORD ! /* Define this macro if the system header files support C++ as well ! as C. This macro inhibits the usual method of using system header ! files in C++, which is to pretend that the file's contents are ! enclosed in `extern "C" {...}'. */ ! #define NO_IMPLICIT_EXTERN_C ! ! #ifdef NO_LONG_DOUBLE ! /* Turn off long double being 96 bits. */ #undef LONG_DOUBLE_TYPE_SIZE + #define LONG_DOUBLE_TYPE_SIZE 64 + #endif /* This macro generates the assembly code for function entry. *************** *** 258,262 **** the number LABELNO, so you would generate the name using `LP%d' in a `fprintf'. ! The details of how the address should be passed to `mcount' are determined by your operating system environment, not by GNU CC. To figure them out, --- 267,271 ---- the number LABELNO, so you would generate the name using `LP%d' in a `fprintf'. ! The details of how the address should be passed to `mcount' are determined by your operating system environment, not by GNU CC. To figure them out, *************** *** 333,413 **** while (0) - /* A C statement or compound statement to output to FILE some - assembler code to initialize basic-block profiling for the current - object module. This code should call the subroutine - `__bb_init_func' once per object module, passing it as its sole - argument the address of a block allocated in the object module. - - The name of the block is a local symbol made with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 0); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. - - The first word of this block is a flag which will be nonzero if the - object module has already been initialized. So test this word - first, and do not call `__bb_init_func' if the flag is nonzero. */ - - #undef FUNCTION_BLOCK_PROFILER - #define FUNCTION_BLOCK_PROFILER(STREAM, LABELNO) \ - do \ - { \ - if (!flag_pic) \ - { \ - fprintf (STREAM, "\tcmpl $0,%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl $%sPBX0\n", LPREFIX); \ - fprintf (STREAM, "\tcall %s__bb_init_func\n", \ - (TARGET_UNDERSCORES) ? "_" : ""); \ - fprintf (STREAM, "0:\n"); \ - } \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX0@GOT(%ebx),%eax\n"); \ - fprintf (STREAM, "\tcmpl $0,(%eax)\n"); \ - fprintf (STREAM, "\tjne 0f\n"); \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tcall %s__bb_init_func@PLT\n", \ - (TARGET_UNDERSCORES) ? "_" : ""); \ - fprintf (STREAM, "0:\n"); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - - /* A C statement or compound statement to increment the count - associated with the basic block number BLOCKNO. Basic blocks are - numbered separately from zero within each compilation. The count - associated with block number BLOCKNO is at index BLOCKNO in a - vector of words; the name of this array is a local symbol made - with this statement: - - ASM_GENERATE_INTERNAL_LABEL (BUFFER, "LPBX", 2); - - Of course, since you are writing the definition of - `ASM_GENERATE_INTERNAL_LABEL' as well as that of this macro, you - can take a short cut in the definition of this macro and use the - name that you know will result. */ - - #undef BLOCK_PROFILER - #define BLOCK_PROFILER(STREAM, BLOCKNO) \ - do \ - { \ - if (!flag_pic) \ - fprintf (STREAM, "\tincl %sPBX2+%d\n", LPREFIX, (BLOCKNO)*4); \ - else \ - { \ - fprintf (STREAM, "\tpushl %eax\n"); \ - fprintf (STREAM, "\tmovl %sPBX2@GOT(%ebx),%eax\n", LPREFIX); \ - fprintf (STREAM, "\tincl %d(%eax)\n", (BLOCKNO)*4); \ - fprintf (STREAM, "\tpopl %eax\n"); \ - } \ - } \ - while (0) - /* A C function or functions which are needed in the library to support block profiling. When support goes into libc, undo --- 342,345 ---- *************** *** 531,588 **** || !HALF_PIC_ADDRESS_P (X)) - /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression - that is a valid memory address for an instruction. - The MODE argument is the machine mode for the MEM expression - that wants to use this address. */ - - #define GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR) \ - { \ - if (CONSTANT_ADDRESS_P (X) \ - && (! flag_pic || LEGITIMATE_PIC_OPERAND_P (X))) \ - goto ADDR; \ - GO_IF_INDEXING (X, ADDR); \ - if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \ - { \ - rtx x0 = XEXP (X, 0); \ - if (! flag_pic || ! SYMBOLIC_CONST (XEXP (X, 1))) \ - { GO_IF_INDEXING (x0, ADDR); } \ - else if (x0 == pic_offset_table_rtx) \ - goto ADDR; \ - else if (GET_CODE (x0) == PLUS) \ - { \ - if (XEXP (x0, 0) == pic_offset_table_rtx) \ - { GO_IF_INDEXABLE_BASE (XEXP (x0, 1), ADDR); } \ - if (XEXP (x0, 1) == pic_offset_table_rtx) \ - { GO_IF_INDEXABLE_BASE (XEXP (x0, 0), ADDR); } \ - } \ - } \ - } - - #undef GO_IF_LEGITIMATE_ADDRESS - #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR) \ - { \ - if (! HALF_PIC_P ()) \ - { \ - GO_IF_LEGITIMATE_ADDRESS_ORIG(MODE, X, ADDR); \ - } \ - else \ - { \ - if (CONSTANT_P (X) && ! HALF_PIC_ADDRESS_P (X)) \ - goto ADDR; \ - \ - GO_IF_INDEXING (X, ADDR); \ - if (GET_CODE (X) == PLUS) \ - { \ - rtx x1 = XEXP (X, 1); \ - \ - if (CONSTANT_P (x1) && ! HALF_PIC_ADDRESS_P (x1)) \ - { \ - rtx x0 = XEXP (X, 0); \ - GO_IF_INDEXING (x0, ADDR); \ - } \ - } \ - } \ - } - /* Sometimes certain combinations of command options do not make sense on a particular target machine. You can define a macro --- 463,466 ---- *************** *** 617,621 **** The macro definition, if any, is executed immediately after the ! rtl for DECL has been created and stored in `DECL_RTL (DECL)'. The value of the rtl will be a `mem' whose address is a `symbol_ref'. --- 495,499 ---- The macro definition, if any, is executed immediately after the ! rtl for DECL has been created and stored in `DECL_RTL (DECL)'. The value of the rtl will be a `mem' whose address is a `symbol_ref'. *************** *** 627,631 **** The best way to modify the name string is by adding text to the ! beginning, with suitable punctuation to prevent any ambiguity. Allocate the new name in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to remove and decode the added text --- 505,509 ---- The best way to modify the name string is by adding text to the ! beginning, with suitable punctuation to prevent any ambiguity. Allocate the new name in `saveable_obstack'. You will have to modify `ASM_OUTPUT_LABELREF' to remove and decode the added text *************** *** 754,758 **** STREAM any text necessary for declaring the name NAME of an initialized variable which is being defined. This macro must ! output the label definition (perhaps using `ASM_OUTPUT_LABEL'). The argument DECL is the `VAR_DECL' tree node representing the variable. --- 632,636 ---- STREAM any text necessary for declaring the name NAME of an initialized variable which is being defined. This macro must ! output the label definition (perhaps using `ASM_OUTPUT_LABEL'). The argument DECL is the `VAR_DECL' tree node representing the variable. *************** *** 915,918 **** --- 793,802 ---- fprintf ((STREAM), " -funroll-loops"); \ \ + if (flag_schedule_insns) \ + fprintf ((STREAM), " -fschedule-insns"); \ + \ + if (flag_schedule_insns_after_reload) \ + fprintf ((STREAM), " -fschedule-insns2"); \ + \ if (flag_force_mem) \ fprintf ((STREAM), " -fforce-mem"); \ *************** *** 948,952 **** fprintf ((STREAM), " -mhalf-pic"); \ \ ! fprintf ((STREAM), (TARGET_486) ? " -m486" : " -m386"); \ fprintf ((STREAM), (TARGET_ELF) ? " -melf\"\n" : " -mrose\"\n"); \ } \ --- 832,847 ---- fprintf ((STREAM), " -mhalf-pic"); \ \ ! if (!TARGET_MOVE) \ ! fprintf ((STREAM), " -mno-move"); \ ! \ ! if (TARGET_386) \ ! fprintf ((STREAM), " -m386"); \ ! \ ! else if (TARGET_486) \ ! fprintf ((STREAM), " -m486"); \ ! \ ! else \ ! fprintf ((STREAM), " -munknown-machine"); \ ! \ fprintf ((STREAM), (TARGET_ELF) ? " -melf\"\n" : " -mrose\"\n"); \ } \ *************** *** 958,963 **** /* Tell collect where the appropriate binaries are. */ ! #define REAL_LD_FILE_NAME "/usr/ccs/gcc/gld" ! #define REAL_NM_FILE_NAME "/usr/ccs/bin/nm" #define REAL_STRIP_FILE_NAME "/usr/ccs/bin/strip" --- 853,857 ---- /* Tell collect where the appropriate binaries are. */ ! #define REAL_NM_FILE_NAME "/usr/ccs/gcc/bfd-nm" #define REAL_STRIP_FILE_NAME "/usr/ccs/bin/strip" *************** *** 985,1044 **** output_lang_identify (STREAM); \ } - - /* This is how to output an assembler line defining a `double' constant. - Use "word" pseudos to avoid printing NaNs, infinity, etc. */ - - /* This is how to output an assembler line defining a `double' constant. */ - #undef ASM_OUTPUT_DOUBLE - #define ASM_OUTPUT_DOUBLE(STREAM, VALUE) \ - do \ - { \ - long value_long[2]; \ - char dstr[30]; \ - REAL_VALUE_TO_TARGET_DOUBLE (VALUE, value_long); \ - REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \ - if (sizeof (int) == sizeof (long)) \ - fprintf (STREAM, "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n", \ - value_long[0], dstr, value_long[1]); \ - else \ - fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n", \ - value_long[0], dstr, value_long[1]); \ - } \ - while (0) - - /* This is how to output an assembler line defining a `float' constant. */ - #undef ASM_OUTPUT_FLOAT - #define ASM_OUTPUT_FLOAT(STREAM, VALUE) \ - do \ - { \ - long value_long; \ - char dstr[30]; \ - REAL_VALUE_TO_TARGET_SINGLE (VALUE, value_long); \ - REAL_VALUE_TO_DECIMAL (VALUE, "%.12g", dstr); \ - if (sizeof (int) == sizeof (long)) \ - fprintf (STREAM, "\t.long\t0x%08x\t\t# %s (float)\n", \ - value_long, dstr); \ - else \ - fprintf (STREAM, "\t.long\t0x%08lx\t\t# %s (float)\n", \ - value_long, dstr); \ - } \ - while (0) - - /* This is how to output an assembler line for a `long double' constant. */ - #undef ASM_OUTPUT_LONG_DOUBLE - #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE) \ - do { long l[3]; \ - char dstr[30]; \ - REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l); \ - REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr); \ - if (sizeof (int) == sizeof (long)) \ - fprintf (FILE, \ - "\t.long\t0x%08x\t\t# %s\n\t.long\t0x%08x\n\t.long\t0x%08x\n", \ - l[0], dstr, l[1], l[2]); \ - else \ - fprintf (FILE, \ - "\t.long\t0x%08lx\t\t# %s\n\t.long\t0x%08lx\n\t.long\t0x%08lx\n", \ - l[0], dstr, l[1], l[2]); \ - } while (0) /* Generate calls to memcpy, etc., not bcopy, etc. */ --- 879,882 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/sco4.h gcc-2.6.1/config/i386/sco4.h *** gcc-2.6.0/config/i386/sco4.h Wed Jun 1 18:59:59 1994 --- gcc-2.6.1/config/i386/sco4.h Sat Oct 1 20:41:10 1994 *************** *** 62,71 **** #undef CPP_PREDEFINES ! #define CPP_PREDEFINES "-Di386 -Dunix -Asystem(unix) -Asystem(svr3) -Acpu(i386) -Amachine(i386)" #undef CPP_SPEC #define CPP_SPEC \ ! "-D_M_I386 -D_M_I86 -D_M_I86SM -D_M_SDATA -D_M_STEXT \ ! -D_M_UNIX -D_M_XENIX \ -D_M_SYS5 -D_M_SYSV -D_M_SYS3 -D_M_SYSIII \ -D_M_COFF -D_M_BITFIELDS -D_M_WORDSWAP \ --- 62,72 ---- #undef CPP_PREDEFINES ! #define CPP_PREDEFINES \ ! "-Asystem(unix) -Asystem(svr3) -Acpu(i386) -Amachine(i386)" #undef CPP_SPEC #define CPP_SPEC \ ! "-D_i386 -D_M_I386 -D_M_I86 -D_M_I86SM -D_M_SDATA -D_M_STEXT \ ! -D_unix -D_M_UNIX -D_M_XENIX \ -D_M_SYS5 -D_M_SYSV -D_M_SYS3 -D_M_SYSIII \ -D_M_COFF -D_M_BITFIELDS -D_M_WORDSWAP \ *************** *** 74,79 **** %{!scoxpg3:%{!posix:\ %{ansi:-D_STRICT_NAMES}%{!ansi:\ ! -DM_I386 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \ ! -DM_UNIX -DM_XENIX \ -DM_SYS5 -DM_SYSV -DM_SYS3 -DM_SYSIII \ -DM_COFF -DM_BITFIELDS -DM_WORDSWAP \ --- 75,80 ---- %{!scoxpg3:%{!posix:\ %{ansi:-D_STRICT_NAMES}%{!ansi:\ ! -Di386 -DM_I386 -DM_I86 -DM_I86SM -DM_SDATA -DM_STEXT \ ! -Dunix -DM_UNIX -DM_XENIX \ -DM_SYS5 -DM_SYSV -DM_SYS3 -DM_SYSIII \ -DM_COFF -DM_BITFIELDS -DM_WORDSWAP \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/seq-sysv3.h gcc-2.6.1/config/i386/seq-sysv3.h *** gcc-2.6.0/config/i386/seq-sysv3.h Sat May 7 12:09:04 1994 --- gcc-2.6.1/config/i386/seq-sysv3.h Sat Sep 10 06:37:48 1994 *************** *** 1,2 **** --- 1,4 ---- + /* Sequent DYNIX/ptx 1.x (SVr3) */ + #include "i386/sysv3.h" *************** *** 24,31 **** from the .init section */ #define INVOKE__main - - /* Use atexit for static destructors, instead of defining - our own exit function. */ - #define HAVE_ATEXIT /* Assembler pseudo-op for initialized shared variables (.shdata). */ --- 26,29 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/seq2-sysv3.h gcc-2.6.1/config/i386/seq2-sysv3.h *** gcc-2.6.0/config/i386/seq2-sysv3.h --- gcc-2.6.1/config/i386/seq2-sysv3.h Sat Sep 10 06:38:18 1994 *************** *** 0 **** --- 1,8 ---- + /* Sequent DYNIX/ptx 2.x (SVr3) */ + + #include "i386/seq-sysv3.h" + + /* Use atexit for static destructors, instead of defining + our own exit function. */ + #define HAVE_ATEXIT + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/sysv4gdb.h gcc-2.6.1/config/i386/sysv4gdb.h *** gcc-2.6.0/config/i386/sysv4gdb.h --- gcc-2.6.1/config/i386/sysv4gdb.h Mon Sep 5 12:27:05 1994 *************** *** 0 **** --- 1,7 ---- + /* Target definitions for GNU compiler for Intel 80386 running System V.4 + with gas and gdb. */ + + /* Use stabs instead of DWARF debug format. */ + #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG + + #include "i386/sysv4.h" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/unix.h gcc-2.6.1/config/i386/unix.h *** gcc-2.6.0/config/i386/unix.h Sun Dec 27 21:29:39 1992 --- gcc-2.6.1/config/i386/unix.h Fri Sep 30 17:31:32 1994 *************** *** 1,4 **** /* Definitions for Unix assembler syntax for the Intel 80386. ! Copyright (C) 1988 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Definitions for Unix assembler syntax for the Intel 80386. ! Copyright (C) 1988, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 29,34 **** in some of the places where they should. */ ! #ifdef __STDC__ #define AS2(a,b,c) #a " " #b "," #c #define AS3(a,b,c,d) #a " " #b "," #c "," #d #define AS1(a,b) #a " " #b --- 29,35 ---- in some of the places where they should. */ ! #if defined(__STDC__) || defined(ALMOST_STDC) #define AS2(a,b,c) #a " " #b "," #c + #define AS2C(b,c) " " #b "," #c #define AS3(a,b,c,d) #a " " #b "," #c "," #d #define AS1(a,b) #a " " #b *************** *** 36,39 **** --- 37,41 ---- #define AS1(a,b) "a b" #define AS2(a,b,c) "a b,c" + #define AS2C(b,c) " b,c" #define AS3(a,b,c,d) "a b,c,d" #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/winnt.h gcc-2.6.1/config/i386/winnt.h *** gcc-2.6.0/config/i386/winnt.h --- gcc-2.6.1/config/i386/winnt.h Fri Sep 30 17:20:32 1994 *************** *** 0 **** --- 1,79 ---- + /* Definitions of target machine for GNU compiler + for an Intel i386 or later processor running Windows NT 3.x. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Douglas B. Rupp (drupp@cs.washington.edu) + + 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. */ + + #define YES_UNDERSCORES + + #include "i386/gas.h" + #include "winnt/winnt.h" + + #undef CPP_PREDEFINES + #define CPP_PREDEFINES "-Dunix -Di386 -DWINNT -D_M_IX86 -D_X86_ -D__STDC__=0 \ + -DALMOST_STDC -Asystem(unix) -Asystem(winnt) -Acpu(i386) -Amachine(i386)" + + #undef EXTRA_SECTIONS + #define EXTRA_SECTIONS in_ctor, in_dtor + + #undef EXTRA_SECTION_FUNCTIONS + #define EXTRA_SECTION_FUNCTIONS \ + CTOR_SECTION_FUNCTION \ + DTOR_SECTION_FUNCTION + + #undef CTOR_SECTION_FUNCTION + #define CTOR_SECTION_FUNCTION \ + void \ + ctor_section () \ + { \ + if (in_section != in_ctor) \ + { \ + fprintf (asm_out_file, "\t.section .ctor\n"); \ + in_section = in_ctor; \ + } \ + } + + #undef DTOR_SECTION_FUNCTION + #define DTOR_SECTION_FUNCTION \ + void \ + dtor_section () \ + { \ + if (in_section != in_dtor) \ + { \ + fprintf (asm_out_file, "\t.section .dtor\n"); \ + in_section = in_dtor; \ + } \ + } + + #undef ASM_OUTPUT_CONSTRUCTOR + #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ + do { \ + ctor_section (); \ + fprintf (FILE, "%s\t", ASM_LONG); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + } while (0) + + #undef ASM_OUTPUT_DESTRUCTOR + #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ + do { \ + dtor_section (); \ + fprintf (FILE, "%s\t", ASM_LONG); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/x-freebsd gcc-2.6.1/config/i386/x-freebsd *** gcc-2.6.0/config/i386/x-freebsd Thu Jul 14 12:56:43 1994 --- gcc-2.6.1/config/i386/x-freebsd Mon Oct 31 07:52:41 1994 *************** *** 1,2 **** --- 1,3 ---- # Don't run fixproto STMP_FIXPROTO = + CLIB=-lgnumalloc diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/x-sco gcc-2.6.1/config/i386/x-sco *** gcc-2.6.0/config/i386/x-sco Sun Dec 27 21:29:50 1992 --- gcc-2.6.1/config/i386/x-sco Sat Oct 1 20:41:12 1994 *************** *** 5,7 **** RCCFLAGS = -Dunix -Di386 -DM_UNIX -DM_I386 -DNULL=0 CCLIBFLAGS = ! CLIB = -lPW --- 5,8 ---- RCCFLAGS = -Dunix -Di386 -DM_UNIX -DM_I386 -DNULL=0 CCLIBFLAGS = ! CLIB = -lmalloc ! ALLOCA = -lPW diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/x-sco4 gcc-2.6.1/config/i386/x-sco4 *** gcc-2.6.0/config/i386/x-sco4 Wed May 18 19:06:23 1994 --- gcc-2.6.1/config/i386/x-sco4 Sat Oct 1 20:41:15 1994 *************** *** 1,9 **** RANLIB = : RANLIB_TEST = false ! CLIB = -lPW ! CC = cc -nointl ! ! # Seems to be needed with SCO DEV3.2v4. ! X_CFLAGS = -D__STDC__=0 # See all the declarations. --- 1,10 ---- RANLIB = : RANLIB_TEST = false ! CC = rcc $(RCCFLAGS) ! OLDCC = rcc $(RCCFLAGS) ! RCCFLAGS = -Dunix -Di386 -DM_UNIX -DM_I386 -DNULL=0 ! CCLIBFLAGS = ! CLIB = -lmalloc ! ALLOCA = -lPW # See all the declarations. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/x-winnt gcc-2.6.1/config/i386/x-winnt *** gcc-2.6.0/config/i386/x-winnt --- gcc-2.6.1/config/i386/x-winnt Thu Oct 27 13:09:17 1994 *************** *** 0 **** --- 1,15 ---- + RANLIB = : + RANLIB_TEST = false + CLIB = libc.lib kernel32.lib + CC = cl -D_SYSV -DWINNT -D_M_IX86 -D_X86_ -D__STDC__=0 -DALMOST_STDC + LDFLAGS = -align:0x1000 -subsystem:console -entry:mainCRTStartup \ + -stack:1000000,1000000 + + EXTRA_PROGRAMS="ld" + + ld.o: $(srcdir)/config/winnt/ld.c + $(CC) -I. -I$(srcdir) -I$(srcdir)/config -c $(srcdir)/config/winnt/ld.c + + ld-winnt: ld.o + $(CC) -o ld-winnt ld.o + copy ld-winnt.exe ld.exe diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/xm-gnu.h gcc-2.6.1/config/i386/xm-gnu.h *** gcc-2.6.0/config/i386/xm-gnu.h --- gcc-2.6.1/config/i386/xm-gnu.h Wed Oct 5 01:26:36 1994 *************** *** 0 **** --- 1,4 ---- + /* Configuration for GCC for Intel i386 running GNU as host. */ + + #include "i386/xm-i386.h" + #include "xm-gnu.h" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i386/xm-winnt.h gcc-2.6.1/config/i386/xm-winnt.h *** gcc-2.6.0/config/i386/xm-winnt.h --- gcc-2.6.1/config/i386/xm-winnt.h Fri Sep 30 17:20:33 1994 *************** *** 0 **** --- 1,23 ---- + /* Configuration for GNU compiler + for an Intel i386 or later processor running Windows NT 3.x. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Douglas B. Rupp (drupp@cs.washington.edu) + + 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 "winnt/xm-winnt.h" + #include "i386/xm-i386.h" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i960/i960-coff.h gcc-2.6.1/config/i960/i960-coff.h *** gcc-2.6.0/config/i960/i960-coff.h --- gcc-2.6.1/config/i960/i960-coff.h Thu Sep 29 20:10:07 1994 *************** *** 0 **** --- 1,32 ---- + /* Definitions of target machine for GNU compiler, for "naked" Intel + 80960 using coff object format and coff debugging symbols. + Copyright (C) 1988, 1989, 1991 Intel Corp. + Contributed by Steven McGeady (mcg@omepd.intel.com) + Additional work by Glenn Colon-Bonet, Jonathan Shapiro, Andy Wilson + Converted to GCC 2.0 by Michael Tiemann, Cygnus Support. + */ + + /* + 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 "i960/i960.h" + + /* Generate SDB_DEBUGGING_INFO by default. */ + #undef PREFERRED_DEBUGGING_TYPE + #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG + + /* end of i960-coff.h */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i960/i960.c gcc-2.6.1/config/i960/i960.c *** gcc-2.6.0/config/i960/i960.c Wed Apr 20 11:49:23 1994 --- gcc-2.6.1/config/i960/i960.c Thu Oct 20 16:09:33 1994 *************** *** 76,79 **** --- 76,87 ---- static int ret_label = 0; + /* This is true if FNDECL is either a varargs or a stdarg function. + This is used to help identify functions that use an argument block. */ + + #define VARARGS_STDARG_FUNCTION(FNDECL) \ + ((TYPE_ARG_TYPES (TREE_TYPE (FNDECL)) != 0 \ + && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (FNDECL)))) != void_type_node)) \ + || current_function_varargs) + #if 0 /* Handle pragmas for compatibility with Intel's compilers. */ *************** *** 824,828 **** argblock, because argblock uses g14 implicitly. */ ! if (current_function_args_size != 0) { tail_call_ok = 0; --- 832,836 ---- argblock, because argblock uses g14 implicitly. */ ! if (current_function_args_size != 0 || VARARGS_STDARG_FUNCTION (fndecl)) { tail_call_ok = 0; *************** *** 961,966 **** { int actual_fsize; ! int outgoing_args_size ! = current_function_outgoing_args_size + current_function_pretend_args_size; /* The STARTING_FRAME_OFFSET is totally hidden to us as far --- 969,973 ---- { int actual_fsize; ! int outgoing_args_size = current_function_outgoing_args_size; /* The STARTING_FRAME_OFFSET is totally hidden to us as far *************** *** 1159,1162 **** --- 1166,1171 ---- int last_parm_reg; int i, j, increment; + int varargs_stdarg_function + = VARARGS_STDARG_FUNCTION (current_function_decl); /* Figure out the last used parameter register. The proper thing to do *************** *** 1195,1199 **** set it to zero. */ ! if (current_function_args_size != 0) fprintf (file, "\tmov g14,r3\n\tmov 0,g14\n"); --- 1204,1208 ---- set it to zero. */ ! if (current_function_args_size != 0 || varargs_stdarg_function) fprintf (file, "\tmov g14,r3\n\tmov 0,g14\n"); *************** *** 1204,1208 **** /* If this function uses the arg pointer, restore it. */ ! if (current_function_args_size != 0) fprintf (file, "\tmov r3,g14\n"); --- 1213,1217 ---- /* If this function uses the arg pointer, restore it. */ ! if (current_function_args_size != 0 || varargs_stdarg_function) fprintf (file, "\tmov r3,g14\n"); *************** *** 1281,1285 **** /* Must clear g14 on return. */ ! if (current_function_args_size != 0) fprintf (file, "\tmov 0,g14\n"); --- 1290,1295 ---- /* Must clear g14 on return. */ ! if (current_function_args_size != 0 ! || VARARGS_STDARG_FUNCTION (current_function_decl)) fprintf (file, "\tmov 0,g14\n"); *************** *** 1297,1300 **** --- 1307,1312 ---- rtx nexti = next_real_insn (insn); rtx operands[2]; + int varargs_stdarg_function + = VARARGS_STDARG_FUNCTION (current_function_decl); operands[0] = target; *************** *** 1301,1305 **** operands[1] = arg_pointer; ! if (current_function_args_size != 0) output_asm_insn ("mov g14,r3", operands); --- 1313,1317 ---- operands[1] = arg_pointer; ! if (current_function_args_size != 0 || varargs_stdarg_function) output_asm_insn ("mov g14,r3", operands); *************** *** 1306,1310 **** if (argsize > 48) output_asm_insn ("lda %a1,g14", operands); ! else if (current_function_args_size != 0) output_asm_insn ("mov 0,g14", operands); --- 1318,1322 ---- if (argsize > 48) output_asm_insn ("lda %a1,g14", operands); ! else if (current_function_args_size != 0 || varargs_stdarg_function) output_asm_insn ("mov 0,g14", operands); *************** *** 1327,1331 **** output_asm_insn ("callx %0", operands); ! if (current_function_args_size != 0) output_asm_insn ("mov r3,g14", operands); --- 1339,1343 ---- output_asm_insn ("callx %0", operands); ! if (current_function_args_size != 0 || varargs_stdarg_function) output_asm_insn ("mov r3,g14", operands); *************** *** 1350,1354 **** } ! if (current_function_args_size != 0) output_asm_insn ("mov 0,g14", 0); --- 1362,1367 ---- } ! if (current_function_args_size != 0 ! || VARARGS_STDARG_FUNCTION (current_function_decl)) output_asm_insn ("mov 0,g14", 0); *************** *** 2046,2050 **** i960_arg_size_and_align (mode, type, &size, &align); ! if (named == 0 || size > 4 || cum->ca_nstackparms != 0 || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS || MUST_PASS_IN_STACK (mode, type)) --- 2059,2063 ---- i960_arg_size_and_align (mode, type, &size, &align); ! if (size > 4 || cum->ca_nstackparms != 0 || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS || MUST_PASS_IN_STACK (mode, type)) *************** *** 2069,2073 **** i960_arg_size_and_align (mode, type, &size, &align); ! if (named == 0 || size > 4 || cum->ca_nstackparms != 0 || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS || MUST_PASS_IN_STACK (mode, type)) --- 2082,2086 ---- i960_arg_size_and_align (mode, type, &size, &align); ! if (size > 4 || cum->ca_nstackparms != 0 || (size + ROUND_PARM (cum->ca_nregparms, align)) > NPARM_REGS || MUST_PASS_IN_STACK (mode, type)) *************** *** 2185,2194 **** int first_reg_offset = cum->ca_nregparms; ! if (first_reg_offset > NPARM_REGS) ! first_reg_offset = NPARM_REGS; ! ! if (! (no_rtl) && first_reg_offset != NPARM_REGS) { rtx label = gen_label_rtx (); emit_insn (gen_cmpsi (arg_pointer_rtx, const0_rtx)); emit_jump_insn (gen_bne (label)); --- 2198,2212 ---- int first_reg_offset = cum->ca_nregparms; ! if (! (no_rtl)) { rtx label = gen_label_rtx (); + rtx regblock; + + /* If arg_pointer_rtx == 0, no arguments were passed on the stack + and we need to allocate a chunk to save the registers (if any + arguments were passed on the stack the caller would allocate the + 48 bytes as well). We must allocate all 48 bytes (12*4) because + arg_pointer_rtx is saved at the front, the anonymous args are + saved at the end. */ emit_insn (gen_cmpsi (arg_pointer_rtx, const0_rtx)); emit_jump_insn (gen_bne (label)); *************** *** 2200,2210 **** 48)))); emit_label (label); ! move_block_from_reg ! (first_reg_offset, ! gen_rtx (MEM, BLKmode, virtual_incoming_args_rtx), ! NPARM_REGS - first_reg_offset, ! (NPARM_REGS - first_reg_offset) * UNITS_PER_WORD); } - *pretend_size = (NPARM_REGS - first_reg_offset) * UNITS_PER_WORD; } } --- 2218,2235 ---- 48)))); emit_label (label); ! ! /* Any anonymous args passed in regs? */ ! if (first_reg_offset + 1 < NPARM_REGS) ! { ! rtx regblock; ! regblock = gen_rtx (MEM, BLKmode, ! plus_constant (arg_pointer_rtx, ! (first_reg_offset + 1) * 4)); ! move_block_from_reg (first_reg_offset + 1, regblock, ! NPARM_REGS - first_reg_offset - 1, ! ((NPARM_REGS - first_reg_offset - 1) ! * UNITS_PER_WORD)); ! } } } } *************** *** 2243,2247 **** /* Otherwise, we have an arg block if the current function has more than 48 bytes of parameters. */ ! if (current_function_args_size != 0) return 48; else --- 2268,2272 ---- /* Otherwise, we have an arg block if the current function has more than 48 bytes of parameters. */ ! if (current_function_args_size != 0 || VARARGS_STDARG_FUNCTION (fndecl)) return 48; else diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i960/i960.h gcc-2.6.1/config/i960/i960.h *** gcc-2.6.0/config/i960/i960.h Tue May 31 19:53:35 1994 --- gcc-2.6.1/config/i960/i960.h Thu Oct 20 16:09:40 1994 *************** *** 46,52 **** /* -mic* options make characters signed by default. */ ! #define SIGNED_CHAR_SPEC \ ! (DEFAULT_SIGNED_CHAR ? "%{funsigned-char:-D__CHAR_UNSIGNED__}" \ ! : "%{!fsigned-char:%{!mic*:-D__CHAR_UNSIGNED__}}") /* Specs for the compiler, to handle processor variations. */ --- 46,56 ---- /* -mic* options make characters signed by default. */ ! /* Use #if rather than ?: because MIPS C compiler rejects ?: in ! initializers. */ ! #if DEFAULT_SIGNED_CHAR ! #define SIGNED_CHAR_SPEC "%{funsigned-char:-D__CHAR_UNSIGNED__}" ! #else ! #define SIGNED_CHAR_SPEC "%{!fsigned-char:%{!mic*:-D__CHAR_UNSIGNED__}}" ! #endif /* Specs for the compiler, to handle processor variations. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i960/i960.md gcc-2.6.1/config/i960/i960.md *** gcc-2.6.0/config/i960/i960.md Tue Jun 28 13:39:40 1994 --- gcc-2.6.1/config/i960/i960.md Thu Oct 13 17:13:30 1994 *************** *** 2161,2165 **** (define_expand "call" ! [(call (match_operand:SI 0 "general_operand" "g") (match_operand:SI 1 "immediate_operand" "i"))] "" --- 2161,2165 ---- (define_expand "call" ! [(call (match_operand:SI 0 "memory_operand" "m") (match_operand:SI 1 "immediate_operand" "i"))] "" *************** *** 2180,2184 **** (define_insn "call_internal" ! [(call (match_operand:SI 0 "general_operand" "g") (match_operand:SI 1 "immediate_operand" "i")) (use (match_operand:SI 2 "address_operand" "p")) --- 2180,2184 ---- (define_insn "call_internal" ! [(call (match_operand:SI 0 "memory_operand" "m") (match_operand:SI 1 "immediate_operand" "i")) (use (match_operand:SI 2 "address_operand" "p")) *************** *** 2191,2195 **** (define_expand "call_value" [(set (match_operand 0 "register_operand" "=d") ! (call (match_operand:SI 1 "general_operand" "g") (match_operand:SI 2 "immediate_operand" "i")))] "" --- 2191,2195 ---- (define_expand "call_value" [(set (match_operand 0 "register_operand" "=d") ! (call (match_operand:SI 1 "memory_operand" "m") (match_operand:SI 2 "immediate_operand" "i")))] "" *************** *** 2206,2210 **** (define_insn "call_value_internal" [(set (match_operand 0 "register_operand" "=d") ! (call (match_operand:SI 1 "general_operand" "g") (match_operand:SI 2 "immediate_operand" "i"))) (use (match_operand:SI 3 "address_operand" "p")) --- 2206,2210 ---- (define_insn "call_value_internal" [(set (match_operand 0 "register_operand" "=d") ! (call (match_operand:SI 1 "memory_operand" "m") (match_operand:SI 2 "immediate_operand" "i"))) (use (match_operand:SI 3 "address_operand" "p")) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/i960/t-960bare gcc-2.6.1/config/i960/t-960bare *** gcc-2.6.0/config/i960/t-960bare --- gcc-2.6.1/config/i960/t-960bare Thu Sep 29 20:10:56 1994 *************** *** 0 **** --- 1,20 ---- + LIBGCC1 = libgcc1.null + CROSS_LIBGCC1 = libgcc1.null + + LIB2FUNCS_EXTRA = fp-bit.c dp-bit.c + + dp-bit.c: $(srcdir)/config/fp-bit.c + echo '#define FLOAT_BIT_ORDER_MISMATCH' > dp-bit.c + cat $(srcdir)/config/fp-bit.c >> dp-bit.c + + fp-bit.c: $(srcdir)/config/fp-bit.c + echo '#define FLOAT' > fp-bit.c + echo '#define FLOAT_BIT_ORDER_MISMATCH' >> fp-bit.c + cat $(srcdir)/config/fp-bit.c >> fp-bit.c + + MULTILIB_OPTIONS=mnumerics + MULTILIB_DIRNAMES=float + MULTILIB_MATCHES=mnumerics=msb mnumerics=msc mnumerics=mkb mnumerics=mkc mnumerics=mmc mnumerics=mcb mnumerics=mcc + + LIBGCC = stmp-multilib + INSTALL_LIBGCC = install-multilib diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/lynx-ng.h gcc-2.6.1/config/lynx-ng.h *** gcc-2.6.0/config/lynx-ng.h Mon Jul 11 16:26:43 1994 --- gcc-2.6.1/config/lynx-ng.h Tue Oct 4 15:56:23 1994 *************** *** 55,58 **** --- 55,59 ---- #define DBX_DEBUGGING_INFO + #undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/lynx.h gcc-2.6.1/config/lynx.h *** gcc-2.6.0/config/lynx.h Mon Jul 11 17:07:08 1994 --- gcc-2.6.1/config/lynx.h Tue Oct 4 15:56:26 1994 *************** *** 1,4 **** /* Target independent definitions for LynxOS. ! Copyright (C) 1993 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Target independent definitions for LynxOS. ! Copyright (C) 1993, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 58,61 **** --- 58,62 ---- #define DBX_DEBUGGING_INFO + #undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG *************** *** 84,91 **** #define ASM_OUTPUT_SOURCE_LINE(file, line) \ { static int sym_lineno = 1; \ ! fprintf (file, ".stabn 68,0,%d,.LM%d-%s\n.LM%d:\n", \ ! line, sym_lineno, \ ! XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0), \ ! sym_lineno); \ sym_lineno += 1; } --- 85,93 ---- #define ASM_OUTPUT_SOURCE_LINE(file, line) \ { static int sym_lineno = 1; \ ! fprintf (file, ".stabn 68,0,%d,.LM%d-", \ ! line, sym_lineno); \ ! assemble_name (file, \ ! XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); \ ! fprintf (file, "\n.LM%d:\n", sym_lineno); \ sym_lineno += 1; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/atari.h gcc-2.6.1/config/m68k/atari.h *** gcc-2.6.0/config/m68k/atari.h Tue Jun 28 13:28:45 1994 --- gcc-2.6.1/config/m68k/atari.h Wed Sep 21 05:51:09 1994 *************** *** 21,24 **** --- 21,29 ---- #include "m68k/m68kv4.h" + /* Dollars and dots in labels are not allowed. */ + + #define NO_DOLLAR_IN_LABEL + #define NO_DOT_IN_LABEL + /* Alter assembler syntax for fsgldiv and fsglmul. It is highly likely that this is a generic SGS m68k assembler dependency. *************** *** 99,100 **** --- 104,118 ---- else \ asm_fprintf (FILE, "%0L%s%d:\n", PREFIX, NUM) + + /* Define how to generate (in the callee) the output value of a function + and how to find (in the caller) the value returned by a function. VALTYPE + is the data type of the value (as a tree). If the precise function being + called is known, FUNC is its FUNCTION_DECL; otherwise, FUNC is 0. + For the Atari generate the result in d0 or fp0 as appropriate. */ + + #undef FUNCTION_VALUE + #define FUNCTION_VALUE(VALTYPE, FUNC) \ + (TREE_CODE (VALTYPE) == REAL_TYPE && TARGET_68881 \ + ? gen_rtx (REG, TYPE_MODE (VALTYPE), 16) \ + : gen_rtx (REG, TYPE_MODE (VALTYPE), 0)) + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/crds.h gcc-2.6.1/config/m68k/crds.h *** gcc-2.6.0/config/m68k/crds.h Sat Dec 25 13:03:58 1993 --- gcc-2.6.1/config/m68k/crds.h Sat Jul 30 15:01:49 1994 *************** *** 1,6 **** ! /* Definitions of target machine for GNU compiler. ! Charles River Data Systems UNiverse/32 ! Written by Gary E. Miller (Gary_Edmunds_Miller@cup.portal.com) ! Copyright (C) 1987, 1993 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,6 ---- ! /* Definitions of target machine for GNU compiler; ! Charles River Data Systems UNiverse/32. ! Copyright (C) 1987, 1993, 1994 Free Software Foundation, Inc. ! Contributed by Gary E. Miller (Gary_Edmunds_Miller@cup.portal.com) This file is part of GNU CC. *************** *** 307,318 **** { REAL_VALUE_TO_TARGET_SINGLE (r, l); \ fprintf (FILE, "$0x%x", l); } } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == XFmode) \ { REAL_VALUE_TYPE r; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ! ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ { REAL_VALUE_TYPE r; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ! ASM_OUTPUT_DOUBLE_OPERAND (FILE, r); } \ else { putc ('$', FILE); output_addr_const (FILE, X); }} --- 307,318 ---- { REAL_VALUE_TO_TARGET_SINGLE (r, l); \ fprintf (FILE, "$0x%x", l); } } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode) \ { REAL_VALUE_TYPE r; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ! ASM_OUTPUT_DOUBLE_OPERAND (FILE, r); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == XFmode) \ { REAL_VALUE_TYPE r; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ! ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); } \ else { putc ('$', FILE); output_addr_const (FILE, X); }} diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/hp320.h gcc-2.6.1/config/m68k/hp320.h *** gcc-2.6.0/config/m68k/hp320.h Wed Jun 22 18:48:38 1994 --- gcc-2.6.1/config/m68k/hp320.h Thu Aug 11 13:28:59 1994 *************** *** 75,78 **** --- 75,80 ---- #define ASM_SPEC "%{m68000:+X}%{mc68000:+X}" + #define NO_DOT_IN_LABEL + #if TARGET_DEFAULT & 02 /* -m68881 is the default */ *************** *** 320,324 **** #define DATA_SECTION_ASM_OP "data" #endif - #define READONLY_DATA_SECTION data_section #define ASCII_DATA_ASM_OP "byte" --- 322,325 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/lynx.h gcc-2.6.1/config/m68k/lynx.h *** gcc-2.6.0/config/m68k/lynx.h Mon Jul 11 16:48:06 1994 --- gcc-2.6.1/config/m68k/lynx.h Thu Aug 25 18:30:59 1994 *************** *** 1,4 **** /* Definitions for Motorola 680x0 running LynxOS. ! Copyright (C) 1993 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Definitions for Motorola 680x0 running LynxOS. ! Copyright (C) 1993, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 46,47 **** --- 46,54 ---- #define STRUCTURE_SIZE_BOUNDARY 16 + + /* Lynx uses d2 and d3 as scratch registers. */ + #undef CALL_USED_REGISTERS + #define CALL_USED_REGISTERS \ + {1, 1, 1, 1, 0, 0, 0, 0, \ + 1, 1, 0, 0, 0, 0, 0, 1, \ + 1, 1, 0, 0, 0, 0, 0, 0 } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/m68k-coff.h gcc-2.6.1/config/m68k/m68k-coff.h *** gcc-2.6.0/config/m68k/m68k-coff.h --- gcc-2.6.1/config/m68k/m68k-coff.h Mon Aug 15 16:34:52 1994 *************** *** 0 **** --- 1,150 ---- + /* Definitions of target machine for GNU compiler. + m68k series COFF object files and debugging, version. + Copyright (C) 1987, 1988, 1991, 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. */ + + /* This file is included after m68k.h by CPU COFF specific files. It + is not a complete target itself. */ + + /* Generate sdb debugging information. */ + + #undef DBX_DEBUGGING_INFO + #define SDB_DEBUGGING_INFO + + /* Output DBX (stabs) debugging information if using -gstabs. */ + + #define DBX_DEBUGGING_INFO + + #undef PREFERRED_DEBUGGING_TYPE + #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG + + /* COFF symbols don't start with an underscore. */ + + #undef USER_LABEL_PREFIX + #define USER_LABEL_PREFIX "" + + /* Use a prefix for local labels, just to be on the save side. */ + + #undef LOCAL_LABEL_PREFIX + #define LOCAL_LABEL_PREFIX "." + + /* Use a register prefix to avoid clashes with external symbols (classic + example: `extern char PC;' in termcap). */ + + #undef REGISTER_PREFIX + #define REGISTER_PREFIX "%" + + /* In the machine description we can't use %R, because it will not be seen + by ASM_FPRINTF. (Isn't that a design bug?). */ + + #undef REGISTER_PREFIX_MD + #define REGISTER_PREFIX_MD "%%" + + /* config/m68k.md has an explicit reference to the program counter, + prefix this by the register prefix. */ + + #define ASM_RETURN_CASE_JUMP return "jmp %%pc@(2,%0:w)" + + /* Here are the new register names. */ + + #undef REGISTER_NAMES + #ifndef SUPPORT_SUN_FPA + #define REGISTER_NAMES \ + {"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", \ + "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%sp", \ + "%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7" } + #else /* SUPPORTED_SUN_FPA */ + #define REGISTER_NAMES \ + {"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", \ + "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%sp", \ + "%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7", \ + "%fpa0", "%fpa1", "%fpa2", "%fpa3", "%fpa4", "%fpa5", "%fpa6", "%fpa7", \ + "%fpa8", "%fpa9", "%fpa10", "%fpa11", "%fpa12", "%fpa13", "%fpa14", "%fpa15", \ + "%fpa16", "%fpa17", "%fpa18", "%fpa19", "%fpa20", "%fpa21", "%fpa22", "%fpa23", \ + "%fpa24", "%fpa25", "%fpa26", "%fpa27", "%fpa28", "%fpa29", "%fpa30", "%fpa31" } + #endif /* defined SUPPORT_SUN_FPA */ + + #undef ASM_FILE_START + #define ASM_FILE_START(FILE) \ + output_file_directive ((FILE), main_input_filename) + + /* Support the ctors and dtors sections for g++. */ + + #define CTORS_SECTION_ASM_OP ".section\t.ctors,\"x\"" + #define DTORS_SECTION_ASM_OP ".section\t.dtors,\"x\"" + + /* A list of other sections which the compiler might be "in" at any + given time. */ + + #undef EXTRA_SECTIONS + #define EXTRA_SECTIONS in_ctors, in_dtors + + /* A list of extra section function definitions. */ + + #undef EXTRA_SECTION_FUNCTIONS + #define EXTRA_SECTION_FUNCTIONS \ + CTORS_SECTION_FUNCTION \ + DTORS_SECTION_FUNCTION + + #define CTORS_SECTION_FUNCTION \ + void \ + ctors_section () \ + { \ + if (in_section != in_ctors) \ + { \ + fprintf (asm_out_file, "%s\n", CTORS_SECTION_ASM_OP); \ + in_section = in_ctors; \ + } \ + } + + #define DTORS_SECTION_FUNCTION \ + void \ + dtors_section () \ + { \ + if (in_section != in_dtors) \ + { \ + fprintf (asm_out_file, "%s\n", DTORS_SECTION_ASM_OP); \ + in_section = in_dtors; \ + } \ + } + + #define INT_ASM_OP ".long" + + /* A C statement (sans semicolon) to output an element in the table of + global constructors. */ + #define ASM_OUTPUT_CONSTRUCTOR(FILE,NAME) \ + do { \ + ctors_section (); \ + fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + } while (0) + + /* A C statement (sans semicolon) to output an element in the table of + global destructors. */ + #define ASM_OUTPUT_DESTRUCTOR(FILE,NAME) \ + do { \ + dtors_section (); \ + fprintf (FILE, "\t%s\t ", INT_ASM_OP); \ + assemble_name (FILE, NAME); \ + fprintf (FILE, "\n"); \ + } while (0) + + /* Don't assume anything about startfiles. */ + + #define STARTFILE_SPEC "" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/m68k.md gcc-2.6.1/config/m68k/m68k.md *** gcc-2.6.0/config/m68k/m68k.md Thu Jun 30 18:14:18 1994 --- gcc-2.6.1/config/m68k/m68k.md Thu Sep 8 02:35:41 1994 *************** *** 3799,3802 **** --- 3799,3803 ---- (match_operand:SI 3 "const_int_operand" "n")))] "TARGET_68020 && TARGET_BITFIELD + && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16) && INTVAL (operands[3]) % INTVAL (operands[2]) == 0 && (GET_CODE (operands[1]) == REG *************** *** 3852,3855 **** --- 3853,3857 ---- (match_operand:SI 3 "const_int_operand" "n")))] "TARGET_68020 && TARGET_BITFIELD + && (INTVAL (operands[2]) == 8 || INTVAL (operands[2]) == 16) && INTVAL (operands[3]) % INTVAL (operands[2]) == 0 && (GET_CODE (operands[1]) == REG *************** *** 4491,4495 **** { #ifdef CASE_VECTOR_PC_RELATIVE ! operands[0] = gen_rtx (PLUS, SImode, pc_rtx, operands[0]); #endif }") --- 4493,4498 ---- { #ifdef CASE_VECTOR_PC_RELATIVE ! operands[0] = gen_rtx (PLUS, SImode, pc_rtx, ! gen_rtx (SIGN_EXTEND, SImode, operands[0])); #endif }") *************** *** 4511,4515 **** (define_insn "" [(set (pc) ! (plus:SI (pc) (match_operand:HI 0 "register_operand" "r"))) (use (label_ref (match_operand 1 "" "")))] "" --- 4514,4519 ---- (define_insn "" [(set (pc) ! (plus:SI (pc) ! (sign_extend:SI (match_operand:HI 0 "register_operand" "r")))) (use (label_ref (match_operand 1 "" "")))] "" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/news.h gcc-2.6.1/config/m68k/news.h *** gcc-2.6.0/config/m68k/news.h Sun Mar 20 19:38:09 1994 --- gcc-2.6.1/config/m68k/news.h Sat Jul 30 14:12:29 1994 *************** *** 339,343 **** REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ { REAL_VALUE_TYPE r; char dstr[30]; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ --- 339,343 ---- REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode) \ { REAL_VALUE_TYPE r; char dstr[30]; \ REAL_VALUE_FROM_CONST_DOUBLE (r, X); \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m68k/next.h gcc-2.6.1/config/m68k/next.h *** gcc-2.6.0/config/m68k/next.h Sat Mar 19 08:44:26 1994 --- gcc-2.6.1/config/m68k/next.h Thu Jul 28 16:10:29 1994 *************** *** 205,206 **** --- 205,208 ---- asm volatile ("trap #2") + /* GCC is the primary compiler for NeXTSTEP, so we don't need this. */ + #undef PCC_STATIC_STRUCT_RETURN diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m88k/dgux.h gcc-2.6.1/config/m88k/dgux.h *** gcc-2.6.0/config/m88k/dgux.h Wed Jul 13 11:48:41 1994 --- gcc-2.6.1/config/m88k/dgux.h Fri Aug 12 13:43:06 1994 *************** *** 32,36 **** #ifndef VERSION_INFO2 ! #define VERSION_INFO2 "$Revision: 1.14 $" #endif #ifndef NO_BUGS --- 32,36 ---- #ifndef VERSION_INFO2 ! #define VERSION_INFO2 "$Revision: 1.15 $" #endif #ifndef NO_BUGS *************** *** 86,90 **** #define CPP_SPEC "%{!m88000:%{!m88100:%{m88110:-D__m88110__}}} \ %{!m88000:%{!m88110:%{m88100:-D__m88100__}}} \ ! %{!ansi:%{!traditional:-D__OPEN_NAMESPACE__}}" /* Assembler support (-V, silicon filter, legends for mxdb). */ --- 86,91 ---- #define CPP_SPEC "%{!m88000:%{!m88100:%{m88110:-D__m88110__}}} \ %{!m88000:%{!m88110:%{m88100:-D__m88100__}}} \ ! %{!ansi:%{!traditional:-D__OPEN_NAMESPACE__}} \ ! %{msvr3:-D_M88KBCS_TARGET} %{!msvr3:-D_DGUX_TARGET}" /* Assembler support (-V, silicon filter, legends for mxdb). */ *************** *** 92,96 **** #define ASM_SPEC "\ %{V} %{v:%{!V:-V}} %{pipe:%{!.s: - }\ ! %{!msvr3:%{mversion-03.00:-KV3}%{!mversion-03.00:%{mversion-*:-KV%*}}}}\ %{!mlegend:%{mstandard:-Wc,off}}\ %{mlegend:-Wc,-fix-bb,-h\"gcc-" VERSION_INFO2 "\",-s\"%i\"\ --- 93,97 ---- #define ASM_SPEC "\ %{V} %{v:%{!V:-V}} %{pipe:%{!.s: - }\ ! %{!msvr3:%{!m88110:-KV3 }%{m88110:-KV04.00 }}}\ %{!mlegend:%{mstandard:-Wc,off}}\ %{mlegend:-Wc,-fix-bb,-h\"gcc-" VERSION_INFO2 "\",-s\"%i\"\ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m88k/dguxbcs.h gcc-2.6.1/config/m88k/dguxbcs.h *** gcc-2.6.0/config/m88k/dguxbcs.h Wed Jul 13 08:57:10 1994 --- gcc-2.6.1/config/m88k/dguxbcs.h Fri Aug 12 13:37:21 1994 *************** *** 40,44 **** #define ASM_SPEC "\ %{V} %{v:%{!V:-V}} %{pipe:%{!.s: - }\ ! %{msvr4:%{mversion-03.00:-KV3}%{!mversion-03.00:%{mversion-*:-KV%*}}}}\ %{!mlegend:%{mstandard:-Wc,off}}\ %{mlegend:-Wc,-fix-bb,-h\"gcc-" VERSION_INFO2 "\",-s\"%i\"\ --- 40,44 ---- #define ASM_SPEC "\ %{V} %{v:%{!V:-V}} %{pipe:%{!.s: - }\ ! %{msvr4:%{!m88110:-KV3 }%{m88110:-KV04.00 }}}\ %{!mlegend:%{mstandard:-Wc,off}}\ %{mlegend:-Wc,-fix-bb,-h\"gcc-" VERSION_INFO2 "\",-s\"%i\"\ *************** *** 48,51 **** --- 48,61 ---- %{mexternal-legend:,-external}\ %{mocs-frame-position:,-ocs}}" + + /* If -m88100 is in effect, add -Dm88100; similarly for -m88110. + Here, the CPU_DEFAULT is assumed to be -m88000. If not -ansi, + -traditional, or restricting include files to one specific source + target, specify full DG/UX features. */ + #undef CPP_SPEC + #define CPP_SPEC "%{!m88000:%{!m88100:%{m88110:-D__m88110__}}} \ + %{!m88000:%{!m88110:%{m88100:-D__m88100__}}} \ + %{!ansi:%{!traditional:-D__OPEN_NAMESPACE__}} \ + %{!msvr4:-D_M88KBCS_TARGET} %{msvr4:-D_DGUX_TARGET}" /* Linker and library spec's. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m88k/m88k.c gcc-2.6.1/config/m88k/m88k.c *** gcc-2.6.0/config/m88k/m88k.c Sun Apr 10 07:04:24 1994 --- gcc-2.6.1/config/m88k/m88k.c Thu Oct 6 10:59:47 1994 *************** *** 225,228 **** --- 225,232 ---- register rtx operand1 = operands[1]; + if (CONSTANT_P (operand1) && flag_pic + && pic_address_needs_scratch (operand1)) + operands[1] = operand1 = legitimize_address (1, operand1, 0, 0); + /* Handle most common case first: storing into a register. */ if (register_operand (operand0, mode)) *************** *** 1272,1276 **** return (register_operand (op, mode) || GET_CODE (op) == CONST_INT ! || (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == DImode)); } --- 1276,1280 ---- return (register_operand (op, mode) || GET_CODE (op) == CONST_INT ! || (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)); } *************** *** 2646,2660 **** { if (m88k_compare_op1 == const0_rtx) ! emit_jump_insn (optimize ! ? gen_bxx (emit_test (op, VOIDmode), label) ! : gen_bcnd (gen_rtx (op, VOIDmode, ! m88k_compare_op0, const0_rtx), ! label)); else if (m88k_compare_op0 == const0_rtx) ! emit_jump_insn (optimize ! ? gen_bxx (emit_test (op, VOIDmode), label) ! : gen_bcnd (gen_rtx (swap_condition (op), VOIDmode, ! m88k_compare_op1, const0_rtx), ! label)); else if (op != EQ && op != NE) emit_jump_insn (gen_bxx (emit_test (op, VOIDmode), label)); --- 2650,2662 ---- { if (m88k_compare_op1 == const0_rtx) ! emit_jump_insn( gen_bcnd ( ! gen_rtx (op, VOIDmode,m88k_compare_op0, const0_rtx), ! label)); else if (m88k_compare_op0 == const0_rtx) ! emit_jump_insn( gen_bcnd( ! gen_rtx( ! swap_condition (op), ! VOIDmode, m88k_compare_op1, const0_rtx), ! label)); else if (op != EQ && op != NE) emit_jump_insn (gen_bxx (emit_test (op, VOIDmode), label)); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/m88k/m88k.h gcc-2.6.1/config/m88k/m88k.h *** gcc-2.6.0/config/m88k/m88k.h Mon Jul 11 13:27:23 1994 --- gcc-2.6.1/config/m88k/m88k.h Tue Sep 27 19:02:50 1994 *************** *** 198,202 **** #define VERSION_INFO1 "88open OCS/BCS, " #ifndef VERSION_INFO2 ! #define VERSION_INFO2 "$Revision: 1.60 $" #endif --- 198,202 ---- #define VERSION_INFO1 "88open OCS/BCS, " #ifndef VERSION_INFO2 ! #define VERSION_INFO2 "$Revision: 1.61 $" #endif *************** *** 204,208 **** #define VERSION_STRING version_string #ifdef __STDC__ ! #define TM_RCS_ID "@(#)" __FILE__ " $Revision: 1.60 $ " __DATE__ #else #define TM_RCS_ID "$What$" --- 204,208 ---- #define VERSION_STRING version_string #ifdef __STDC__ ! #define TM_RCS_ID "@(#)" __FILE__ " $Revision: 1.61 $ " __DATE__ #else #define TM_RCS_ID "$What$" *************** *** 1850,1853 **** --- 1850,1854 ---- #ifdef SDB_DEBUGGING_INFO + #undef ASM_OUTPUT_SOURCE_LINE #define ASM_OUTPUT_SOURCE_LINE(FILE, LINE) \ if (m88k_prologue_done) \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/bsd-5.h gcc-2.6.1/config/mips/bsd-5.h *** gcc-2.6.0/config/mips/bsd-5.h Wed May 4 14:17:38 1994 --- gcc-2.6.1/config/mips/bsd-5.h Sun Aug 14 19:04:59 1994 *************** *** 47,54 **** #define MD_EXEC_PREFIX "/bsd43/usr/lib/cmplrs/cc/" - /* Some RISCOS assemblers misassemble \n in a .ascii, - so we use \X0A instead. */ - #define ASM_OUTPUT_NEWLINE(STREAM) \ - fputs ("\\X0A", (STREAM)); - #include "mips/mips.h" --- 47,65 ---- #define MD_EXEC_PREFIX "/bsd43/usr/lib/cmplrs/cc/" #include "mips/mips.h" + + /* Some assemblers have a bug that causes backslash escaped chars in .ascii + to be misassembled, so we just completely avoid it. */ + #undef ASM_OUTPUT_ASCII + #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ + do { \ + unsigned char *s; \ + int i; \ + for (i = 0, s = (unsigned char *)(PTR); i < (LEN); s++, i++) \ + { \ + if ((i % 8) == 0) \ + fputs ("\n\t.byte\t", (FILE)); \ + fprintf ((FILE), "%s0x%x", (i%8?",":""), (unsigned)*s); \ + } \ + fputs ("\n", (FILE)); \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/iris4.h gcc-2.6.1/config/mips/iris4.h *** gcc-2.6.0/config/mips/iris4.h Fri May 20 12:49:12 1994 --- gcc-2.6.1/config/mips/iris4.h Sun Aug 14 19:05:01 1994 *************** *** 33,38 **** "%{!p:%{!pg:%{!static:%{!g*:-lc_s}}}}%{p:libprof1.a%s}%{pg:libprof1.a%s} -lc crtn.o%s" ! /* Assembler is said to have trouble with .ascii with escape chars. ! The quickest way to avoid the problem is not to use .ascii. */ #undef ASM_OUTPUT_ASCII #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ --- 33,38 ---- "%{!p:%{!pg:%{!static:%{!g*:-lc_s}}}}%{p:libprof1.a%s}%{pg:libprof1.a%s} -lc crtn.o%s" ! /* Some assemblers have a bug that causes backslash escaped chars in .ascii ! to be misassembled, so we just completely avoid it. */ #undef ASM_OUTPUT_ASCII #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/iris5.h gcc-2.6.1/config/mips/iris5.h *** gcc-2.6.0/config/mips/iris5.h Wed May 4 14:17:54 1994 --- gcc-2.6.1/config/mips/iris5.h Tue Sep 20 16:06:17 1994 *************** *** 91,94 **** --- 91,102 ---- #undef ASM_FINAL_SPEC + /* The system header files are C++ aware. */ + /* ??? Unfortunately, most but not all of the headers are C++ aware. + Specifically, curses.h is not, and libg++ won't build because of it + if this is defined. On the other hand, SGI has C++ packages with + header files in /usr/include, and they won't work unless this is + defined. We need some way to fix just those files that need fixing. */ + /* #define NO_IMPLICIT_EXTERN_C 1 */ + /* We don't support debugging info for now. */ #undef DBX_DEBUGGING_INFO *************** *** 103,104 **** --- 111,135 ---- #undef MIPS_DEFAULT_GVALUE #define MIPS_DEFAULT_GVALUE 0 + + /* In Irix 5, we must output a `.global name .text' directive for every used + but undefined function. If we don't, the linker may perform an optimization + (skipping over the insns that set $gp) when it is unsafe. This is used + indirectly by ASM_OUTPUT_EXTERNAL. */ + #define ASM_OUTPUT_UNDEF_FUNCTION(FILE, NAME) \ + do { \ + fputs ("\t.globl ", FILE); \ + assemble_name (FILE, NAME); \ + fputs (" .text\n", FILE); \ + } while (0) + + /* Also do this for libcalls. */ + #define ASM_OUTPUT_EXTERNAL_LIBCALL(FILE, FUN) \ + mips_output_external_libcall (FILE, XSTR (FUN, 0)) + + /* This does for functions what ASM_DECLARE_OBJECT_NAME does for variables. + This is used indirectly by ASM_OUTPUT_EXTERNAL. */ + #define ASM_DECLARE_FUNCTION_SIZE(STREAM, NAME, DECL) \ + do { \ + tree name_tree = get_identifier (NAME); \ + TREE_ASM_WRITTEN (name_tree) = 1; \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/mips-5.h gcc-2.6.1/config/mips/mips-5.h *** gcc-2.6.0/config/mips/mips-5.h Mon Mar 7 20:31:33 1994 --- gcc-2.6.1/config/mips/mips-5.h Sun Aug 14 19:05:04 1994 *************** *** 27,34 **** #define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt1.o%s crtn.o%s}}" - /* Some RISCOS assemblers misassemble \n in a .ascii, - so we use \X0A instead. */ - #define ASM_OUTPUT_NEWLINE(STREAM) \ - fputs ("\\X0A", (STREAM)); - #include "mips/mips.h" --- 27,45 ---- #define STARTFILE_SPEC "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt1.o%s crtn.o%s}}" #include "mips/mips.h" + + /* Some assemblers have a bug that causes backslash escaped chars in .ascii + to be misassembled, so we just completely avoid it. */ + #undef ASM_OUTPUT_ASCII + #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ + do { \ + unsigned char *s; \ + int i; \ + for (i = 0, s = (unsigned char *)(PTR); i < (LEN); s++, i++) \ + { \ + if ((i % 8) == 0) \ + fputs ("\n\t.byte\t", (FILE)); \ + fprintf ((FILE), "%s0x%x", (i%8?",":""), (unsigned)*s); \ + } \ + fputs ("\n", (FILE)); \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/mips.c gcc-2.6.1/config/mips/mips.c *** gcc-2.6.0/config/mips/mips.c Wed May 4 14:26:11 1994 --- gcc-2.6.1/config/mips/mips.c Mon Oct 17 19:21:06 1994 *************** *** 3111,3114 **** --- 3111,3122 ---- break; } + + #ifdef MIPS_CPU_DEFAULT + if (mips_isa_string == (char *)0) + { + mips_cpu_string = MIPS_CPU_STRING_DEFAULT; + mips_cpu = MIPS_CPU_DEFAULT; + } + #endif } *************** *** 3771,3776 **** --- 3779,3814 ---- extern_head = p; } + + #ifdef ASM_OUTPUT_UNDEF_FUNCTION + if (TREE_CODE (decl) == FUNCTION_DECL) + { + p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list)); + p->next = extern_head; + p->name = name; + p->size = -1; + extern_head = p; + } + #endif + + return 0; + } + + #ifdef ASM_OUTPUT_UNDEF_FUNCTION + int + mips_output_external_libcall (file, name) + FILE *file; + char *name; + { + register struct extern_list *p; + + p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list)); + p->next = extern_head; + p->name = name; + p->size = -1; + extern_head = p; + return 0; } + #endif *************** *** 4042,4049 **** HALF_PIC_FINISH (file); ! if (TARGET_GP_OPT) { ! if (extern_head) ! fputs ("\n", file); for (p = extern_head; p != 0; p = p->next) --- 4080,4086 ---- HALF_PIC_FINISH (file); ! if (extern_head) { ! fputs ("\n", file); for (p = extern_head; p != 0; p = p->next) *************** *** 4055,4064 **** { TREE_ASM_WRITTEN (name_tree) = 1; ! fputs ("\t.extern\t", file); ! assemble_name (file, p->name); ! fprintf (file, ", %d\n", p->size); } } ! fprintf (file, "\n\t.text\n"); rewind (asm_out_text_file); --- 4092,4111 ---- { TREE_ASM_WRITTEN (name_tree) = 1; ! #ifdef ASM_OUTPUT_UNDEF_FUNCTION ! if (p->size == -1) ! ASM_OUTPUT_UNDEF_FUNCTION (file, p->name); ! else ! #endif ! { ! fputs ("\t.extern\t", file); ! assemble_name (file, p->name); ! fprintf (file, ", %d\n", p->size); ! } } } ! } ! ! if (TARGET_GP_OPT) ! { fprintf (file, "\n\t.text\n"); rewind (asm_out_text_file); *************** *** 4673,4677 **** ASM_OUTPUT_SOURCE_FILENAME (file, DECL_SOURCE_FILE (current_function_decl)); ! if (debug_info_level != DINFO_LEVEL_TERSE) ASM_OUTPUT_SOURCE_LINE (file, DECL_SOURCE_LINE (current_function_decl)); --- 4720,4724 ---- ASM_OUTPUT_SOURCE_FILENAME (file, DECL_SOURCE_FILE (current_function_decl)); ! if (debug_info_level != DINFO_LEVEL_TERSE && write_symbols == SDB_DEBUG) ASM_OUTPUT_SOURCE_LINE (file, DECL_SOURCE_LINE (current_function_decl)); *************** *** 4756,4765 **** for (cur_arg = fnargs; cur_arg != (tree)0; cur_arg = next_arg) { ! tree type = DECL_ARG_TYPE (cur_arg); ! enum machine_mode passed_mode = TYPE_MODE (type); ! rtx entry_parm = FUNCTION_ARG (args_so_far, ! passed_mode, ! DECL_ARG_TYPE (cur_arg), ! 1); if (entry_parm) --- 4803,4817 ---- for (cur_arg = fnargs; cur_arg != (tree)0; cur_arg = next_arg) { ! tree passed_type = DECL_ARG_TYPE (cur_arg); ! enum machine_mode passed_mode = TYPE_MODE (passed_type); ! rtx entry_parm; ! ! if (TYPE_NEEDS_CONSTRUCTING (passed_type)) ! { ! passed_type = build_pointer_type (passed_type); ! passed_mode = Pmode; ! } ! ! entry_parm = FUNCTION_ARG (args_so_far, passed_mode, passed_type, 1); if (entry_parm) *************** *** 4769,4773 **** /* passed in a register, so will get homed automatically */ if (GET_MODE (entry_parm) == BLKmode) ! words = (int_size_in_bytes (type) + 3) / 4; else words = (GET_MODE_SIZE (GET_MODE (entry_parm)) + 3) / 4; --- 4821,4825 ---- /* passed in a register, so will get homed automatically */ if (GET_MODE (entry_parm) == BLKmode) ! words = (int_size_in_bytes (passed_type) + 3) / 4; else words = (GET_MODE_SIZE (GET_MODE (entry_parm)) + 3) / 4; *************** *** 4781,4788 **** } ! FUNCTION_ARG_ADVANCE (args_so_far, ! passed_mode, ! DECL_ARG_TYPE (cur_arg), ! 1); next_arg = TREE_CHAIN (cur_arg); --- 4833,4837 ---- } ! FUNCTION_ARG_ADVANCE (args_so_far, passed_mode, passed_type, 1); next_arg = TREE_CHAIN (cur_arg); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/mips.h gcc-2.6.1/config/mips/mips.h *** gcc-2.6.0/config/mips/mips.h Mon Jul 11 14:22:16 1994 --- gcc-2.6.1/config/mips/mips.h Tue Oct 18 16:14:34 1994 *************** *** 560,563 **** --- 560,565 ---- %{pipe: %e-pipe is not supported.} \ %{K}} \ + %{!mmips-as: \ + %{mcpu=*}} \ %{G*} %{EB} %{EL} %{mips1} %{mips2} %{mips3} %{v} \ %{noasmopt:-O0} \ *************** *** 577,580 **** --- 579,584 ---- %{pipe: %e-pipe is not supported.} \ %{K}} \ + %{mgas: \ + %{mcpu=*}} \ %{G*} %{EB} %{EL} %{mips1} %{mips2} %{mips3} %{v} \ %{noasmopt:-O0} \ *************** *** 3455,3466 **** fprintf (STREAM, "\t.space\t%u\n", (SIZE)) - - /* Some RISCOS assemblers don't correctly handle \n in a .ascii directive, - so we have separated out this part so that it can be machine dependent. */ - #ifndef ASM_OUTPUT_NEWLINE - #define ASM_OUTPUT_NEWLINE(STREAM) \ - fputs ("\\n", (STREAM)); - #endif - /* This is how to output a string. */ #define ASM_OUTPUT_ASCII(STREAM, STRING, LEN) \ --- 3459,3462 ---- *************** *** 3483,3487 **** \ case TARGET_NEWLINE: \ ! ASM_OUTPUT_NEWLINE (STREAM); \ if (i+1 < len \ && (((c = string[i+1]) >= '\040' && c <= '~') \ --- 3479,3483 ---- \ case TARGET_NEWLINE: \ ! fputs ("\\n", (STREAM)); \ if (i+1 < len \ && (((c = string[i+1]) >= '\040' && c <= '~') \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/mips.md gcc-2.6.1/config/mips/mips.md *** gcc-2.6.0/config/mips/mips.md Sat Jul 2 22:20:26 1994 --- gcc-2.6.1/config/mips/mips.md Thu Oct 20 16:21:00 1994 *************** *** 140,144 **** (define_function_unit "memory" 1 0 ! (and (eq_attr "type" "load") (eq_attr "cpu" "!r3000")) 3 0) --- 140,144 ---- (define_function_unit "memory" 1 0 ! (and (eq_attr "type" "load") (eq_attr "cpu" "!r3000,r4600")) 3 0) *************** *** 1946,1992 **** (set_attr "length" "1")]) ! ! ;; The optimizer doesn't deal well with truncate operators, so we completely ! ;; avoid them by using define expands here. ! ! (define_expand "truncdisi2" ! [(set (match_operand:DI 2 "register_operand" "=d") ! (ashift:DI (match_operand:DI 1 "register_operand" "d") ! (const_int 32))) ! (set (match_operand:DI 3 "register_operand" "=d") ! (ashiftrt:DI (match_dup 2) ! (const_int 32))) ! (set (match_operand:SI 0 "register_operand" "=d") ! (subreg:SI (match_dup 3) 0))] "TARGET_64BIT" ! " ! { ! operands[2] = gen_reg_rtx (DImode); ! operands[3] = gen_reg_rtx (DImode); ! }") ! (define_expand "truncdihi2" ! [(set (match_operand:DI 2 "register_operand" "=d") ! (and:DI (match_operand:DI 1 "register_operand" "d") ! (const_int 65535))) ! (set (match_operand:HI 0 "register_operand" "=d") ! (subreg:HI (match_dup 2) 0))] "TARGET_64BIT" ! " ! { ! operands[2] = gen_reg_rtx (DImode); ! }") ! (define_expand "truncdiqi2" ! [(set (match_operand:DI 2 "register_operand" "=d") ! (and:DI (match_operand:DI 1 "register_operand" "d") ! (const_int 255))) ! (set (match_operand:QI 0 "register_operand" "=d") ! (subreg:QI (match_dup 2) 0))] "TARGET_64BIT" ! " ! { ! operands[2] = gen_reg_rtx (DImode); ! }") ;; --- 1946,1980 ---- (set_attr "length" "1")]) ! ;; ??? This should be a define expand. ! ;; See the zero_extendsidi2 pattern. ! ;; ??? We tried define expands, but they did not work. Too many shift ! ;; instructions were optimized away. Perhaps add combiner patterns to ! ;; recognize cases where shifts and truncates can be combined. ! (define_insn "truncdisi2" ! [(set (match_operand:SI 0 "register_operand" "=d") ! (truncate:SI (match_operand:DI 1 "register_operand" "d")))] "TARGET_64BIT" ! "dsll\\t%0,%1,32\;dsra\\t%0,%0,32" ! [(set_attr "type" "darith") ! (set_attr "mode" "SI") ! (set_attr "length" "2")]) ! (define_insn "truncdihi2" ! [(set (match_operand:HI 0 "register_operand" "=d") ! (truncate:HI (match_operand:DI 1 "register_operand" "d")))] "TARGET_64BIT" ! "andi\\t%0,%1,0xffff" ! [(set_attr "type" "darith") ! (set_attr "mode" "HI") ! (set_attr "length" "1")]) ! (define_insn "truncdiqi2" ! [(set (match_operand:QI 0 "register_operand" "=d") ! (truncate:QI (match_operand:DI 1 "register_operand" "d")))] "TARGET_64BIT" ! "andi\\t%0,%1,0x00ff" ! [(set_attr "type" "darith") ! (set_attr "mode" "QI") ! (set_attr "length" "1")]) ;; *************** *** 3197,3204 **** [(set (match_operand:DF 0 "register_operand" "") (match_operand:DF 1 "register_operand" ""))] ! "reload_completed && !TARGET_DEBUG_D_MODE && !TARGET_DEBUG_G_MODE && GET_CODE (operands[0]) == REG && GP_REG_P (REGNO (operands[0])) && GET_CODE (operands[1]) == REG && GP_REG_P (REGNO (operands[1]))" - [(set (subreg:SI (match_dup 0) 0) (subreg:SI (match_dup 1) 0)) (set (subreg:SI (match_dup 0) 1) (subreg:SI (match_dup 1) 1))] --- 3185,3191 ---- [(set (match_operand:DF 0 "register_operand" "") (match_operand:DF 1 "register_operand" ""))] ! "reload_completed && !TARGET_64BIT && !TARGET_DEBUG_D_MODE && !TARGET_DEBUG_G_MODE && GET_CODE (operands[0]) == REG && GP_REG_P (REGNO (operands[0])) && GET_CODE (operands[1]) == REG && GP_REG_P (REGNO (operands[1]))" [(set (subreg:SI (match_dup 0) 0) (subreg:SI (match_dup 1) 0)) (set (subreg:SI (match_dup 0) 1) (subreg:SI (match_dup 1) 1))] diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/svr3-5.h gcc-2.6.1/config/mips/svr3-5.h *** gcc-2.6.0/config/mips/svr3-5.h Wed May 4 14:18:14 1994 --- gcc-2.6.1/config/mips/svr3-5.h Sun Aug 14 19:05:20 1994 *************** *** 69,76 **** #define TARGET_MEM_FUNCTIONS - /* Some RISCOS assemblers misassemble \n in a .ascii, - so we use \X0A instead. */ - #define ASM_OUTPUT_NEWLINE(STREAM) \ - fputs ("\\X0A", (STREAM)); - #include "mips/mips.h" --- 69,87 ---- #define TARGET_MEM_FUNCTIONS #include "mips/mips.h" + + /* Some assemblers have a bug that causes backslash escaped chars in .ascii + to be misassembled, so we just completely avoid it. */ + #undef ASM_OUTPUT_ASCII + #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ + do { \ + unsigned char *s; \ + int i; \ + for (i = 0, s = (unsigned char *)(PTR); i < (LEN); s++, i++) \ + { \ + if ((i % 8) == 0) \ + fputs ("\n\t.byte\t", (FILE)); \ + fprintf ((FILE), "%s0x%x", (i%8?",":""), (unsigned)*s); \ + } \ + fputs ("\n", (FILE)); \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/mips/svr4-5.h gcc-2.6.1/config/mips/svr4-5.h *** gcc-2.6.0/config/mips/svr4-5.h Wed May 4 14:18:22 1994 --- gcc-2.6.1/config/mips/svr4-5.h Sun Aug 14 19:05:23 1994 *************** *** 72,79 **** #define TARGET_MEM_FUNCTIONS - /* Some RISCOS assemblers misassemble \n in a .ascii, - so we use \X0A instead. */ - #define ASM_OUTPUT_NEWLINE(STREAM) \ - fputs ("\\X0A", (STREAM)); - #include "mips/mips.h" --- 72,90 ---- #define TARGET_MEM_FUNCTIONS #include "mips/mips.h" + + /* Some assemblers have a bug that causes backslash escaped chars in .ascii + to be misassembled, so we just completely avoid it. */ + #undef ASM_OUTPUT_ASCII + #define ASM_OUTPUT_ASCII(FILE,PTR,LEN) \ + do { \ + unsigned char *s; \ + int i; \ + for (i = 0, s = (unsigned char *)(PTR); i < (LEN); s++, i++) \ + { \ + if ((i % 8) == 0) \ + fputs ("\n\t.byte\t", (FILE)); \ + fprintf ((FILE), "%s0x%x", (i%8?",":""), (unsigned)*s); \ + } \ + fputs ("\n", (FILE)); \ + } while (0) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/msdos/configur.bat gcc-2.6.1/config/msdos/configur.bat *** gcc-2.6.0/config/msdos/configur.bat --- gcc-2.6.1/config/msdos/configur.bat Fri Jul 22 09:57:13 1994 *************** *** 0 **** --- 1,33 ---- + @echo off + echo Configuring GCC for go32 + rem This batch file assumes a unix-type "sed" program + + if not exist config\msdos\configure.bat chdir ..\.. + + update config\i386\xm-dos.h config.h + update config\i386\xm-dos.h hconfig.h + update config\i386\xm-dos.h tconfig.h + update config\i386\go32.h tm.h + update config\i386\i386.md md + update config\i386\i386.c aux-output.c + + echo # Makefile generated by "configure.bat"> Makefile + echo all.dos: cccp cc1 cc1obj xgcc s-objlist >> Makefile + sed -f config/msdos/top.sed Makefile.in >> Makefile + + set LANG= + + if not exist cp\make-lang.in goto no_cp + sed -f config/msdos/top.sed cp\make-lang.in >> Makefile + sed -f config/msdos/top.sed cp\makefile.in > cp\Makefile + set LANG=%LANG% c++.& + :no_cp + + echo lang.mostlyclean: %LANG% | sed "s/&/mostlyclean/g" >> Makefile + echo lang.clean: %LANG% | sed "s/&/clean/g" >> Makefile + echo lang.distclean: %LANG% | sed "s/&/distclean/g" >> Makefile + echo lang.realclean: %LANG% | sed "s/&/realclean/g" >> Makefile + + echo #define MULTILIB_SELECT ". ;" > multilib.h1 + update multilib.h1 multilib.h + del multilib.h1 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/msdos/top.sed gcc-2.6.1/config/msdos/top.sed *** gcc-2.6.0/config/msdos/top.sed --- gcc-2.6.1/config/msdos/top.sed Sun Oct 30 10:11:01 1994 *************** *** 0 **** --- 1,38 ---- + /\.o[ ]*:/ s/config.status// + /^multilib.h/ s/multilib/not-multilib/ + /^target=/ c\ + target=go32 + /^xmake_file=/ d + /^tmake_file=/ d + /^version=/ c\ + version=2.6.1 + s/CC = cc/CC = gcc/ + s/:\$/: \$/g + s/^ \ *\.\// go32 / + s/<\ *\$(srcdir)\//< $(srcdir)\\/g + s/^ \$(srcdir)\/move-if-change/ update/ + s/^USE_/# USE_/ + s/`echo \$(srcdir)\///g + s/ | sed 's,\^\\\.\/,,'`//g + s/^ cd \$(srcdir)[ ]*;/ / + /^# USE_HOST_OBSTACK/ i\ + USE_HOST_OBSTACK=obstack.o + /^stamp-attrtab/,/update/ { + /\\/d + /fi/d + /update/ i\ + go32 genattrtab md > t-attrtab.c + } + /^enquire[ ]*:/ s/\$(GCC_PARTS)//g + /^enquire.o[ ]*:/ s/\$(GCC_PASSES)//g + /^GCC_FOR_TARGET =/ c\ + GCC_FOR_TARGET = gcc + s/; *@true// + s/stamp-/s-/g + s/tmp-/t-/g + /> *s-objlist/ c\ + echo.exe -o s-objlist $(addprefix ../,$(OBJS) $(BC_OBJS)) + /^OBJS.*s-objlist/ s?`cat ../s-objlist`?@../s-objlist? + s/^\(SUBDIR_OBSTACK *=\).*$/\1 ..\/obstack.o/ + s/^\(SUBDIR_USE_ALLOCA *=\).*$/\1/ + s/^\(SUBDIR_MALLOC *=\).*$/\1/ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/netbsd.h gcc-2.6.1/config/netbsd.h *** gcc-2.6.0/config/netbsd.h Thu Jul 14 12:58:46 1994 --- gcc-2.6.1/config/netbsd.h Fri Sep 9 15:07:01 1994 *************** *** 74,77 **** --- 74,80 ---- file which includes this one. */ + #undef TYPE_ASM_OP + #undef SIZE_ASM_OP + #undef WEAK_ASM_OP #define TYPE_ASM_OP ".type" #define SIZE_ASM_OP ".size" *************** *** 84,87 **** --- 87,91 ---- specific tm.h file (depending upon the particulars of your assembler). */ + #undef TYPE_OPERAND_FMT #define TYPE_OPERAND_FMT "@%s" *************** *** 103,106 **** --- 107,111 ---- function's return value. We allow for that here. */ + #undef ASM_DECLARE_FUNCTION_NAME #define ASM_DECLARE_FUNCTION_NAME(FILE, NAME, DECL) \ do { \ *************** *** 116,119 **** --- 121,125 ---- /* Write the extra assembler code needed to declare an object properly. */ + #undef ASM_DECLARE_OBJECT_NAME #define ASM_DECLARE_OBJECT_NAME(FILE, NAME, DECL) \ do { \ *************** *** 140,143 **** --- 146,150 ---- by ASM_DECLARE_OBJECT_NAME when it was run for the same decl. */ + #undef ASM_FINISH_DECLARE_OBJECT #define ASM_FINISH_DECLARE_OBJECT(FILE, DECL, TOP_LEVEL, AT_END) \ do { \ *************** *** 157,160 **** --- 164,168 ---- /* This is how to declare the size of a function. */ + #undef ASM_DECLARE_FUNCTION_SIZE #define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ do { \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/genix.h gcc-2.6.1/config/ns32k/genix.h *** gcc-2.6.0/config/ns32k/genix.h Tue Jan 5 00:51:12 1993 --- gcc-2.6.1/config/ns32k/genix.h Sat Jul 30 14:58:00 1994 *************** *** 1,4 **** /* Definitions of target machine for GNU compiler. Genix ns32000 version. ! Copyright (C) 1987, 1988 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Definitions of target machine for GNU compiler. Genix ns32000 version. ! Copyright (C) 1987, 1988, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 154,158 **** } \ } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ if (GET_MODE (X) == DFmode) \ { union { double d; int i[2]; } u; \ --- 154,158 ---- } \ } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode) \ if (GET_MODE (X) == DFmode) \ { union { double d; int i[2]; } u; \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/merlin.h gcc-2.6.1/config/ns32k/merlin.h *** gcc-2.6.0/config/ns32k/merlin.h Sat Oct 2 04:22:10 1993 --- gcc-2.6.1/config/ns32k/merlin.h Sat Jul 30 15:00:52 1994 *************** *** 1,4 **** /* Definitions of target machine for GNU compiler. MERLIN NS32000 version. ! Copyright (C) 1990 Free Software Foundation, Inc. By Mark Mason (mason@reed.bitnet, pyramid!unify!mason@uunet.uu.net). --- 1,4 ---- /* Definitions of target machine for GNU compiler. MERLIN NS32000 version. ! Copyright (C) 1990, 1994 Free Software Foundation, Inc. By Mark Mason (mason@reed.bitnet, pyramid!unify!mason@uunet.uu.net). *************** *** 113,117 **** } \ } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ if (GET_MODE (X) == DFmode) \ { union { double d; int i[2]; } u; \ --- 113,117 ---- } \ } \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode) \ if (GET_MODE (X) == DFmode) \ { union { double d; int i[2]; } u; \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/netbsd.h gcc-2.6.1/config/ns32k/netbsd.h *** gcc-2.6.0/config/ns32k/netbsd.h Wed Mar 30 17:30:47 1994 --- gcc-2.6.1/config/ns32k/netbsd.h Mon Aug 8 19:57:01 1994 *************** *** 1,3 **** --- 1,4 ---- /* Configuration for a ns32532 running NetBSD as the target machine. + Copyright (C) 1988, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 17,21 **** the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ! $Id: netbsd.h,v 1.1 1994/03/30 22:30:46 kenner Exp $ */ --- 18,22 ---- the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ! $Id: netbsd.h,v 1.2 1994/08/08 23:57:00 kenner Exp $ */ *************** *** 24,30 **** /* Compile for the floating point unit & 32532 by default; ! Don't assume SB is zero */ ! #define TARGET_DEFAULT 57 /* 32-bit alignment for efficiency */ --- 25,32 ---- /* Compile for the floating point unit & 32532 by default; ! Don't assume SB is zero; ! Don't use bitfield instructions; */ ! #define TARGET_DEFAULT 121 /* 32-bit alignment for efficiency */ *************** *** 69,73 **** #undef CPP_PREDEFINES ! #define CPP_PREDEFINES "-Dns32k -Dns32000 -Dns32532 -D__NetBSD__ -Dunix" /* Specify -k to assembler for pic generation. PIC needs -K too. */ --- 71,75 ---- #undef CPP_PREDEFINES ! #define CPP_PREDEFINES "-Dns32k -Dns32000 -Dns32532 -D__NetBSD__ -Dunix -Dpc532" /* Specify -k to assembler for pic generation. PIC needs -K too. */ *************** *** 94,103 **** #undef WCHAR_TYPE ! #define WCHAR_TYPE "short unsigned int" ! #define WCHAR_UNSIGNED 1 #undef WCHAR_TYPE_SIZE ! #define WCHAR_TYPE_SIZE 16 /* This is BSD, so it wants DBX format. */ --- 96,105 ---- #undef WCHAR_TYPE ! #define WCHAR_TYPE "int" ! #define WCHAR_UNSIGNED 0 #undef WCHAR_TYPE_SIZE ! #define WCHAR_TYPE_SIZE 32 /* This is BSD, so it wants DBX format. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/ns32k.c gcc-2.6.1/config/ns32k/ns32k.c *** gcc-2.6.0/config/ns32k/ns32k.c Thu Jun 23 17:45:13 1994 --- gcc-2.6.1/config/ns32k/ns32k.c Mon Aug 8 19:54:23 1994 *************** *** 468,472 **** output_address (XEXP (x, 0)); } ! else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != DImode) { if (GET_MODE (x) == DFmode) --- 468,472 ---- output_address (XEXP (x, 0)); } ! else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode) { if (GET_MODE (x) == DFmode) *************** *** 768,771 **** --- 768,790 ---- fprintf (file, "(%s)", reg_names[REGNO (base)]); #ifdef BASE_REG_NEEDED + else if (TARGET_SB) + fprintf (file, "(sb)"); + else + abort (); + #endif + fprintf (file, ")"); + break; + + default: + abort (); + } + #ifdef PC_RELATIVE + else if (GET_CODE (offset) == LABEL_REF + || GET_CODE (offset) == SYMBOL_REF + || GET_CODE (offset) == CONST + || GET_CODE (offset) == PLUS) + fprintf (file, "(pc)"); + #endif + #ifdef BASE_REG_NEEDED else { *************** *** 786,809 **** } } - #endif - fprintf (file, ")"); - break; - - default: - abort (); - } - #ifdef PC_RELATIVE - else if (GET_CODE (offset) == LABEL_REF - || GET_CODE (offset) == SYMBOL_REF - || GET_CODE (offset) == CONST - || GET_CODE (offset) == PLUS) - fprintf (file, "(pc)"); - #endif - #ifdef BASE_REG_NEEDED /* this is defined if the assembler always - needs a base register */ - else if (TARGET_SB) - fprintf (file, "(sb)"); - else - abort (); #endif /* now print index if we have one */ --- 805,808 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/ns32k.h gcc-2.6.1/config/ns32k/ns32k.h *** gcc-2.6.0/config/ns32k/ns32k.h Wed Mar 30 17:26:11 1994 --- gcc-2.6.1/config/ns32k/ns32k.h Tue Sep 27 19:27:14 1994 *************** *** 1,5 **** /* Definitions of target machine for GNU compiler. NS32000 version. Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc. ! Contributed by Michael Tiemann (tiemann@mcc.com) This file is part of GNU CC. --- 1,5 ---- /* Definitions of target machine for GNU compiler. NS32000 version. Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc. ! Contributed by Michael Tiemann (tiemann@cygnus.com) This file is part of GNU CC. *************** *** 83,86 **** --- 83,89 ---- #define TARGET_SB ((target_flags & 32) == 0) + /* Compile using bitfield insns. */ + #define TARGET_BITFIELD ((target_flags & 64) == 0) + /* Macro to define tables used to set the flags. This is a list in braces of pairs in braces, *************** *** 102,105 **** --- 105,110 ---- { "sb", -32}, \ { "nosb", 32}, \ + { "bitfield", -64}, \ + { "nobitfield", 64}, \ { "", TARGET_DEFAULT}} /* TARGET_DEFAULT is defined in encore.h, pc532.h, etc. */ *************** *** 1058,1062 **** SYMBOL_REF_FLAG (XEXP (rtl, 0)) \ = (TREE_CODE_CLASS (TREE_CODE (DECL)) != 'd' \ - || TREE_CODE (DECL) == FUNCTION_DECL \ || ! TREE_PUBLIC (DECL)); \ } \ --- 1063,1066 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/ns32k/ns32k.md gcc-2.6.1/config/ns32k/ns32k.md *** gcc-2.6.0/config/ns32k/ns32k.md Tue May 17 18:06:05 1994 --- gcc-2.6.1/config/ns32k/ns32k.md Tue Sep 6 18:24:02 1994 *************** *** 1862,1866 **** }") ! ;; The extsd/extd isntructions have the problem that they always access ;; 32 bits even if the bitfield is smaller. For example the instruction ;; extsd 7(r1),r0,2,5 --- 1862,1866 ---- }") ! ;; The exts/ext instructions have the problem that they always access ;; 32 bits even if the bitfield is smaller. For example the instruction ;; extsd 7(r1),r0,2,5 *************** *** 1877,1881 **** ;; takes about 21 cycles. ;; ! ;; So lets forget about extsd/extd on the 532. (define_insn "" --- 1877,1884 ---- ;; takes about 21 cycles. ;; ! ;; The inss/ins instructions suffer from the same problem. ! ;; ! ;; A machine specific option (-mbitfield/-mnobitfield) is used ! ;; to allow/disallow the use of these instructions. (define_insn "" *************** *** 1884,1888 **** (match_operand:SI 2 "const_int_operand" "i") (match_operand:SI 3 "general_operand" "rK")))] ! "! TARGET_32532" "* { if (GET_CODE (operands[3]) == CONST_INT) --- 1887,1891 ---- (match_operand:SI 2 "const_int_operand" "i") (match_operand:SI 3 "general_operand" "rK")))] ! "TARGET_BITFIELD" "* { if (GET_CODE (operands[3]) == CONST_INT) *************** *** 1896,1900 **** (match_operand:SI 2 "const_int_operand" "i") (match_operand:SI 3 "general_operand" "rK")))] ! "! TARGET_32532" "* { if (GET_CODE (operands[3]) == CONST_INT) --- 1899,1903 ---- (match_operand:SI 2 "const_int_operand" "i") (match_operand:SI 3 "general_operand" "rK")))] ! "TARGET_BITFIELD" "* { if (GET_CODE (operands[3]) == CONST_INT) *************** *** 1908,1912 **** (match_operand:SI 2 "general_operand" "rn")) (match_operand:SI 3 "general_operand" "rm"))] ! "" "* { if (GET_CODE (operands[2]) == CONST_INT) --- 1911,1915 ---- (match_operand:SI 2 "general_operand" "rn")) (match_operand:SI 3 "general_operand" "rm"))] ! "TARGET_BITFIELD" "* { if (GET_CODE (operands[2]) == CONST_INT) *************** *** 1933,1937 **** (match_operand:SI 2 "general_operand" "rK")) (match_operand:SI 3 "general_operand" "rm"))] ! "" "* { if (GET_CODE (operands[2]) == CONST_INT) --- 1936,1940 ---- (match_operand:SI 2 "general_operand" "rK")) (match_operand:SI 3 "general_operand" "rm"))] ! "TARGET_BITFIELD" "* { if (GET_CODE (operands[2]) == CONST_INT) *************** *** 1950,1954 **** (match_operand:SI 2 "general_operand" "rK")) (match_operand:SI 3 "general_operand" "rm"))] ! "" "* { if (GET_CODE (operands[2]) == CONST_INT) --- 1953,1957 ---- (match_operand:SI 2 "general_operand" "rK")) (match_operand:SI 3 "general_operand" "rm"))] ! "TARGET_BITFIELD" "* { if (GET_CODE (operands[2]) == CONST_INT) *************** *** 2700,2703 **** --- 2703,2710 ---- output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%$%1,0(sp)\"), operands); + else if (GET_CODE (operands[1]) != REG + && GET_CODE (operands[1]) != MEM + && address_operand (operands[1], SImode)) + output_asm_insn (\"addr %a1,0(sp)\", operands); else output_asm_insn (\"movd %1,0(sp)\", operands); *************** *** 2720,2723 **** --- 2727,2734 ---- output_asm_insn (output_move_dconst (INTVAL (operands[1]), \"%$%1,4(sp)\"), operands); + else if (GET_CODE (operands[1]) != REG + && GET_CODE (operands[1]) != MEM + && address_operand (operands[1], SImode)) + output_asm_insn (\"addr %a1,4(sp)\", operands); else output_asm_insn (\"movd %1,4(sp)\", operands); *************** *** 2726,2729 **** --- 2737,2744 ---- output_asm_insn (output_move_dconst (INTVAL (operands[3]), \"%$%3,0(sp)\"), operands); + else if (GET_CODE (operands[3]) != REG + && GET_CODE (operands[3]) != MEM + && address_operand (operands[3], SImode)) + output_asm_insn (\"addr %a3,0(sp)\", operands); else output_asm_insn (\"movd %3,0(sp)\", operands); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/pa-ghpux.h gcc-2.6.1/config/pa/pa-ghpux.h *** gcc-2.6.0/config/pa/pa-ghpux.h Sun Apr 10 04:48:01 1994 --- gcc-2.6.1/config/pa/pa-ghpux.h Thu Oct 20 18:05:57 1994 *************** *** 38,42 **** #undef LINK_SPEC ! #define LINK_SPEC "-u main %{static: -a archive}%{g: -a archive}" /* hpux8 and later have C++ compatable include files, so do not --- 38,42 ---- #undef LINK_SPEC ! #define LINK_SPEC "-u main %{static: -a archive}%{g*: -a archive}" /* hpux8 and later have C++ compatable include files, so do not diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/pa-hpux.h gcc-2.6.1/config/pa/pa-hpux.h *** gcc-2.6.0/config/pa/pa-hpux.h Sun Apr 10 04:48:19 1994 --- gcc-2.6.1/config/pa/pa-hpux.h Thu Oct 20 18:05:58 1994 *************** *** 43,47 **** #undef LINK_SPEC ! #define LINK_SPEC "-u main %{static: -a archive}%{g: -a archive}" /* hpux8 and later have C++ compatable include files, so do not --- 43,47 ---- #undef LINK_SPEC ! #define LINK_SPEC "-u main %{static: -a archive}%{g*: -a archive}" /* hpux8 and later have C++ compatable include files, so do not diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/pa.c gcc-2.6.1/config/pa/pa.c *** gcc-2.6.0/config/pa/pa.c Tue Jun 14 15:12:35 1994 --- gcc-2.6.1/config/pa/pa.c Tue Oct 18 08:37:48 1994 *************** *** 1,4 **** /* Subroutines for insn-output.c for HPPA. ! Copyright (C) 1992, 1993 Free Software Foundation, Inc. Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.c --- 1,4 ---- /* Subroutines for insn-output.c for HPPA. ! Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.c *************** *** 612,618 **** x = XEXP (x, 0); if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT ! && (GET_CODE (XEXP (x, 0)) == SYMBOL_REF || GET_CODE (XEXP (x, 0)) == REG)) { --- 612,621 ---- x = XEXP (x, 0); + /* Note we must reject symbols which represent function addresses + since the assembler/linker can't handle arithmetic on plabels. */ if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT ! && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF ! && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0))) || GET_CODE (XEXP (x, 0)) == REG)) { *************** *** 767,778 **** /* Handle secondary reloads for loads/stores of FP registers from ! REG+D addresses where D does not fit in 5 bits. */ if (fp_reg_operand (operand0, mode) ! && GET_CODE (operand1) == MEM ! /* Using DFmode forces only short displacements be be ! recognized as valid in reg+d addressing modes. */ ! && ! memory_address_p (DFmode, XEXP (operand1, 0)) && scratch_reg) { emit_move_insn (scratch_reg, XEXP (operand1, 0)); emit_insn (gen_rtx (SET, VOIDmode, operand0, gen_rtx (MEM, mode, --- 770,787 ---- /* Handle secondary reloads for loads/stores of FP registers from ! REG+D addresses where D does not fit in 5 bits, including ! (subreg (mem (addr)) cases. */ if (fp_reg_operand (operand0, mode) ! && ((GET_CODE (operand1) == MEM ! && ! memory_address_p (DFmode, XEXP (operand1, 0))) ! || ((GET_CODE (operand1) == SUBREG ! && GET_CODE (XEXP (operand1, 0)) == MEM ! && !memory_address_p (DFmode, XEXP (XEXP (operand1, 0), 0))))) && scratch_reg) { + if (GET_CODE (operand1) == SUBREG) + operand1 = XEXP (operand1, 0); + + scratch_reg = gen_rtx (REG, SImode, REGNO (scratch_reg)); emit_move_insn (scratch_reg, XEXP (operand1, 0)); emit_insn (gen_rtx (SET, VOIDmode, operand0, gen_rtx (MEM, mode, *************** *** 781,790 **** } else if (fp_reg_operand (operand1, mode) ! && GET_CODE (operand0) == MEM ! /* Using DFmode forces only short displacements be be ! recognized as valid in reg+d addressing modes. */ ! && ! memory_address_p (DFmode, XEXP (operand0, 0)) && scratch_reg) { emit_move_insn (scratch_reg, XEXP (operand0, 0)); emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (MEM, mode, scratch_reg), --- 790,804 ---- } else if (fp_reg_operand (operand1, mode) ! && ((GET_CODE (operand0) == MEM ! && ! memory_address_p (DFmode, XEXP (operand0, 0))) ! || ((GET_CODE (operand0) == SUBREG) ! && GET_CODE (XEXP (operand0, 0)) == MEM ! && !memory_address_p (DFmode, XEXP (XEXP (operand0, 0), 0)))) && scratch_reg) { + if (GET_CODE (operand0) == SUBREG) + operand0 = XEXP (operand0, 0); + + scratch_reg = gen_rtx (REG, SImode, REGNO (scratch_reg)); emit_move_insn (scratch_reg, XEXP (operand0, 0)); emit_insn (gen_rtx (SET, VOIDmode, gen_rtx (MEM, mode, scratch_reg), *************** *** 819,826 **** } /* Handle secondary reloads for SAR. These occur when trying to load ! the SAR from memory or from a FP register. */ else if (GET_CODE (operand0) == REG && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS && (GET_CODE (operand1) == MEM || (GET_CODE (operand1) == REG && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))) --- 833,841 ---- } /* Handle secondary reloads for SAR. These occur when trying to load ! the SAR from memory a FP register, or with a constant. */ else if (GET_CODE (operand0) == REG && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS && (GET_CODE (operand1) == MEM + || GET_CODE (operand1) == CONST_INT || (GET_CODE (operand1) == REG && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))) *************** *** 893,897 **** else { ! rtx temp, set; if (reload_in_progress || reload_completed) --- 908,912 ---- else { ! rtx temp, set, const_part = NULL; if (reload_in_progress || reload_completed) *************** *** 900,903 **** --- 915,937 ---- temp = gen_reg_rtx (mode); + /* Argh. The assembler and linker can't handle arithmetic + involving plabels. We'll have to split up operand1 here + if it's a function label involved in an arithmetic + expression. Luckily, this only happens with addition + of constants to plabels, which simplifies the test. */ + if (GET_CODE (operand1) == CONST + && GET_CODE (XEXP (operand1, 0)) == PLUS + && function_label_operand (XEXP (XEXP (operand1, 0), 0), + Pmode)) + { + /* Save away the constant part of the expression. */ + const_part = XEXP (XEXP (operand1, 0), 1); + if (GET_CODE (const_part) != CONST_INT) + abort (); + + /* Set operand1 to just the SYMBOL_REF. */ + operand1 = XEXP (XEXP (operand1, 0), 0); + } + if (ishighonly) set = gen_rtx (SET, mode, operand0, temp); *************** *** 911,914 **** --- 945,954 ---- gen_rtx (HIGH, mode, operand1))); emit_insn (set); + + /* Add back in the constant part if needed. */ + if (const_part != NULL) + emit_insn (gen_rtx (SET, mode, operand0, + plus_constant (operand0, + XEXP (const_part, 0)))); return 1; } *************** *** 2063,2070 **** else { ! store_reg (1, 0, FRAME_POINTER_REGNUM); set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM, ! actual_fsize); } } --- 2103,2118 ---- else { ! /* It is incorrect to store the saved frame pointer at *sp, ! then increment sp (writes beyond the current stack boundary). ! ! So instead use stwm to store at *sp and post-increment the ! stack pointer as an atomic operation. Then increment sp to ! finish allocating the new frame. */ ! emit_insn (gen_post_stwm (stack_pointer_rtx, ! stack_pointer_rtx, ! GEN_INT (64), tmpreg)); set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM, ! actual_fsize - 64); } } *************** *** 2879,2883 **** fprintf (file, "0x%x", u1.i); } ! else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != DImode) { union { double d; int i[2]; } u; --- 2927,2931 ---- fprintf (file, "0x%x", u1.i); } ! else if (GET_CODE (x) == CONST_DOUBLE && GET_MODE (x) != VOIDmode) { union { double d; int i[2]; } u; *************** *** 3226,3229 **** --- 3274,3286 ---- return R1_REGS; + if (GET_CODE (in) == SUBREG) + in = SUBREG_REG (in); + + if (FP_REG_CLASS_P (class) + && GET_CODE (in) == MEM + && !memory_address_p (DFmode, XEXP (in, 0)) + && memory_address_p (SImode, XEXP (in, 0))) + return GENERAL_REGS; + return NO_REGS; } *************** *** 3795,3799 **** int ! function_label_operand (op, mode) rtx op; enum machine_mode mode; --- 3852,3856 ---- int ! function_label_operand (op, mode) rtx op; enum machine_mode mode; *************** *** 3802,3805 **** --- 3859,3878 ---- } + /* Returns 1 if OP is a function label involved in a simple addition + with a constant. Used to keep certain patterns from matching + during instruction combination. */ + int + is_function_label_plus_const (op) + rtx op; + { + /* Strip off any CONST. */ + if (GET_CODE (op) == CONST) + op = XEXP (op, 0); + + return (GET_CODE (op) == PLUS + && function_label_operand (XEXP (op, 0), Pmode) + && GET_CODE (XEXP (op, 1)) == CONST_INT); + } + /* Returns 1 if the 6 operands specified in OPERANDS are suitable for use in fmpyadd instructions. */ *************** *** 3913,3916 **** --- 3986,3999 ---- { return (GET_CODE (op) == CONST_INT && shadd_constant_p (INTVAL (op))); + } + + /* Return 1 if this operand is anything other than a hard register. */ + + int + non_hard_reg_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return ! (GET_CODE (op) == REG && REGNO (op) < FIRST_PSEUDO_REGISTER); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/pa.h gcc-2.6.1/config/pa/pa.h *** gcc-2.6.0/config/pa/pa.h Tue Jul 12 16:23:50 1994 --- gcc-2.6.1/config/pa/pa.h Sun Aug 21 23:15:08 1994 *************** *** 827,831 **** functions and calls through pointers to functions -- the conventions are different! Calls through pointers to functions only use general ! registers for the first four argument words. Of course all this is different for the portable runtime model --- 827,833 ---- functions and calls through pointers to functions -- the conventions are different! Calls through pointers to functions only use general ! registers for the first four argument words. Note the indirect function ! calling conventions are in effect during TARGET_LONG_CALLS, but ! current_call_is_indirect will not be set in such situations. Of course all this is different for the portable runtime model *************** *** 862,870 **** ? gen_rtx (REG, (MODE), \ (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \ ! ? (((!current_call_is_indirect || TARGET_PORTABLE_RUNTIME) \ && (MODE) == DFmode) \ ? ((CUM).words ? 38 : 34) \ : ((CUM).words ? 23 : 25)) \ ! : (((!current_call_is_indirect || TARGET_PORTABLE_RUNTIME) \ && (MODE) == SFmode) \ ? (32 + 2 * (CUM).words) \ --- 864,874 ---- ? gen_rtx (REG, (MODE), \ (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \ ! ? (((!(current_call_is_indirect || TARGET_LONG_CALLS) \ ! || TARGET_PORTABLE_RUNTIME) \ && (MODE) == DFmode) \ ? ((CUM).words ? 38 : 34) \ : ((CUM).words ? 23 : 25)) \ ! : (((!(current_call_is_indirect || TARGET_LONG_CALLS) \ ! || TARGET_PORTABLE_RUNTIME) \ && (MODE) == SFmode) \ ? (32 + 2 * (CUM).words) \ *************** *** 1892,1916 **** fprintf (FILE, "\t.blockz %d\n", (SIZE)) ! /* This says how to output an assembler line ! to define a global common symbol. */ ! /* Supposedly the assembler rejects the command if there is no tab! */ ! ! ! #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ ! { bss_section (); \ ! assemble_name ((FILE), (NAME)); \ ! fputs ("\t.comm ", (FILE)); \ ! fprintf ((FILE), "%d\n", (ROUNDED));} ! ! /* This says how to output an assembler line ! to define a local common symbol. */ ! ! #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ ! { bss_section (); \ ! fprintf ((FILE), "\t.align %d\n", (SIZE) <= 4 ? 4 : 8); \ assemble_name ((FILE), (NAME)); \ ! fprintf ((FILE), "\n\t.block %d\n", (ROUNDED));} ! /* Store in OUTPUT a string (made with alloca) containing an assembler-name for a local static variable named NAME. --- 1896,1917 ---- fprintf (FILE, "\t.blockz %d\n", (SIZE)) ! /* This says how to output an assembler line to define a global common symbol ! with size SIZE (in bytes) and alignment ALIGN (in bits). */ ! #define ASM_OUTPUT_ALIGNED_COMMON(FILE, NAME, SIZE, ALIGNED) \ ! { bss_section (); \ ! assemble_name ((FILE), (NAME)); \ ! fputs ("\t.comm ", (FILE)); \ ! fprintf ((FILE), "%d\n", MAX ((SIZE), ((ALIGNED) / BITS_PER_UNIT)));} ! ! /* This says how to output an assembler line to define a local common symbol ! with size SIZE (in bytes) and alignment ALIGN (in bits). */ ! ! #define ASM_OUTPUT_ALIGNED_LOCAL(FILE, NAME, SIZE, ALIGNED) \ ! { bss_section (); \ ! fprintf ((FILE), "\t.align %d\n", ((ALIGNED) / BITS_PER_UNIT)); \ assemble_name ((FILE), (NAME)); \ ! fprintf ((FILE), "\n\t.block %d\n", (SIZE));} ! /* Store in OUTPUT a string (made with alloca) containing an assembler-name for a local static variable named NAME. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/pa.md gcc-2.6.1/config/pa/pa.md *** gcc-2.6.0/config/pa/pa.md Tue Jun 28 12:41:35 1994 --- gcc-2.6.1/config/pa/pa.md Tue Nov 1 18:47:58 1994 *************** *** 957,961 **** (define_expand "reload_insi" [(set (match_operand:SI 0 "register_operand" "=Z") ! (match_operand:SI 1 "general_operand" "")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] "" --- 957,961 ---- (define_expand "reload_insi" [(set (match_operand:SI 0 "register_operand" "=Z") ! (match_operand:SI 1 "non_hard_reg_operand" "")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] "" *************** *** 971,975 **** (define_expand "reload_outsi" ! [(set (match_operand:SI 0 "general_operand" "") (match_operand:SI 1 "register_operand" "Z")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] --- 971,975 ---- (define_expand "reload_outsi" ! [(set (match_operand:SI 0 "non_hard_reg_operand" "") (match_operand:SI 1 "register_operand" "Z")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] *************** *** 1169,1174 **** (define_insn "add_high_const" [(set (match_operand:SI 0 "register_operand" "=!a,*r") ! (plus (match_operand:SI 1 "register_operand" "r,r") ! (high:SI (match_operand 2 "const_int_operand" ""))))] "reload_completed" "@ --- 1169,1174 ---- (define_insn "add_high_const" [(set (match_operand:SI 0 "register_operand" "=!a,*r") ! (plus:SI (match_operand:SI 1 "register_operand" "r,r") ! (high:SI (match_operand 2 "const_int_operand" ""))))] "reload_completed" "@ *************** *** 1200,1204 **** [(set (match_operand:SI 0 "register_operand" "=r") (high:SI (match_operand 1 "" "")))] ! "check_pic (1)" "ldil L'%G1,%0" [(set_attr "type" "move") --- 1200,1204 ---- [(set (match_operand:SI 0 "register_operand" "=r") (high:SI (match_operand 1 "" "")))] ! "check_pic (1) && !is_function_label_plus_const (operands[1])" "ldil L'%G1,%0" [(set_attr "type" "move") *************** *** 1233,1237 **** (lo_sum:SI (match_operand:SI 1 "register_operand" "r") (match_operand:SI 2 "immediate_operand" "i")))] ! "" "ldo R'%G2(%1),%0" [(set_attr "length" "4")]) --- 1233,1237 ---- (lo_sum:SI (match_operand:SI 1 "register_operand" "r") (match_operand:SI 2 "immediate_operand" "i")))] ! "!is_function_label_plus_const (operands[2])" "ldo R'%G2(%1),%0" [(set_attr "length" "4")]) *************** *** 1481,1484 **** --- 1481,1517 ---- }") + ;; Reloading an SImode or DImode value requires a scratch register if + ;; going in to or out of float point registers. + + (define_expand "reload_indf" + [(set (match_operand:DF 0 "register_operand" "=Z") + (match_operand:DF 1 "non_hard_reg_operand" "")) + (clobber (match_operand:DF 2 "register_operand" "=&r"))] + "" + " + { + if (emit_move_sequence (operands, DFmode, operands[2])) + DONE; + + /* We don't want the clobber emitted, so handle this ourselves. */ + emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1])); + DONE; + }") + + (define_expand "reload_outdf" + [(set (match_operand:DF 0 "non_hard_reg_operand" "") + (match_operand:DF 1 "register_operand" "Z")) + (clobber (match_operand:DF 2 "register_operand" "=&r"))] + "" + " + { + if (emit_move_sequence (operands, DFmode, operands[2])) + DONE; + + /* We don't want the clobber emitted, so handle this ourselves. */ + emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1])); + DONE; + }") + (define_insn "" [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand" *************** *** 1588,1592 **** (define_expand "reload_indi" [(set (match_operand:DI 0 "register_operand" "=f") ! (match_operand:DI 1 "general_operand" "")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] "" --- 1621,1625 ---- (define_expand "reload_indi" [(set (match_operand:DI 0 "register_operand" "=f") ! (match_operand:DI 1 "non_hard_reg_operand" "")) (clobber (match_operand:SI 2 "register_operand" "=&r"))] "" *************** *** 1719,1722 **** --- 1752,1788 ---- if (emit_move_sequence (operands, SFmode, 0)) DONE; + }") + + ;; Reloading an SImode or DImode value requires a scratch register if + ;; going in to or out of float point registers. + + (define_expand "reload_insf" + [(set (match_operand:SF 0 "register_operand" "=Z") + (match_operand:SF 1 "non_hard_reg_operand" "")) + (clobber (match_operand:SF 2 "register_operand" "=&r"))] + "" + " + { + if (emit_move_sequence (operands, SFmode, operands[2])) + DONE; + + /* We don't want the clobber emitted, so handle this ourselves. */ + emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1])); + DONE; + }") + + (define_expand "reload_outsf" + [(set (match_operand:SF 0 "non_hard_reg_operand" "") + (match_operand:SF 1 "register_operand" "Z")) + (clobber (match_operand:SF 2 "register_operand" "=&r"))] + "" + " + { + if (emit_move_sequence (operands, SFmode, operands[2])) + DONE; + + /* We don't want the clobber emitted, so handle this ourselves. */ + emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1])); + DONE; }") diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/t-pa gcc-2.6.1/config/pa/t-pa *** gcc-2.6.0/config/pa/t-pa Tue Sep 21 19:25:46 1993 --- gcc-2.6.1/config/pa/t-pa Mon Sep 12 18:14:16 1994 *************** *** 2,3 **** --- 2,4 ---- CROSS_LIBGCC1=libgcc1.null INSTALLED_H = float.h stdarg.h varargs.h $(USER_H) limits.h + ADA_CFLAGS=-mdisable-indexing diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pa/t-pa-hpux gcc-2.6.1/config/pa/t-pa-hpux *** gcc-2.6.0/config/pa/t-pa-hpux --- gcc-2.6.1/config/pa/t-pa-hpux Sun Oct 30 10:11:38 1994 *************** *** 0 **** --- 1,3 ---- + LIBGCC1=libgcc1.null + CROSS_LIBGCC1=libgcc1.null + ADA_CFLAGS=-mdisable-indexing diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pdp11/pdp11.c gcc-2.6.1/config/pdp11/pdp11.c *** gcc-2.6.0/config/pdp11/pdp11.c --- gcc-2.6.1/config/pdp11/pdp11.c Mon Oct 31 07:59:54 1994 *************** *** 0 **** --- 1,1418 ---- + /* Subroutines for gcc2 for pdp11. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at). + + 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 1, 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. */ + + #ifndef FILE + #include + #endif + #include "config.h" + #include "rtl.h" + #include "regs.h" + #include "hard-reg-set.h" + #include "real.h" + #include "insn-config.h" + #include "conditions.h" + #include "insn-flags.h" + #include "output.h" + #include "insn-attr.h" + + /* + #define FPU_REG_P(X) ((X)>=8 && (X)<14) + #define CPU_REG_P(X) ((X)>=0 && (X)<8) + */ + + /* this is the current value returned by the macro FIRST_PARM_OFFSET + defined in tm.h */ + int current_first_parm_offset; + + /* This is where the condition code register lives. */ + /* rtx cc0_reg_rtx; - no longer needed? */ + + static rtx find_addr_reg (); + + /* Nonzero if OP is a valid second operand for an arithmetic insn. */ + + int + arith_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (register_operand (op, mode) || GET_CODE (op) == CONST_INT); + } + + int + const_immediate_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (GET_CODE (op) == CONST_INT); + } + + int + immediate15_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (GET_CODE (op) == CONST_INT && ((INTVAL (op) & 0x8000) == 0x0000)); + } + + int + expand_shift_operand (op, mode) + rtx op; + enum machine_mode mode; + { + return (GET_CODE (op) == CONST_INT + && abs (INTVAL(op)) > 1 + && abs (INTVAL(op)) <= 4); + } + + /* + stream is a stdio stream to output the code to. + size is an int: how many units of temporary storage to allocate. + Refer to the array `regs_ever_live' to determine which registers + to save; `regs_ever_live[I]' is nonzero if register number I + is ever used in the function. This macro is responsible for + knowing which registers should not be saved even if used. + */ + + void + output_function_prologue(stream, size) + FILE *stream; + int size; + { + extern char call_used_regs[]; + extern int frame_pointer_needed; + + int fsize = ((size) + 1) & ~1; + int regno, nregs, i; + int offset = 0; + + int via_ac = -1; + + fprintf (stream, "\n\t; /* function prologue %s*/\n", current_function_name); + + /* if we are outputting code for main, + the switch FPU to right mode if TARGET_FPU */ + if ( (strcmp ("main", current_function_name) == 0) + && TARGET_FPU) + { + fprintf(stream, "\t;/* switch cpu to double float, single integer */\n"); + fprintf(stream, "\tsetd\n"); + fprintf(stream, "\tseti\n\n"); + } + + if (frame_pointer_needed) + { + fprintf(stream, "\tmov fp, -(sp)\n"); + fprintf(stream, "\tmov sp, fp\n"); + } + else + { + /* DON'T SAVE FP */ + } + + /* make frame */ + if (fsize) + fprintf (stream, "\tsub $%d, sp\n", fsize); + + /* save CPU registers */ + for (regno = 0; regno < 8; regno++) + if (regs_ever_live[regno] && ! call_used_regs[regno]) + if (! ((regno == FRAME_POINTER_REGNUM) + && frame_pointer_needed)) + fprintf (stream, "\tmov %s, -(sp)\n", reg_names[regno]); + /* fpu regs saving */ + + /* via_ac specifies the ac to use for saving ac4, ac5 */ + via_ac = -1; + + for (regno = 8; regno < FIRST_PSEUDO_REGISTER ; regno++) + { + /* ac0 - ac3 */ + if (LOAD_FPU_REG_P(regno) + && regs_ever_live[regno] + && ! call_used_regs[regno]) + { + fprintf (stream, "\tfstd %s, -(sp)\n", reg_names[regno]); + via_ac = regno; + } + + /* maybe make ac4, ac5 call used regs?? */ + /* ac4 - ac5 */ + if (NO_LOAD_FPU_REG_P(regno) + && regs_ever_live[regno] + && ! call_used_regs[regno]) + { + if (via_ac == -1) + abort(); + + fprintf (stream, "\tfldd %s, %s\n", reg_names[regno], reg_names[via_ac]); + fprintf (stream, "\tfstd %s, -(sp)\n", reg_names[via_ac]); + } + } + + fprintf (stream, "\t;/* end of prologue */\n\n"); + } + + /* + The function epilogue should not depend on the current stack pointer! + It should use the frame pointer only. This is mandatory because + of alloca; we also take advantage of it to omit stack adjustments + before returning. */ + + /* maybe we can make leaf functions faster by switching to the + second register file - this way we don't have to save regs! + leaf functions are ~ 50% of all functions (dynamically!) + + set/clear bit 11 (dec. 2048) of status word for switching register files - + but how can we do this? the pdp11/45 manual says bit may only + be set (p.24), but not cleared! + + switching to kernel is probably more expensive, so we'll leave it + like this and not use the second set of registers... + + maybe as option if you want to generate code for kernel mode? */ + + + void + output_function_epilogue(stream, size) + FILE *stream; + int size; + { + extern char call_used_regs[]; + extern int may_call_alloca; + + int fsize = ((size) + 1) & ~1; + int nregs, regno, i, j, k, adjust_fp; + + int via_ac; + + fprintf (stream, "\n\t; /*function epilogue */\n"); + + if (frame_pointer_needed) + { + /* hope this is safe - m68k does it also .... */ + regs_ever_live[FRAME_POINTER_REGNUM] = 0; + + for (i =7, j = 0 ; i >= 0 ; i--) + if (regs_ever_live[i] && ! call_used_regs[i]) + j++; + + /* remember # of pushed bytes for CPU regs */ + k = 2*j; + + for (i =7 ; i >= 0 ; i--) + if (regs_ever_live[i] && ! call_used_regs[i]) + fprintf(stream, "\tmov %d(fp), %s\n",-fsize-2*j--, reg_names[i]); + + /* get ACs */ + via_ac = FIRST_PSEUDO_REGISTER -1; + + for (i = FIRST_PSEUDO_REGISTER; i > 7; i--) + if (regs_ever_live[i] && ! call_used_regs[i]) + { + via_ac = i; + k += 8; + } + + for (i = FIRST_PSEUDO_REGISTER; i > 7; i--) + { + if (LOAD_FPU_REG_P(i) + && regs_ever_live[i] + && ! call_used_regs[i]) + { + fprintf(stream, "\tfldd %d(fp), %s\n", -fsize-k, reg_names[i]); + k -= 8; + } + + if (NO_LOAD_FPU_REG_P(i) + && regs_ever_live[i] + && ! call_used_regs[i]) + { + if (! LOAD_FPU_REG_P(via_ac)) + abort(); + + fprintf(stream, "\tfldd %d(fp), %s\n", -fsize-k, reg_names[via_ac]); + fprintf(stream, "\tfstd %s, %s\n", reg_names[via_ac], reg_names[i]); + k -= 8; + } + } + + fprintf(stream, "\tmov fp, sp\n"); + fprintf (stream, "\tmov (sp)+, fp\n"); + } + else + { + via_ac = FIRST_PSEUDO_REGISTER -1; + + /* get ACs */ + for (i = FIRST_PSEUDO_REGISTER; i > 7; i--) + if (regs_ever_live[i] && call_used_regs[i]) + via_ac = i; + + for (i = FIRST_PSEUDO_REGISTER; i > 7; i--) + { + if (LOAD_FPU_REG_P(i) + && regs_ever_live[i] + && ! call_used_regs[i]) + fprintf(stream, "\tfldd (sp)+, %s\n", reg_names[i]); + + if (NO_LOAD_FPU_REG_P(i) + && regs_ever_live[i] + && ! call_used_regs[i]) + { + if (! LOAD_FPU_REG_P(via_ac)) + abort(); + + fprintf(stream, "\tfldd (sp)+, %s\n", reg_names[via_ac]); + fprintf(stream, "\tfstd %s, %s\n", reg_names[via_ac], reg_names[i]); + } + } + + for (i=7; i >= 0; i--) + if (regs_ever_live[i] && !call_used_regs[i]) + fprintf(stream, "\tmov (sp)+, %s\n", reg_names[i]); + + if (fsize) + fprintf((stream), "\tadd $%d, sp\n", fsize); + } + + fprintf (stream, "\trts pc\n"); + fprintf (stream, "\t;/* end of epilogue*/\n\n\n"); + } + + /* Return the best assembler insn template + for moving operands[1] into operands[0] as a fullword. */ + static char * + singlemove_string (operands) + rtx *operands; + { + if (operands[1] != const0_rtx) + return "mov %1,%0"; + + return "clr %0"; + } + + + /* Output assembler code to perform a doubleword move insn + with operands OPERANDS. */ + + char * + output_move_double (operands) + rtx *operands; + { + enum { REGOP, OFFSOP, MEMOP, PUSHOP, POPOP, CNSTOP, RNDOP } optype0, optype1; + rtx latehalf[2]; + rtx addreg0 = 0, addreg1 = 0; + + /* First classify both operands. */ + + if (REG_P (operands[0])) + optype0 = REGOP; + else if (offsettable_memref_p (operands[0])) + optype0 = OFFSOP; + else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC) + optype0 = POPOP; + else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC) + optype0 = PUSHOP; + else if (GET_CODE (operands[0]) == MEM) + optype0 = MEMOP; + else + optype0 = RNDOP; + + if (REG_P (operands[1])) + optype1 = REGOP; + else if (CONSTANT_P (operands[1])) + #if 0 + || GET_CODE (operands[1]) == CONST_DOUBLE) + #endif + optype1 = CNSTOP; + else if (offsettable_memref_p (operands[1])) + optype1 = OFFSOP; + else if (GET_CODE (XEXP (operands[1], 0)) == POST_INC) + optype1 = POPOP; + else if (GET_CODE (XEXP (operands[1], 0)) == PRE_DEC) + optype1 = PUSHOP; + else if (GET_CODE (operands[1]) == MEM) + optype1 = MEMOP; + else + optype1 = RNDOP; + + /* Check for the cases that the operand constraints are not + supposed to allow to happen. Abort if we get one, + because generating code for these cases is painful. */ + + if (optype0 == RNDOP || optype1 == RNDOP) + abort (); + + /* If one operand is decrementing and one is incrementing + decrement the former register explicitly + and change that operand into ordinary indexing. */ + + if (optype0 == PUSHOP && optype1 == POPOP) + { + operands[0] = XEXP (XEXP (operands[0], 0), 0); + output_asm_insn ("sub $4,%0", operands); + operands[0] = gen_rtx (MEM, SImode, operands[0]); + optype0 = OFFSOP; + } + if (optype0 == POPOP && optype1 == PUSHOP) + { + operands[1] = XEXP (XEXP (operands[1], 0), 0); + output_asm_insn ("sub $4,%1", operands); + operands[1] = gen_rtx (MEM, SImode, operands[1]); + optype1 = OFFSOP; + } + + /* If an operand is an unoffsettable memory ref, find a register + we can increment temporarily to make it refer to the second word. */ + + if (optype0 == MEMOP) + addreg0 = find_addr_reg (XEXP (operands[0], 0)); + + if (optype1 == MEMOP) + addreg1 = find_addr_reg (XEXP (operands[1], 0)); + + /* Ok, we can do one word at a time. + Normally we do the low-numbered word first, + but if either operand is autodecrementing then we + do the high-numbered word first. + + In either case, set up in LATEHALF the operands to use + for the high-numbered word and in some cases alter the + operands in OPERANDS to be suitable for the low-numbered word. */ + + if (optype0 == REGOP) + latehalf[0] = gen_rtx (REG, HImode, REGNO (operands[0]) + 1); + else if (optype0 == OFFSOP) + latehalf[0] = adj_offsettable_operand (operands[0], 2); + else + latehalf[0] = operands[0]; + + if (optype1 == REGOP) + latehalf[1] = gen_rtx (REG, HImode, REGNO (operands[1]) + 1); + else if (optype1 == OFFSOP) + latehalf[1] = adj_offsettable_operand (operands[1], 2); + else if (optype1 == CNSTOP) + { + if (CONSTANT_P (operands[1])) + { + /* now the mess begins, high word is in lower word??? + + that's what ashc makes me think, but I don't remember :-( */ + latehalf[1] = gen_rtx(CONST_INT, VOIDmode, + INTVAL(operands[1])>>16); + operands[1] = gen_rtx(CONST_INT, VOIDmode, + INTVAL(operands[1])&0xff); + } + else if (GET_CODE (operands[1]) == CONST_DOUBLE) + { + /* immediate 32 bit values not allowed */ + abort(); + } + } + else + latehalf[1] = operands[1]; + + /* If insn is effectively movd N(sp),-(sp) then we will do the + high word first. We should use the adjusted operand 1 (which is N+4(sp)) + for the low word as well, to compensate for the first decrement of sp. */ + if (optype0 == PUSHOP + && REGNO (XEXP (XEXP (operands[0], 0), 0)) == STACK_POINTER_REGNUM + && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1])) + operands[1] = latehalf[1]; + + /* If one or both operands autodecrementing, + do the two words, high-numbered first. */ + + /* Likewise, the first move would clobber the source of the second one, + do them in the other order. This happens only for registers; + such overlap can't happen in memory unless the user explicitly + sets it up, and that is an undefined circumstance. */ + + if (optype0 == PUSHOP || optype1 == PUSHOP + || (optype0 == REGOP && optype1 == REGOP + && REGNO (operands[0]) == REGNO (latehalf[1]))) + { + /* Make any unoffsettable addresses point at high-numbered word. */ + if (addreg0) + output_asm_insn ("add $2,%0", &addreg0); + if (addreg1) + output_asm_insn ("add $2,%0", &addreg1); + + /* Do that word. */ + output_asm_insn (singlemove_string (latehalf), latehalf); + + /* Undo the adds we just did. */ + if (addreg0) + output_asm_insn ("sub $2,%0", &addreg0); + if (addreg1) + output_asm_insn ("sub $2,%0", &addreg1); + + /* Do low-numbered word. */ + return singlemove_string (operands); + } + + /* Normal case: do the two words, low-numbered first. */ + + output_asm_insn (singlemove_string (operands), operands); + + /* Make any unoffsettable addresses point at high-numbered word. */ + if (addreg0) + output_asm_insn ("add $2,%0", &addreg0); + if (addreg1) + output_asm_insn ("add $2,%0", &addreg1); + + /* Do that word. */ + output_asm_insn (singlemove_string (latehalf), latehalf); + + /* Undo the adds we just did. */ + if (addreg0) + output_asm_insn ("sub $2,%0", &addreg0); + if (addreg1) + output_asm_insn ("sub $2,%0", &addreg1); + + return ""; + } + /* Output assembler code to perform a quadword move insn + with operands OPERANDS. */ + + char * + output_move_quad (operands) + rtx *operands; + { + enum { REGOP, OFFSOP, MEMOP, PUSHOP, POPOP, CNSTOP, RNDOP } optype0, optype1; + rtx latehalf[2]; + rtx addreg0 = 0, addreg1 = 0; + + output_asm_insn(";; movdi/df: %1 -> %0", operands); + + if (REG_P (operands[0])) + optype0 = REGOP; + else if (offsettable_memref_p (operands[0])) + optype0 = OFFSOP; + else if (GET_CODE (XEXP (operands[0], 0)) == POST_INC) + optype0 = POPOP; + else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC) + optype0 = PUSHOP; + else if (GET_CODE (operands[0]) == MEM) + optype0 = MEMOP; + else + optype0 = RNDOP; + + if (REG_P (operands[1])) + optype1 = REGOP; + else if (CONSTANT_P (operands[1]) + || GET_CODE (operands[1]) == CONST_DOUBLE) + optype1 = CNSTOP; + else if (offsettable_memref_p (operands[1])) + optype1 = OFFSOP; + else if (GET_CODE (XEXP (operands[1], 0)) == POST_INC) + optype1 = POPOP; + else if (GET_CODE (XEXP (operands[1], 0)) == PRE_DEC) + optype1 = PUSHOP; + else if (GET_CODE (operands[1]) == MEM) + optype1 = MEMOP; + else + optype1 = RNDOP; + + /* Check for the cases that the operand constraints are not + supposed to allow to happen. Abort if we get one, + because generating code for these cases is painful. */ + + if (optype0 == RNDOP || optype1 == RNDOP) + abort (); + + /* check if we move a CPU reg to an FPU reg, or vice versa! */ + if (optype0 == REGOP && optype1 == REGOP) + /* bogus - 64 bit cannot reside in CPU! */ + if (CPU_REG_P(REGNO(operands[0])) + || CPU_REG_P (REGNO(operands[1]))) + abort(); + + if (optype0 == REGOP || optype1 == REGOP) + { + /* check for use of clrd???? + if you ever allow ac4 and ac5 (now we require secondary load) + you must check whether + you want to load into them or store from them - + then dump ac0 into $help$ movce ac4/5 to ac0, do the + store from ac0, and restore ac0 - if you can find + an unused ac[0-3], use that and you save a store and a load!*/ + + if (FPU_REG_P(REGNO(operands[0]))) + { + if (GET_CODE(operands[1]) == CONST_DOUBLE) + { + union { double d; int i[2]; } u; + u.i[0] = CONST_DOUBLE_LOW (operands[1]); + u.i[1] = CONST_DOUBLE_HIGH (operands[1]); + + if (u.d == 0.0) + return "clrd %0"; + } + + return "ldd %1, %0"; + } + + if (FPU_REG_P(REGNO(operands[1]))) + return "std %1, %0"; + } + + /* If one operand is decrementing and one is incrementing + decrement the former register explicitly + and change that operand into ordinary indexing. */ + + if (optype0 == PUSHOP && optype1 == POPOP) + { + operands[0] = XEXP (XEXP (operands[0], 0), 0); + output_asm_insn ("sub $8,%0", operands); + operands[0] = gen_rtx (MEM, DImode, operands[0]); + optype0 = OFFSOP; + } + if (optype0 == POPOP && optype1 == PUSHOP) + { + operands[1] = XEXP (XEXP (operands[1], 0), 0); + output_asm_insn ("sub $8,%1", operands); + operands[1] = gen_rtx (MEM, SImode, operands[1]); + optype1 = OFFSOP; + } + + /* If an operand is an unoffsettable memory ref, find a register + we can increment temporarily to make it refer to the second word. */ + + if (optype0 == MEMOP) + addreg0 = find_addr_reg (XEXP (operands[0], 0)); + + if (optype1 == MEMOP) + addreg1 = find_addr_reg (XEXP (operands[1], 0)); + + /* Ok, we can do one word at a time. + Normally we do the low-numbered word first, + but if either operand is autodecrementing then we + do the high-numbered word first. + + In either case, set up in LATEHALF the operands to use + for the high-numbered word and in some cases alter the + operands in OPERANDS to be suitable for the low-numbered word. */ + + if (optype0 == REGOP) + latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 2); + else if (optype0 == OFFSOP) + latehalf[0] = adj_offsettable_operand (operands[0], 4); + else + latehalf[0] = operands[0]; + + if (optype1 == REGOP) + latehalf[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 2); + else if (optype1 == OFFSOP) + latehalf[1] = adj_offsettable_operand (operands[1], 4); + else if (optype1 == CNSTOP) + { + if (GET_CODE (operands[1]) == CONST_DOUBLE) + { + /* floats only. not yet supported! + + -- compute it into PDP float format, - internally, + just use IEEE and ignore possible problems ;-) + + we might get away with it !!!! */ + + abort(); + + #ifndef HOST_WORDS_BIG_ENDIAN + latehalf[1] = gen_rtx (CONST_INT, VOIDmode, + CONST_DOUBLE_LOW (operands[1])); + operands[1] = gen_rtx (CONST_INT, VOIDmode, + CONST_DOUBLE_HIGH (operands[1])); + #else /* HOST_WORDS_BIG_ENDIAN */ + latehalf[1] = gen_rtx (CONST_INT, VOIDmode, + CONST_DOUBLE_HIGH (operands[1])); + operands[1] = gen_rtx (CONST_INT, VOIDmode, + CONST_DOUBLE_LOW (operands[1])); + #endif /* HOST_WORDS_BIG_ENDIAN */ + } + } + else + latehalf[1] = operands[1]; + + /* If insn is effectively movd N(sp),-(sp) then we will do the + high word first. We should use the adjusted operand 1 (which is N+4(sp)) + for the low word as well, to compensate for the first decrement of sp. */ + if (optype0 == PUSHOP + && REGNO (XEXP (XEXP (operands[0], 0), 0)) == STACK_POINTER_REGNUM + && reg_overlap_mentioned_p (stack_pointer_rtx, operands[1])) + operands[1] = latehalf[1]; + + /* If one or both operands autodecrementing, + do the two words, high-numbered first. */ + + /* Likewise, the first move would clobber the source of the second one, + do them in the other order. This happens only for registers; + such overlap can't happen in memory unless the user explicitly + sets it up, and that is an undefined circumstance. */ + + if (optype0 == PUSHOP || optype1 == PUSHOP + || (optype0 == REGOP && optype1 == REGOP + && REGNO (operands[0]) == REGNO (latehalf[1]))) + { + /* Make any unoffsettable addresses point at high-numbered word. */ + if (addreg0) + output_asm_insn ("add $4,%0", &addreg0); + if (addreg1) + output_asm_insn ("add $4,%0", &addreg1); + + /* Do that word. */ + output_asm_insn(output_move_double(latehalf), latehalf); + + /* Undo the adds we just did. */ + if (addreg0) + output_asm_insn ("sub $4,%0", &addreg0); + if (addreg1) + output_asm_insn ("sub $4,%0", &addreg1); + + /* Do low-numbered word. */ + return output_move_double (operands); + } + + /* Normal case: do the two words, low-numbered first. */ + + output_asm_insn (output_move_double (operands), operands); + + /* Make any unoffsettable addresses point at high-numbered word. */ + if (addreg0) + output_asm_insn ("add $4,%0", &addreg0); + if (addreg1) + output_asm_insn ("add $4,%0", &addreg1); + + /* Do that word. */ + output_asm_insn (output_move_double (latehalf), latehalf); + + /* Undo the adds we just did. */ + if (addreg0) + output_asm_insn ("sub $4,%0", &addreg0); + if (addreg1) + output_asm_insn ("sub $4,%0", &addreg1); + + return ""; + } + + + /* Return a REG that occurs in ADDR with coefficient 1. + ADDR can be effectively incremented by incrementing REG. */ + + static rtx + find_addr_reg (addr) + rtx addr; + { + while (GET_CODE (addr) == PLUS) + { + if (GET_CODE (XEXP (addr, 0)) == REG) + addr = XEXP (addr, 0); + if (GET_CODE (XEXP (addr, 1)) == REG) + addr = XEXP (addr, 1); + if (CONSTANT_P (XEXP (addr, 0))) + addr = XEXP (addr, 1); + if (CONSTANT_P (XEXP (addr, 1))) + addr = XEXP (addr, 0); + } + if (GET_CODE (addr) == REG) + return addr; + return 0; + } + + /* Output an ascii string. */ + output_ascii (file, p, size) + FILE *file; + char *p; + int size; + { + int i; + + fprintf (file, "\t.byte \""); + + for (i = 0; i < size; i++) + { + register int c = p[i]; + if (c == '\"' || c == '\\') + putc ('\\', file); + if (c >= ' ' && c < 0177) + putc (c, file); + else + { + fprintf (file, "\\%03o", c); + /* After an octal-escape, if a digit follows, + terminate one string constant and start another. + The Vax assembler fails to stop reading the escape + after three digits, so this is the only way we + can get it to parse the data properly. */ + if (i < size - 1 && p[i + 1] >= '0' && p[i + 1] <= '9') + fprintf (file, "\"\n\tstring \""); + } + } + fprintf (file, "\"\n"); + } + + + /* --- stole from out-vax, needs changes */ + + print_operand_address (file, addr) + FILE *file; + register rtx addr; + { + register rtx reg1, reg2, breg, ireg; + rtx offset; + + retry: + + switch (GET_CODE (addr)) + { + case MEM: + fprintf (file, "@"); + addr = XEXP (addr, 0); + goto retry; + + case REG: + fprintf (file, "(%s)", reg_names[REGNO (addr)]); + break; + + case PRE_DEC: + fprintf (file, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]); + break; + + case POST_INC: + fprintf (file, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]); + break; + + case PLUS: + reg1 = 0; reg2 = 0; + ireg = 0; breg = 0; + offset = 0; + if (CONSTANT_ADDRESS_P (XEXP (addr, 0)) + || GET_CODE (XEXP (addr, 0)) == MEM) + { + offset = XEXP (addr, 0); + addr = XEXP (addr, 1); + } + else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)) + || GET_CODE (XEXP (addr, 1)) == MEM) + { + offset = XEXP (addr, 1); + addr = XEXP (addr, 0); + } + if (GET_CODE (addr) != PLUS) + ; + else if (GET_CODE (XEXP (addr, 0)) == MULT) + { + reg1 = XEXP (addr, 0); + addr = XEXP (addr, 1); + } + else if (GET_CODE (XEXP (addr, 1)) == MULT) + { + reg1 = XEXP (addr, 1); + addr = XEXP (addr, 0); + } + else if (GET_CODE (XEXP (addr, 0)) == REG) + { + reg1 = XEXP (addr, 0); + addr = XEXP (addr, 1); + } + else if (GET_CODE (XEXP (addr, 1)) == REG) + { + reg1 = XEXP (addr, 1); + addr = XEXP (addr, 0); + } + if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT) + { + if (reg1 == 0) + reg1 = addr; + else + reg2 = addr; + addr = 0; + } + if (offset != 0) + { + if (addr != 0) abort (); + addr = offset; + } + if (reg1 != 0 && GET_CODE (reg1) == MULT) + { + breg = reg2; + ireg = reg1; + } + else if (reg2 != 0 && GET_CODE (reg2) == MULT) + { + breg = reg1; + ireg = reg2; + } + else if (reg2 != 0 || GET_CODE (addr) == MEM) + { + breg = reg2; + ireg = reg1; + } + else + { + breg = reg1; + ireg = reg2; + } + if (addr != 0) + output_address (addr); + if (breg != 0) + { + if (GET_CODE (breg) != REG) + abort (); + fprintf (file, "(%s)", reg_names[REGNO (breg)]); + } + if (ireg != 0) + { + if (GET_CODE (ireg) == MULT) + ireg = XEXP (ireg, 0); + if (GET_CODE (ireg) != REG) + abort (); + abort(); + fprintf (file, "[%s]", reg_names[REGNO (ireg)]); + } + break; + + default: + output_addr_const (file, addr); + } + } + + /* register move costs, indexed by regs */ + + static int move_costs[N_REG_CLASSES][N_REG_CLASSES] = + { + /* NO MUL GEN LFPU NLFPU FPU ALL */ + + /* NO */ { 0, 0, 0, 0, 0, 0, 0}, + /* MUL */ { 0, 2, 2, 10, 22, 22, 22}, + /* GEN */ { 0, 2, 2, 10, 22, 22, 22}, + /* LFPU */ { 0, 10, 10, 2, 2, 2, 10}, + /* NLFPU */ { 0, 22, 22, 2, 2, 2, 22}, + /* FPU */ { 0, 22, 22, 2, 2, 2, 22}, + /* ALL */ { 0, 22, 22, 10, 22, 22, 22} + } ; + + + /* -- note that some moves are tremendously expensive, + because they require lots of tricks! do we have to + charge the costs incurred by secondary reload class + -- as we do here with 22 -- or not ? */ + + int + register_move_cost(c1, c2) + enum reg_class c1, c2; + { + return move_costs[(int)c1][(int)c2]; + } + + char * + output_jump(pos, neg, length) + int length; + char *pos, *neg; + { + static int x = 0; + + static char buf[1000]; + + #if 0 + /* currently we don't need this, because the tstdf and cmpdf + copy the condition code immediately, and other float operations are not + yet recognized as changing the FCC - if so, then the length-cost of all + jump insns increases by one, because we have to potentially copy the + FCC! */ + if (cc_status.flags & CC_IN_FPU) + output_asm_insn("cfcc", NULL); + #endif + + switch (length) + { + case 1: + + strcpy(buf, pos); + strcat(buf, " %l0"); + + return buf; + + case 3: + + sprintf(buf, "%s JMP_%d\n\tjmp %%l0\nJMP_%d:", neg, x, x); + + x++; + + return buf; + + default: + + abort(); + } + + } + + void + notice_update_cc_on_set(exp, insn) + rtx exp; + rtx insn; + { + if (GET_CODE (SET_DEST (exp)) == CC0) + { + cc_status.flags = 0; + cc_status.value1 = SET_DEST (exp); + cc_status.value2 = SET_SRC (exp); + + /* + if (GET_MODE(SET_SRC(exp)) == DFmode) + cc_status.flags |= CC_IN_FPU; + */ + } + else if ((GET_CODE (SET_DEST (exp)) == REG + || GET_CODE (SET_DEST (exp)) == MEM) + && GET_CODE (SET_SRC (exp)) != PC + && (GET_MODE (SET_DEST(exp)) == HImode + || GET_MODE (SET_DEST(exp)) == QImode) + && (GET_CODE (SET_SRC(exp)) == PLUS + || GET_CODE (SET_SRC(exp)) == MINUS + || GET_CODE (SET_SRC(exp)) == AND + || GET_CODE (SET_SRC(exp)) == IOR + || GET_CODE (SET_SRC(exp)) == XOR + || GET_CODE (SET_SRC(exp)) == NOT + || GET_CODE (SET_SRC(exp)) == NEG + || GET_CODE (SET_SRC(exp)) == REG + || GET_CODE (SET_SRC(exp)) == MEM)) + { + cc_status.flags = 0; + cc_status.value1 = SET_SRC (exp); + cc_status.value2 = SET_DEST (exp); + + if (cc_status.value1 && GET_CODE (cc_status.value1) == REG + && cc_status.value2 + && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) + cc_status.value2 = 0; + if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM + && cc_status.value2 + && GET_CODE (cc_status.value2) == MEM) + cc_status.value2 = 0; + } + else if (GET_CODE (SET_SRC (exp)) == CALL) + { + CC_STATUS_INIT; + } + else if (GET_CODE (SET_DEST (exp)) == REG) + /* what's this ? */ + { + if ((cc_status.value1 + && reg_overlap_mentioned_p (SET_DEST (exp), cc_status.value1))) + cc_status.value1 = 0; + if ((cc_status.value2 + && reg_overlap_mentioned_p (SET_DEST (exp), cc_status.value2))) + cc_status.value2 = 0; + } + else if (SET_DEST(exp) == pc_rtx) + { + /* jump */ + } + else /* if (GET_CODE (SET_DEST (exp)) == MEM) */ + { + /* the last else is a bit paranoic, but since nearly all instructions + play with condition codes, it's reasonable! */ + + CC_STATUS_INIT; /* paranoia*/ + } + } + + + int simple_memory_operand(op, mode) + rtx op; + enum machine_mode mode; + { + rtx addr, plus0, plus1; + int offset = 0; + + /* Eliminate non-memory operations */ + if (GET_CODE (op) != MEM) + return FALSE; + + #if 0 + /* dword operations really put out 2 instructions, so eliminate them. */ + if (GET_MODE_SIZE (GET_MODE (op)) > (HAVE_64BIT_P () ? 8 : 4)) + return FALSE; + #endif + + /* Decode the address now. */ + + indirection: + + addr = XEXP (op, 0); + + switch (GET_CODE (addr)) + { + case REG: + /* (R0) - no extra cost */ + return 1; + + case PRE_DEC: + case POST_INC: + /* -(R0), (R0)+ - cheap! */ + return 0; + + case MEM: + /* cheap - is encoded in addressing mode info! + + -- except for @(R0), which has to be @0(R0) !!! */ + + if (GET_CODE (XEXP (addr, 0)) == REG) + return 0; + + op=addr; + goto indirection; + + case CONST_INT: + case LABEL_REF: + case CONST: + case SYMBOL_REF: + /* @#address - extra cost */ + return 0; + + case PLUS: + /* X(R0) - extra cost */ + return 0; + } + + return FALSE; + } + + + /* + * output a block move: + * + * operands[0] ... to + * operands[1] ... from + * operands[2] ... length + * operands[3] ... alignment + * operands[4] ... scratch register + */ + + + char * + output_block_move(operands) + rtx *operands; + { + static int count = 0; + char buf[200]; + + if (GET_CODE(operands[2]) == CONST_INT + && TARGET_TIME) + { + if (INTVAL(operands[2]) < 16 + && INTVAL(operands[3]) == 1) + { + register int i; + + for (i = 1; i <= INTVAL(operands[2]); i++) + output_asm_insn("movb (%1)+, (%0)+", operands); + + return ""; + } + else if (INTVAL(operands[2]) < 32) + { + register int i; + + for (i = 1; i <= INTVAL(operands[2])/2; i++) + output_asm_insn("mov (%1)+, (%0)+", operands); + + /* may I assume that moved quantity is + multiple of alignment ??? + + I HOPE SO ! + */ + + return ""; + } + + + /* can do other clever things, maybe... */ + } + + if (CONSTANT_P(operands[2]) ) + { + /* just move count to scratch */ + output_asm_insn("mov %2, %4", operands); + } + else + { + /* just clobber the register */ + operands[4] = operands[2]; + } + + + /* switch over alignment */ + switch (INTVAL(operands[3])) + { + case 1: + + /* + x: + movb (%1)+, (%0)+ + + if (TARGET_45) + sob %4,x + else + dec %4 + bgt x + + */ + + sprintf(buf, "\nmovestrhi%d:", count); + output_asm_insn(buf, NULL); + + output_asm_insn("movb (%1)+, (%0)+", operands); + + if (TARGET_45) + { + sprintf(buf, "sob %%4, movestrhi%d", count); + output_asm_insn(buf, operands); + } + else + { + output_asm_insn("dec %4", operands); + + sprintf(buf, "bgt movestrhi%d", count); + output_asm_insn(buf, NULL); + } + + count ++; + break; + + case 2: + + /* + asr %4 + + x: + + mov (%1)+, (%0)+ + + if (TARGET_45) + sob %4, x + else + dec %4 + bgt x + */ + + generate_compact_code: + + output_asm_insn("asr %4", operands); + + sprintf(buf, "\nmovestrhi%d:", count); + output_asm_insn(buf, NULL); + + output_asm_insn("mov (%1)+, (%0)+", operands); + + if (TARGET_45) + { + sprintf(buf, "sob %%4, movestrhi%d", count); + output_asm_insn(buf, operands); + } + else + { + output_asm_insn("dec %4", operands); + + sprintf(buf, "bgt movestrhi%d", count); + output_asm_insn(buf, NULL); + } + + count ++; + break; + + case 4: + + /* + + asr %4 + asr %4 + + x: + + mov (%1)+, (%0)+ + mov (%1)+, (%0)+ + + if (TARGET_45) + sob %4, x + else + dec %4 + bgt x + */ + + if (TARGET_SPACE) + goto generate_compact_code; + + output_asm_insn("asr %4", operands); + output_asm_insn("asr %4", operands); + + sprintf(buf, "\nmovestrhi%d:", count); + output_asm_insn(buf, NULL); + + output_asm_insn("mov (%1)+, (%0)+", operands); + output_asm_insn("mov (%1)+, (%0)+", operands); + + if (TARGET_45) + { + sprintf(buf, "sob %%4, movestrhi%d", count); + output_asm_insn(buf, operands); + } + else + { + output_asm_insn("dec %4", operands); + + sprintf(buf, "bgt movestrhi%d", count); + output_asm_insn(buf, NULL); + } + + count ++; + break; + + default: + + /* + + asr %4 + asr %4 + asr %4 + + x: + + mov (%1)+, (%0)+ + mov (%1)+, (%0)+ + mov (%1)+, (%0)+ + mov (%1)+, (%0)+ + + if (TARGET_45) + sob %4, x + else + dec %4 + bgt x + */ + + + if (TARGET_SPACE) + goto generate_compact_code; + + output_asm_insn("asr %4", operands); + output_asm_insn("asr %4", operands); + output_asm_insn("asr %4", operands); + + sprintf(buf, "\nmovestrhi%d:", count); + output_asm_insn(buf, NULL); + + output_asm_insn("mov (%1)+, (%0)+", operands); + output_asm_insn("mov (%1)+, (%0)+", operands); + output_asm_insn("mov (%1)+, (%0)+", operands); + output_asm_insn("mov (%1)+, (%0)+", operands); + + if (TARGET_45) + { + sprintf(buf, "sob %%4, movestrhi%d", count); + output_asm_insn(buf, operands); + } + else + { + output_asm_insn("dec %4", operands); + + sprintf(buf, "bgt movestrhi%d", count); + output_asm_insn(buf, NULL); + } + + count ++; + break; + + ; + + } + + return ""; + } + + /* for future use */ + int + comparison_operator_index(op) + rtx op; + { + switch (GET_CODE(op)) + { + case NE: + return 0; + + case EQ: + return 1; + + case GE: + return 2; + + case GT: + return 3; + + case LE: + return 4; + + case LT: + return 5; + + case GEU: + return 6; + + case GTU: + return 7; + + case LEU: + return 8; + + case LTU: + return 9; + + default: + return -1; + } + } + + /* tests whether the rtx is a comparison operator */ + int + comp_operator (op, mode) + rtx op; + enum machine_mode mode; + { + return comparison_operator_index(op) >= 0; + } + + + int + legitimate_address_p (mode, address) + enum machine_mode mode; + rtx address; + { + /* #define REG_OK_STRICT */ + GO_IF_LEGITIMATE_ADDRESS(mode, address, win); + + return 0; + + win: + return 1; + + /* #undef REG_OK_STRICT */ + } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pdp11/pdp11.h gcc-2.6.1/config/pdp11/pdp11.h *** gcc-2.6.0/config/pdp11/pdp11.h --- gcc-2.6.1/config/pdp11/pdp11.h Mon Oct 31 08:00:01 1994 *************** *** 0 **** --- 1,1398 ---- + /* Definitions of target machine for GNU compiler, for the pdp-11 + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at). + + 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 1, 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. */ + + + /* declarations */ + char *output_jump(); + char *output_move_double(); + char *output_move_quad(); + char *output_block_move(); + + /* check whther load_fpu_reg or not */ + #define LOAD_FPU_REG_P(x) ((x)>=8 && (x)<=11) + #define NO_LOAD_FPU_REG_P(x) ((x)==12 || (x)==13) + #define FPU_REG_P(x) (LOAD_FPU_REG_P(x) || NO_LOAD_FPU_REG_P(x)) + #define CPU_REG_P(x) ((x)<8) + + /* Names to predefine in the preprocessor for this target machine. */ + + #define CPP_PREDEFINES "-Dpdp11" + + /* Print subsidiary information on the compiler version in use. */ + #define TARGET_VERSION fprintf (stderr, " (pdp11)"); + + + /* Generate DBX debugging information. */ + + /* #define DBX_DEBUGGING_INFO */ + + /* Run-time compilation parameters selecting different hardware subsets. + */ + + extern int target_flags; + + /* Macro to define tables used to set the flags. + This is a list in braces of pairs in braces, + each pair being { "NAME", VALUE } + where VALUE is the bits to set or minus the bits to clear. + An empty string NAME is used to identify the default VALUE. */ + + #define TARGET_SWITCHES \ + { { "fpu", 1}, \ + { "soft-float", -1}, \ + /* return float result in ac0 */\ + { "ac0", 2}, \ + { "no-ac0", -2}, \ + /* is 11/40 */ \ + { "40", 4}, \ + { "no-40", -4}, \ + /* is 11/45 */ \ + { "45", 8}, \ + { "no-45", -8}, \ + /* is 11/10 */ \ + { "10", -12}, \ + /* use movstrhi for bcopy */ \ + { "bcopy", 16}, \ + { "bcopy-builtin", -16}, \ + /* use 32 bit for int */ \ + { "int32", 32}, \ + { "no-int16", 32}, \ + { "int16", -32}, \ + { "no-int32", -32}, \ + /* use 32 bit for float */ \ + { "float32", 64}, \ + { "no-float64", 64}, \ + { "float64", -64}, \ + { "no-float32", -64}, \ + /* allow abshi pattern? - can trigger "optimizations" which make code SLOW! */\ + { "abshi", 128}, \ + { "no-abshi", -128}, \ + /* is branching expensive - on a PDP, it's actually really cheap */ \ + /* this is just to play aroound and check what code gcc generates */ \ + { "branch-expensive", 256}, \ + { "branch-cheap", -256}, \ + /* optimize for space instead of time - just in a couple of places */ \ + { "space", 512 }, \ + { "time", -512 }, \ + /* split instruction and data memory? */ \ + { "split", 1024 }, \ + { "no-split", -1024 }, \ + /* default */ \ + { "", TARGET_DEFAULT} \ + } + + #define TARGET_DEFAULT (1 | 8 | 128) + + #define TARGET_FPU (target_flags & 1) + #define TARGET_SOFT_FLOAT (!TARGET_FPU) + + #define TARGET_AC0 ((target_flags & 2) && TARGET_FPU) + #define TARGET_NO_AC0 (! TARGET_AC0) + + #define TARGET_45 (target_flags & 8) + #define TARGET_40_PLUS ((target_flags & 4) || (target_flags)) + #define TARGET_10 (! TARGET_40_PLUS) + + #define TARGET_BCOPY_BUILTIN (! (target_flags & 16)) + + #define TARGET_INT16 (! TARGET_INT32) + #define TARGET_INT32 (target_flags & 32) + + #define TARGET_FLOAT32 (target_flags & 64) + #define TARGET_FLOAT64 (! TARGET_FLOAT32) + + #define TARGET_ABSHI_BUILTIN (target_flags & 128) + + #define TARGET_BRANCH_EXPENSIVE (target_flags & 256) + #define TARGET_BRANCH_CHEAP (!TARGET_BRANCH_EXPENSIVE) + + #define TARGET_SPACE (target_flags & 512) + #define TARGET_TIME (! TARGET_SPACE) + + #define TARGET_SPLIT (target_flags & 1024) + #define TARGET_NOSPLIT (! TARGET_SPLIT) + + + /* TYPE SIZES */ + #define CHAR_TYPE_SIZE 8 + #define SHORT_TYPE_SIZE 16 + #define INT_TYPE_SIZE (TARGET_INT16 ? 16 : 32) + #define LONG_TYPE_SIZE 32 + #define LONG_LONG_TYPE_SIZE 64 + + /* if we set FLOAT_TYPE_SIZE to 32, we could have the benefit + of saving core for huge arrays - the definitions are + already in md - but floats can never reside in + an FPU register - we keep the FPU in double float mode + all the time !! */ + #define FLOAT_TYPE_SIZE (TARGET_FLOAT32 ? 32 : 64) + #define DOUBLE_TYPE_SIZE 64 + #define LONG_DOUBLE_TYPE_SIZE 64 + + /* machine types from ansi */ + #define SIZE_TYPE "unsigned int" /* definition of size_t */ + + /* is used in cexp.y - we don't have target_flags there, + so just give default definition + + hope it does not come back to haunt us! */ + #define WCHAR_TYPE "int" /* or long int???? */ + #define WCHAR_TYPE_SIZE 16 + + #define PTRDIFF_TYPE "int" + + /* target machine storage layout */ + + /* Define this if most significant bit is lowest numbered + in instructions that operate on numbered bit-fields. */ + #define BITS_BIG_ENDIAN 0 + + /* Define this if most significant byte of a word is the lowest numbered. */ + #define BYTES_BIG_ENDIAN 0 + + /* Define this if most significant word of a multiword number is numbered. */ + #define WORDS_BIG_ENDIAN 1 + + /* number of bits in an addressible storage unit */ + #define BITS_PER_UNIT 8 + + /* Width in bits of a "word", which is the contents of a machine register. + Note that this is not necessarily the width of data type `int'; + if using 16-bit ints on a 68000, this would still be 32. + But on a machine with 16-bit registers, this would be 16. */ + /* This is a machine with 16-bit registers */ + #define BITS_PER_WORD 16 + + /* Width of a word, in units (bytes). + + UNITS OR BYTES - seems like units */ + #define UNITS_PER_WORD 2 + + /* Maximum sized of reasonable data type + DImode or Dfmode ...*/ + #define MAX_FIXED_MODE_SIZE 64 + + /* Width in bits of a pointer. + See also the macro `Pmode' defined below. */ + #define POINTER_SIZE 16 + + /* Allocation boundary (in *bits*) for storing pointers in memory. */ + #define POINTER_BOUNDARY 16 + + /* Allocation boundary (in *bits*) for storing arguments in argument list. */ + #define PARM_BOUNDARY 16 + + /* Allocation boundary (in *bits*) for the code of a function. */ + #define FUNCTION_BOUNDARY 16 + + /* Alignment of field after `int : 0' in a structure. */ + #define EMPTY_FIELD_BOUNDARY 16 + + /* No data type wants to be aligned rounder than this. */ + #define BIGGEST_ALIGNMENT 16 + + /* Define this if move instructions will actually fail to work + when given unaligned data. */ + #define STRICT_ALIGNMENT 1 + + /* Standard register usage. */ + + /* Number of actual hardware registers. + The hardware registers are assigned numbers for the compiler + from 0 to just below FIRST_PSEUDO_REGISTER. + All registers that the compiler knows about must be given numbers, + even those that are not normally considered general registers. + + we have 8 integer registers, plus 6 float + (don't use scratch float !) */ + + #define FIRST_PSEUDO_REGISTER 14 + + /* 1 for registers that have pervasive standard uses + and are not available for the register allocator. + + On the pdp, these are: + Reg 7 = pc; + reg 6 = sp; + reg 5 = fp; not necessarily! + */ + + /* don't let them touch fp regs for the time being !*/ + + #define FIXED_REGISTERS \ + {0, 0, 0, 0, 0, 0, 1, 1, \ + 0, 0, 0, 0, 0, 0 } + + + + /* 1 for registers not available across function calls. + These must include the FIXED_REGISTERS and also any + registers that can be used without being saved. + The latter must include the registers where values are returned + and the register where structure-value addresses are passed. + Aside from that, you can include as many other registers as you like. */ + + /* don't know about fp */ + #define CALL_USED_REGISTERS \ + {1, 1, 0, 0, 0, 0, 1, 1, \ + 0, 0, 0, 0, 0, 0 } + + + /* Make sure everything's fine if we *don't* have an FPU. + This assumes that putting a register in fixed_regs will keep the + compiler's mitts completely off it. We don't bother to zero it out + of register classes. + */ + #define CONDITIONAL_REGISTER_USAGE \ + { \ + int i; \ + HARD_REG_SET x; \ + if (!TARGET_FPU) \ + { \ + COPY_HARD_REG_SET (x, reg_class_contents[(int)FPU_REGS]); \ + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++ ) \ + if (TEST_HARD_REG_BIT (x, i)) \ + fixed_regs[i] = call_used_regs[i] = 1; \ + } \ + \ + if (TARGET_AC0) \ + call_used_regs[8] = 1; \ + } + + /* Return number of consecutive hard regs needed starting at reg REGNO + to hold something of mode MODE. + This is ordinarily the length in words of a value of mode MODE + but can be less for certain modes in special long registers. + */ + + #define HARD_REGNO_NREGS(REGNO, MODE) \ + ((REGNO < 8)? \ + ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) \ + :1) + + + /* Value is 1 if hard register REGNO can hold a value of machine-mode MODE. + On the pdp, the cpu registers can hold any mode - check alignment + + FPU can only hold DF - simplifies life! + */ + #define HARD_REGNO_MODE_OK(REGNO, MODE) \ + ((REGNO < 8)? \ + ((GET_MODE_BITSIZE(MODE) <= 16) \ + || (GET_MODE_BITSIZE(MODE) == 32 && !(REGNO & 1))) \ + :(MODE) == DFmode) + + + /* Value is 1 if it is a good idea to tie two pseudo registers + when one has mode MODE1 and one has mode MODE2. + If HARD_REGNO_MODE_OK could produce different values for MODE1 and MODE2, + for any hard reg, then this must be 0 for correct output. */ + #define MODES_TIEABLE_P(MODE1, MODE2) 0 + + /* Specify the registers used for certain standard purposes. + The values of these macros are register numbers. */ + + /* the pdp11 pc overloaded on a register that the compiler knows about. */ + #define PC_REGNUM 7 + + /* Register to use for pushing function arguments. */ + #define STACK_POINTER_REGNUM 6 + + /* Base register for access to local variables of the function. */ + #define FRAME_POINTER_REGNUM 5 + + /* Value should be nonzero if functions must have frame pointers. + Zero means the frame pointer need not be set up (and parms + may be accessed via the stack pointer) in functions that seem suitable. + This is computed in `reload', in reload1.c. + */ + + #define FRAME_POINTER_REQUIRED 0 + + /* Base register for access to arguments of the function. */ + #define ARG_POINTER_REGNUM 5 + + /* Register in which static-chain is passed to a function. */ + /* ??? - i don't want to give up a reg for this! */ + #define STATIC_CHAIN_REGNUM 4 + + /* Register in which address to store a structure value + is passed to a function. + let's make it an invisible first argument!!! */ + + #define STRUCT_VALUE 0 + + + /* Define the classes of registers for register constraints in the + machine description. Also define ranges of constants. + + One of the classes must always be named ALL_REGS and include all hard regs. + If there is more than one class, another class must be named NO_REGS + and contain no registers. + + The name GENERAL_REGS must be the name of a class (or an alias for + another name such as ALL_REGS). This is the class of registers + that is allowed by "g" or "r" in a register constraint. + Also, registers outside this class are allocated only when + instructions express preferences for them. + + The classes must be numbered in nondecreasing order; that is, + a larger-numbered class must never be contained completely + in a smaller-numbered class. + + For any two classes, it is very desirable that there be another + class that represents their union. */ + + /* The pdp has a couple of classes: + + MUL_REGS are used for odd numbered regs, to use in 16 bit multiplication + (even numbered do 32 bit multiply) + LMUL_REGS long multiply registers (even numbered regs ) + (don't need them, all 32 bit regs are even numbered!) + GENERAL_REGS is all cpu + LOAD_FPU_REGS is the first four cpu regs, they are easier to load + NO_LOAD_FPU_REGS is ac4 and ac5, currently - difficult to load them + FPU_REGS is all fpu regs + */ + + enum reg_class { NO_REGS, MUL_REGS, GENERAL_REGS, LOAD_FPU_REGS, NO_LOAD_FPU_REGS, FPU_REGS, ALL_REGS, LIM_REG_CLASSES }; + + #define N_REG_CLASSES (int) LIM_REG_CLASSES + + /* have to allow this till cmpsi/tstsi are fixed in a better way !! */ + #define SMALL_REGISTER_CLASSES + + /* Since GENERAL_REGS is the same class as ALL_REGS, + don't give it a different class number; just make it an alias. */ + + /* #define GENERAL_REGS ALL_REGS */ + + /* Give names of register classes as strings for dump file. */ + + #define REG_CLASS_NAMES {"NO_REGS", "MUL_REGS", "GENERAL_REGS", "LOAD_FPU_REGS", "NO_LOAD_FPU_REGS", "FPU_REGS", "ALL_REGS" } + + /* Define which registers fit in which classes. + This is an initializer for a vector of HARD_REG_SET + of length N_REG_CLASSES. */ + + #define REG_CLASS_CONTENTS {0, 0x00aa, 0x00ff, 0x0f00, 0x3000, 0x3f00, 0x3fff} + + /* The same information, inverted: + Return the class number of the smallest class containing + reg number REGNO. This could be a conditional expression + or could index an array. */ + + #define REGNO_REG_CLASS(REGNO) \ + ((REGNO)>=8?((REGNO)<=11?LOAD_FPU_REGS:NO_LOAD_FPU_REGS):((REGNO&1)?MUL_REGS:GENERAL_REGS)) + + + /* The class value for index registers, and the one for base regs. */ + #define INDEX_REG_CLASS GENERAL_REGS + #define BASE_REG_CLASS GENERAL_REGS + + /* Get reg_class from a letter such as appears in the machine description. */ + + #define REG_CLASS_FROM_LETTER(C) \ + ((C) == 'f' ? FPU_REGS : \ + ((C) == 'd' ? MUL_REGS : \ + ((C) == 'a' ? LOAD_FPU_REGS : NO_REGS))) + + + /* The letters I, J, K, L and M in a register constraint string + can be used to stand for particular ranges of immediate operands. + This macro defines what the ranges are. + C is the letter, and VALUE is a constant value. + Return 1 if VALUE is in the range specified by C. + + I bits 31-16 0000 + J bits 15-00 0000 + K completely random 32 bit + L,M,N -1,1,0 respectively + O where doing shifts in sequence is faster than + one big shift + */ + + #define CONST_OK_FOR_LETTER_P(VALUE, C) \ + ((C) == 'I' ? ((VALUE) & 0xffff0000) == 0 \ + : (C) == 'J' ? ((VALUE) & 0x0000ffff) == 0 \ + : (C) == 'K' ? (((VALUE) & 0xffff0000) != 0 \ + && ((VALUE) & 0x0000ffff) != 0) \ + : (C) == 'L' ? ((VALUE) == 1) \ + : (C) == 'M' ? ((VALUE) == -1) \ + : (C) == 'N' ? ((VALUE) == 0) \ + : (C) == 'O' ? (abs(VALUE) >1 && abs(VALUE) <= 4) \ + : 0) + + /* Similar, but for floating constants, and defining letters G and H. + Here VALUE is the CONST_DOUBLE rtx itself. */ + + #define CONST_DOUBLE_OK_FOR_LETTER_P(VALUE, C) \ + ((C) == 'G' && XINT (VALUE, 0) == 0 && XINT (VALUE, 1) == 0) + + + /* Letters in the range `Q' through `U' may be defined in a + machine-dependent fashion to stand for arbitrary operand types. + The machine description macro `EXTRA_CONSTRAINT' is passed the + operand as its first argument and the constraint letter as its + second operand. + + `Q' is for memory refereces using take more than 1 instruction. + `R' is for memory refereces which take 1 word for the instruction. */ + + #define EXTRA_CONSTRAINT(OP,CODE) \ + ((GET_CODE (OP) != MEM) ? 0 \ + : !legitimate_address_p (GET_MODE (OP), XEXP (OP, 0)) ? 0 \ + : ((CODE) == 'Q') ? !simple_memory_operand (OP, GET_MODE (OP)) \ + : ((CODE) == 'R') ? simple_memory_operand (OP, GET_MODE (OP)) \ + : 0) + + /* Given an rtx X being reloaded into a reg required to be + in class CLASS, return the class of reg to actually use. + In general this is just CLASS; but on some machines + in some cases it is preferable to use a more restrictive class. + + loading is easier into LOAD_FPU_REGS than FPU_REGS! */ + + #define PREFERRED_RELOAD_CLASS(X,CLASS) \ + (((CLASS) != FPU_REGS)?(CLASS):LOAD_FPU_REGS) + + #define SECONDARY_RELOAD_CLASS(CLASS,MODE,x) \ + (((CLASS) == NO_LOAD_FPU_REGS && !(REG_P(x) && LOAD_FPU_REG_P(REGNO(x))))?LOAD_FPU_REGS:NO_REGS) + + /* Return the maximum number of consecutive registers + needed to represent mode MODE in a register of class CLASS. */ + #define CLASS_MAX_NREGS(CLASS, MODE) \ + ((CLASS == GENERAL_REGS || CLASS == MUL_REGS)? \ + ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD): \ + 1 \ + ) + + + /* Stack layout; function entry, exit and calling. */ + + /* Define this if pushing a word on the stack + makes the stack pointer a smaller address. */ + #define STACK_GROWS_DOWNWARD + + /* Define this if the nominal address of the stack frame + is at the high-address end of the local variables; + that is, each additional local variable allocated + goes at a more negative offset in the frame. + */ + #define FRAME_GROWS_DOWNWARD + + /* Offset within stack frame to start allocating local variables at. + If FRAME_GROWS_DOWNWARD, this is the offset to the END of the + first local allocated. Otherwise, it is the offset to the BEGINNING + of the first local allocated. */ + #define STARTING_FRAME_OFFSET 0 + + /* If we generate an insn to push BYTES bytes, + this says how many the stack pointer really advances by. + On the pdp11, the stack is on an even boundary */ + #define PUSH_ROUNDING(BYTES) ((BYTES + 1) & ~1) + + /* current_first_parm_offset stores the # of registers pushed on the + stack */ + extern int current_first_parm_offset; + + /* Offset of first parameter from the argument pointer register value. + For the pdp11, this is non-zero to account for the return address. + 1 - return address + 2 - frame pointer (always saved, even when not used!!!!) + -- chnage some day !!!:q! + + */ + #define FIRST_PARM_OFFSET(FNDECL) 4 + + /* Value is 1 if returning from a function call automatically + pops the arguments described by the number-of-args field in the call. + FUNTYPE is the data type of the function (as a tree), + or for a library call it is an identifier node for the subroutine name. */ + + #define RETURN_POPS_ARGS(FUNTYPE,SIZE) 0 + + /* Define how to find the value returned by a function. + VALTYPE is the data type of the value (as a tree). + If the precise function being called is known, FUNC is its FUNCTION_DECL; + otherwise, FUNC is 0. */ + #define BASE_RETURN_VALUE_REG(MODE) \ + ((MODE) == DFmode ? 8 : 0) + + /* On the pdp11 the value is found in R0 (or ac0??? + not without FPU!!!! ) */ + + #define FUNCTION_VALUE(VALTYPE, FUNC) \ + gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE))) + + /* and the called function leaves it in the first register. + Difference only on machines with register windows. */ + + #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) \ + gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE))) + + /* Define how to find the value returned by a library function + assuming the value has mode MODE. */ + + #define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, BASE_RETURN_VALUE_REG(MODE)) + + /* 1 if N is a possible register number for a function value + as seen by the caller. + On the pdp, the first "output" reg is the only register thus used. + + maybe ac0 ? - as option someday! */ + + #define FUNCTION_VALUE_REGNO_P(N) (((N) == 0) || (TARGET_AC0 && (N) == 8)) + + /* should probably return DImode and DFmode in memory,lest + we fill up all regs! + + have to, else we crash - exceptio: maybe return result in + ac0 if DFmode and FPU present - compatibility problem with + libraries for non-floating point ... + */ + + #define RETURN_IN_MEMORY(TYPE) \ + (TYPE_MODE(TYPE) == DImode || (TYPE_MODE(TYPE) == DFmode && ! TARGET_AC0)) + + + /* 1 if N is a possible register number for function argument passing. + - not used on pdp */ + + #define FUNCTION_ARG_REGNO_P(N) 0 + + /* Define a data type for recording info about an argument list + during the scan of that argument list. This data type should + hold all necessary information about the function itself + and about the args processed so far, enough to enable macros + such as FUNCTION_ARG to determine where the next arg should go. + + */ + + #define CUMULATIVE_ARGS int + + /* Initialize a variable CUM of type CUMULATIVE_ARGS + for a call to a function whose data type is FNTYPE. + For a library call, FNTYPE is 0. + + ...., the offset normally starts at 0, but starts at 1 word + when the function gets a structure-value-address as an + invisible first argument. */ + + #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME) \ + ((CUM) = 0) + + /* Update the data in CUM to advance over an argument + of mode MODE and data type TYPE. + (TYPE is null for libcalls where that information may not be available.) + + */ + + + #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ + ((CUM) += ((MODE) != BLKmode \ + ? (GET_MODE_SIZE (MODE)) \ + : (int_size_in_bytes (TYPE)))) + + /* Determine where to put an argument to a function. + Value is zero to push the argument on the stack, + or a hard register in which to store the argument. + + MODE is the argument's machine mode. + TYPE is the data type of the argument (as a tree). + This is null for libcalls where that information may + not be available. + CUM is a variable of type CUMULATIVE_ARGS which gives info about + the preceding args and about the function being called. + NAMED is nonzero if this argument is a named parameter + (otherwise it is an extra parameter matching an ellipsis). */ + + #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) 0 + + /* Define where a function finds its arguments. + This would be different from FUNCTION_ARG if we had register windows. */ + /* + #define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ + FUNCTION_ARG (CUM, MODE, TYPE, NAMED) + */ + + /* For an arg passed partly in registers and partly in memory, + this is the number of registers used. + For args passed entirely in registers or entirely in memory, zero. */ + + #define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) 0 + + /* This macro generates the assembly code for function entry. */ + #define FUNCTION_PROLOGUE(FILE, SIZE) \ + output_function_prologue(FILE, SIZE); + + /* Output assembler code to FILE to increment profiler label # LABELNO + for profiling a function entry. */ + + #define FUNCTION_PROFILER(FILE, LABELNO) \ + abort (); + + /* EXIT_IGNORE_STACK should be nonzero if, when returning from a function, + the stack pointer does not matter. The value is tested only in + functions that have frame pointers. + No definition is equivalent to always zero. */ + + extern int may_call_alloca; + extern int current_function_pretend_args_size; + + #define EXIT_IGNORE_STACK 1 + + /* This macro generates the assembly code for function exit, + on machines that need it. If FUNCTION_EPILOGUE is not defined + then individual return instructions are generated for each + return statement. Args are same as for FUNCTION_PROLOGUE. + */ + + #define FUNCTION_EPILOGUE(FILE, SIZE) \ + output_function_epilogue(FILE, SIZE); + + #define INITIAL_FRAME_POINTER_OFFSET(DEPTH_VAR) \ + { \ + int offset, regno; \ + offset = get_frame_size(); \ + for (regno = 0; regno < 8; regno++) \ + if (regs_ever_live[regno] && ! call_used_regs[regno]) \ + offset += 2; \ + for (regno = 8; regno < 14; regno++) \ + if (regs_ever_live[regno] && ! call_used_regs[regno]) \ + offset += 8; \ + /* offset -= 2; no fp on stack frame */ \ + (DEPTH_VAR) = offset; \ + } + + + /* Addressing modes, and classification of registers for them. */ + + #define HAVE_POST_INCREMENT + /* #define HAVE_POST_DECREMENT */ + + #define HAVE_PRE_DECREMENT + /* #define HAVE_PRE_INCREMENT */ + + /* Macros to check register numbers against specific register classes. */ + + /* These assume that REGNO is a hard or pseudo reg number. + They give nonzero only if REGNO is a hard reg of the suitable class + or a pseudo reg currently allocated to a suitable hard reg. + Since they use reg_renumber, they are safe only once reg_renumber + has been allocated, which happens in local-alloc.c. */ + + #define REGNO_OK_FOR_INDEX_P(REGNO) \ + ((REGNO) < 8 || (unsigned) reg_renumber[REGNO] < 8) + #define REGNO_OK_FOR_BASE_P(REGNO) \ + ((REGNO) < 8 || (unsigned) reg_renumber[REGNO] < 8) + + /* Now macros that check whether X is a register and also, + strictly, whether it is in a specified class. + */ + + + + /* Maximum number of registers that can appear in a valid memory address. */ + + #define MAX_REGS_PER_ADDRESS 2 + + /* Recognize any constant value that is a valid address. */ + + #define CONSTANT_ADDRESS_P(X) CONSTANT_P (X) + + /* Nonzero if the constant value X is a legitimate general operand. + It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE. */ + + #define LEGITIMATE_CONSTANT_P(X) (1) + + /* The macros REG_OK_FOR..._P assume that the arg is a REG rtx + and check its validity for a certain class. + We have two alternate definitions for each of them. + The usual definition accepts all pseudo regs; the other rejects + them unless they have been allocated suitable hard regs. + The symbol REG_OK_STRICT causes the latter definition to be used. + + Most source files want to accept pseudo regs in the hope that + they will get allocated to the class that the insn wants them to be in. + Source files for reload pass need to be strict. + After reload, it makes no difference, since pseudo regs have + been eliminated by then. */ + + #ifndef REG_OK_STRICT + + /* Nonzero if X is a hard reg that can be used as an index + or if it is a pseudo reg. */ + #define REG_OK_FOR_INDEX_P(X) (1) + /* Nonzero if X is a hard reg that can be used as a base reg + or if it is a pseudo reg. */ + #define REG_OK_FOR_BASE_P(X) (1) + + #else + + /* Nonzero if X is a hard reg that can be used as an index. */ + #define REG_OK_FOR_INDEX_P(X) REGNO_OK_FOR_INDEX_P (REGNO (X)) + /* Nonzero if X is a hard reg that can be used as a base reg. */ + #define REG_OK_FOR_BASE_P(X) REGNO_OK_FOR_BASE_P (REGNO (X)) + + #endif + + /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression + that is a valid memory address for an instruction. + The MODE argument is the machine mode for the MEM expression + that wants to use this address. + + */ + + #define GO_IF_LEGITIMATE_ADDRESS(mode, operand, ADDR) \ + { \ + rtx xfoob; \ + \ + /* accept (R0) */ \ + if (GET_CODE (operand) == REG \ + && REG_OK_FOR_BASE_P(operand)) \ + goto ADDR; \ + \ + /* accept @#address */ \ + if (CONSTANT_ADDRESS_P (operand)) \ + goto ADDR; \ + \ + /* accept X(R0) */ \ + if (GET_CODE (operand) == PLUS \ + && GET_CODE (XEXP (operand, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (operand, 0)) \ + && CONSTANT_ADDRESS_P (XEXP (operand, 1))) \ + goto ADDR; \ + \ + /* accept -(R0) */ \ + if (GET_CODE (operand) == PRE_DEC \ + && GET_CODE (XEXP (operand, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (operand, 0))) \ + goto ADDR; \ + \ + /* accept (R0)+ */ \ + if (GET_CODE (operand) == POST_INC \ + && GET_CODE (XEXP (operand, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (operand, 0))) \ + goto ADDR; \ + \ + /* handle another level of indirection ! */ \ + if (GET_CODE(operand) != MEM) \ + goto fail; \ + \ + xfoob = XEXP (operand, 0); \ + \ + /* (MEM:xx (MEM:xx ())) is not valid for SI, DI and currently */ \ + /* also forbidden for float, because we have to handle this */ \ + /* in output_move_double and/or output_move_quad() - we could */ \ + /* do it, but currently it's not worth it!!! */ \ + /* now that DFmode cannot go into CPU register file, */ \ + /* maybe I should allow float ... */ \ + /* but then I have to handle memory-to-memory moves in movdf ?? */ \ + \ + if (GET_MODE_BITSIZE(mode) > 16) \ + goto fail; \ + \ + /* accept @(R0) - which is @0(R0) */ \ + if (GET_CODE (xfoob) == REG \ + && REG_OK_FOR_BASE_P(xfoob)) \ + goto ADDR; \ + \ + /* accept @address */ \ + if (CONSTANT_ADDRESS_P (xfoob)) \ + goto ADDR; \ + \ + /* accept @X(R0) */ \ + if (GET_CODE (xfoob) == PLUS \ + && GET_CODE (XEXP (xfoob, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (xfoob, 0)) \ + && CONSTANT_ADDRESS_P (XEXP (xfoob, 1))) \ + goto ADDR; \ + \ + /* accept @-(R0) */ \ + if (GET_CODE (xfoob) == PRE_DEC \ + && GET_CODE (XEXP (xfoob, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (xfoob, 0))) \ + goto ADDR; \ + \ + /* accept @(R0)+ */ \ + if (GET_CODE (xfoob) == POST_INC \ + && GET_CODE (XEXP (xfoob, 0)) == REG \ + && REG_OK_FOR_BASE_P (XEXP (xfoob, 0))) \ + goto ADDR; \ + \ + /* anything else is illegal */ \ + fail: ; \ + } + + + /* Try machine-dependent ways of modifying an illegitimate address + to be legitimate. If we find one, return the new, valid address. + This macro is used in only one place: `memory_address' in explow.c. + + OLDX is the address as it was before break_out_memory_refs was called. + In some cases it is useful to look at this to decide what needs to be done. + + MODE and WIN are passed so that this macro can use + GO_IF_LEGITIMATE_ADDRESS. + + It is always safe for this macro to do nothing. It exists to recognize + opportunities to optimize the output. */ + + #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) {} + + + /* Go to LABEL if ADDR (a legitimate address expression) + has an effect that depends on the machine mode it is used for. + On the the pdp this is for predec/postinc */ + + #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL) \ + { if (GET_CODE (ADDR) == POST_INC || GET_CODE (ADDR) == PRE_DEC) \ + goto LABEL; \ + } + + + /* Specify the machine mode that this machine uses + for the index in the tablejump instruction. */ + #define CASE_VECTOR_MODE HImode + + /* Define this if a raw index is all that is needed for a + `tablejump' insn. */ + #define CASE_TAKES_INDEX_RAW + + /* Define this if the tablejump instruction expects the table + to contain offsets from the address of the table. + Do not define this if the table should contain absolute addresses. */ + /* #define CASE_VECTOR_PC_RELATIVE */ + + /* Specify the tree operation to be used to convert reals to integers. */ + #define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR + + /* This is the kind of divide that is easiest to do in the general case. */ + #define EASY_DIV_EXPR TRUNC_DIV_EXPR + + /* Define this as 1 if `char' should by default be signed; else as 0. */ + #define DEFAULT_SIGNED_CHAR 1 + + /* Max number of bytes we can move from memory to memory + in one reasonably fast instruction. + */ + + #define MOVE_MAX 2 + + /* Zero extension is faster if the target is known to be zero */ + /* #define SLOW_ZERO_EXTEND */ + + /* Nonzero if access to memory by byte is slow and undesirable. - + */ + #define SLOW_BYTE_ACCESS 0 + + /* Do not break .stabs pseudos into continuations. */ + #define DBX_CONTIN_LENGTH 0 + + /* Value is 1 if truncating an integer of INPREC bits to OUTPREC bits + is done just by pretending it is already truncated. */ + #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) 1 + + + /* Add any extra modes needed to represent the condition code. + + CCFPmode is used for FPU, but should we use a separate reg? */ + #define EXTRA_CC_MODES CCFPmode + + /* the name for the mode above */ + #define EXTRA_CC_NAMES "CCFPmode" + + /* Give a comparison code (EQ, NE etc) and the first operand of a COMPARE, + return the mode to be used for the comparison. For floating-point, CCFPmode + should be used. */ + + #define SELECT_CC_MODE(OP,X,Y) \ + (GET_MODE_CLASS(GET_MODE(X)) == MODE_FLOAT? CCFPmode : CCmode) + + /* We assume that the store-condition-codes instructions store 0 for false + and some other value for true. This is the value stored for true. */ + + /* #define STORE_FLAG_VALUE 1 */ + + /* Specify the machine mode that pointers have. + After generation of rtl, the compiler makes no further distinction + between pointers and any other objects of this machine mode. */ + #define Pmode HImode + + /* A function address in a call instruction + is a word address (for indexing purposes) + so give the MEM rtx a word's mode. */ + #define FUNCTION_MODE HImode + + /* Define this if addresses of constant functions + shouldn't be put through pseudo regs where they can be cse'd. + Desirable on machines where ordinary constants are expensive + but a CALL with constant address is cheap. */ + /* #define NO_FUNCTION_CSE */ + + /* Compute the cost of computing a constant rtl expression RTX + whose rtx-code is CODE. The body of this macro is a portion + of a switch statement. If the code is computed here, + return it with a return statement. Otherwise, break from the switch. + + -1, 0, 1 are cheaper for add, sub ... + */ + + #define CONST_COSTS(RTX,CODE,OUTER_CODE) \ + case CONST_INT: \ + if (INTVAL(RTX) == 0 \ + || INTVAL(RTX) == -1 \ + || INTVAL(RTX) == 1) \ + return 0; \ + case CONST: \ + case LABEL_REF: \ + case SYMBOL_REF: \ + /* twice as expensive as REG */ \ + return 2; \ + case CONST_DOUBLE: \ + /* twice (or 4 times) as expensive as 16 bit */ \ + return 4; + + /* cost of moving one register class to another */ + #define REGISTER_MOVE_COST(CLASS1, CLASS2) register_move_cost(CLASS1, CLASS2) + + /* Tell emit-rtl.c how to initialize special values on a per-function base. */ + extern int optimize; + extern struct rtx_def *cc0_reg_rtx; + + #define CC_STATUS_MDEP rtx + + #define CC_STATUS_MDEP_INIT (cc_status.mdep = 0) + + /* Tell final.c how to eliminate redundant test instructions. */ + + /* Here we define machine-dependent flags and fields in cc_status + (see `conditions.h'). */ + + #define CC_IN_FPU 04000 + + /* Do UPDATE_CC if EXP is a set, used in + NOTICE_UPDATE_CC + + floats only do compare correctly, else nullify ... + + get cc0 out soon ... + */ + + /* Store in cc_status the expressions + that the condition codes will describe + after execution of an instruction whose pattern is EXP. + Do not alter them if the instruction would not alter the cc's. */ + + #define NOTICE_UPDATE_CC(EXP, INSN) \ + { if (GET_CODE (EXP) == SET) \ + { \ + notice_update_cc_on_set(EXP, INSN); \ + } \ + else if (GET_CODE (EXP) == PARALLEL \ + && GET_CODE (XVECEXP (EXP, 0, 0)) == SET) \ + { \ + notice_update_cc_on_set(XVECEXP (EXP, 0, 0), INSN); \ + } \ + else if (GET_CODE (EXP) == CALL) \ + { /* all bets are off */ CC_STATUS_INIT; } \ + if (cc_status.value1 && GET_CODE (cc_status.value1) == REG \ + && cc_status.value2 \ + && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2)) \ + printf ("here!\n", cc_status.value2 = 0); \ + } + + /* Control the assembler format that we output. */ + + /* Output at beginning of assembler file. */ + + #if 0 + #define ASM_FILE_START(FILE) \ + ( \ + fprintf (FILE, "\t.data\n"), \ + fprintf (FILE, "$help$: . = .+8 ; space for tmp moves!\n") \ + /* do we need reg def's R0 = %0 etc ??? */ \ + ) + #else + #define ASM_FILE_START(FILE) (0) + #endif + + + /* Output to assembler file text saying following lines + may contain character constants, extra white space, comments, etc. */ + + #define ASM_APP_ON "" + + /* Output to assembler file text saying following lines + no longer contain unusual constructs. */ + + #define ASM_APP_OFF "" + + /* Output before read-only data. */ + + #define TEXT_SECTION_ASM_OP "\t.text\n" + + /* Output before writable data. */ + + #define DATA_SECTION_ASM_OP "\t.data\n" + + /* How to refer to registers in assembler output. + This sequence is indexed by compiler's hard-register-number (see above). */ + + #define REGISTER_NAMES \ + {"r0", "r1", "r2", "r3", "r4", "fp", "sp", "pc", \ + "ac0", "ac1", "ac2", "ac3", "ac4", "ac5" } + + /* How to renumber registers for dbx and gdb. */ + + #define DBX_REGISTER_NUMBER(REGNO) (REGNO) + + /* This is how to output the definition of a user-level label named NAME, + such as the label on a static function or variable NAME. */ + + #define ASM_OUTPUT_LABEL(FILE,NAME) \ + do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0) + + /* This is how to output a command to make the user-level label named NAME + defined for reference from other files. */ + + #define ASM_GLOBALIZE_LABEL(FILE,NAME) \ + do { fputs ("\t.globl ", FILE); assemble_name (FILE, NAME); fputs("\n", FILE); } while (0) + + /* This is how to output a reference to a user-level label named NAME. + `assemble_name' uses this. */ + + #define ASM_OUTPUT_LABELREF(FILE,NAME) \ + fprintf (FILE, "_%s", NAME) + + /* This is how to output an internal numbered label where + PREFIX is the class of label and NUM is the number within the class. */ + + #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM) \ + fprintf (FILE, "%s_%d:\n", PREFIX, NUM) + + /* This is how to store into the string LABEL + the symbol_ref name of an internal numbered label where + PREFIX is the class of label and NUM is the number within the class. + This is suitable for output with `assemble_name'. */ + + #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ + sprintf (LABEL, "*%s_%d", PREFIX, NUM) + + /* This is how to output an assembler line defining a `double' constant. */ + + #define ASM_OUTPUT_DOUBLE(FILE,VALUE) \ + fprintf (FILE, "\tdouble %.20e\n", (VALUE)) + + /* This is how to output an assembler line defining a `float' constant. */ + + #define ASM_OUTPUT_FLOAT(FILE,VALUE) \ + fprintf (FILE, "\tfloat %.12e\n", (VALUE)) + + /* This is how to output an assembler line defining an `int' constant. */ + + #define ASM_OUTPUT_INT(FILE,VALUE) \ + ( fprintf (FILE, "\t.word "), \ + output_addr_const (FILE, (VALUE)), \ + fprintf (FILE, "\n")) + + /* Likewise for `short' and `char' constants. */ + + #define ASM_OUTPUT_SHORT(FILE,VALUE) \ + ( fprintf (FILE, "\t.word "), \ + output_addr_const (FILE, (VALUE)), \ + fprintf (FILE, " /*short*/\n")) + + #define ASM_OUTPUT_CHAR(FILE,VALUE) \ + ( fprintf (FILE, "\t.byte "), \ + output_addr_const (FILE, (VALUE)), \ + fprintf (FILE, " /* char */\n")) + + /* This is how to output an assembler line for a numeric constant byte.- + + do we really NEED it ? let's output it with a comment and grep the + assembly source ;-) + */ + + #define ASM_OUTPUT_BYTE(FILE,VALUE) \ + fprintf (FILE, "\t.byte 0x%x\n", (VALUE)) + + #define ASM_OUTPUT_ASCII(FILE, P, SIZE) \ + output_ascii (FILE, P, SIZE) + + #define ASM_OUTPUT_ADDR_VEC_PROLOGUE(FILE, MODE, LEN) \ + fprintf (FILE, "\t/* HELP! */\n"); + + /* This is how to output an element of a case-vector that is absolute. */ + + #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE) \ + fprintf (FILE, "\t.word L_%d\n", VALUE) + + /* This is how to output an element of a case-vector that is relative. + (the pdp does not use such vectors, + but we must define this macro anyway.) */ + + #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL) \ + fprintf (FILE, "\tERROR @L%d-@L%d ! error should not be used\n", VALUE, REL) + + /* This is how to output an assembler line + that says to advance the location counter + to a multiple of 2**LOG bytes. + + who needs this???? + */ + + #define ASM_OUTPUT_ALIGN(FILE,LOG) \ + if ((LOG) != 0) \ + fprintf (FILE, "\t.align %d\n", 1<<(LOG)) + + #define ASM_OUTPUT_SKIP(FILE,SIZE) \ + fprintf (FILE, "\t.=.+ %d\n", (SIZE)) + + /* This says how to output an assembler line + to define a global common symbol. */ + + #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED) \ + ( fprintf ((FILE), ".globl "), \ + assemble_name ((FILE), (NAME)), \ + fprintf ((FILE), "\n"), \ + assemble_name ((FILE), (NAME)), \ + fprintf ((FILE), ": .=.+ %d\n", (ROUNDED)) \ + ) + + /* This says how to output an assembler line + to define a local common symbol. */ + + #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED) \ + ( assemble_name ((FILE), (NAME)), \ + fprintf ((FILE), ":\t.=.+ %d\n", (ROUNDED))) + + /* Store in OUTPUT a string (made with alloca) containing + an assembler-name for a local static variable named NAME. + LABELNO is an integer which is different for each call. */ + + #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO) \ + ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10), \ + sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO))) + + /* Define the parentheses used to group arithmetic operations + in assembler code. */ + + #define ASM_OPEN_PAREN "(" + #define ASM_CLOSE_PAREN ")" + + /* Define results of standard character escape sequences. */ + #define TARGET_BELL 007 + #define TARGET_BS 010 + #define TARGET_TAB 011 + #define TARGET_NEWLINE 012 + #define TARGET_VT 013 + #define TARGET_FF 014 + #define TARGET_CR 015 + + /* Print operand X (an rtx) in assembler syntax to file FILE. + CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified. + For `%' followed by punctuation, CODE is the punctuation and X is null. + + */ + + + #define PRINT_OPERAND(FILE, X, CODE) \ + { if (CODE == '#') fprintf (FILE, "#"); \ + else if (GET_CODE (X) == REG) \ + fprintf (FILE, "%s", reg_names[REGNO (X)]); \ + else if (GET_CODE (X) == MEM) \ + output_address (XEXP (X, 0)); \ + else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != SImode) \ + { union { double d; int i[2]; } u; \ + u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ + fprintf (FILE, "#%.20e", u.d); } \ + else { putc ('$', FILE); output_addr_const (FILE, X); }} + + /* Print a memory address as an operand to reference that memory location. */ + + #define PRINT_OPERAND_ADDRESS(FILE, ADDR) \ + print_operand_address (FILE, ADDR) + + #define ASM_OUTPUT_REG_PUSH(FILE,REGNO) \ + ( \ + fprintf (FILE, "\tmov %s, -(sp)\n", reg_names[REGNO]) \ + ) + + #define ASM_OUTPUT_REG_POP(FILE,REGNO) \ + ( \ + fprintf (FILE, "\tmov (sp)+, %s\n", reg_names[REGNO]) \ + ) + + + #define ASM_IDENTIFY_GCC(FILE) \ + fprintf(FILE, "gcc_compiled:\n") + + #define ASM_OUTPUT_DOUBLE_INT(a,b) fprintf(a,"%d", b) + + /* trampoline - how should i do it in separate i+d ? + have some allocate_trampoline magic??? + + the following should work for shared I/D: */ + + /* lets see whether this works as trampoline: + MV #STATIC, $4 0x940Y 0x0000 <- STATIC; Y = STATIC_CHAIN_REGNUM + JMP FUNCTION 0x0058 0x0000 <- FUNCTION + */ + + #define TRAMPOLINE_TEMPLATE(FILE) \ + { \ + if (TARGET_SPLIT) \ + abort(); \ + \ + ASM_OUTPUT_INT (FILE, gen_rtx(CONST_INT, VOIDmode, 0x9400+STATIC_CHAIN_REGNUM)); \ + ASM_OUTPUT_INT (FILE, const0_rtx); \ + ASM_OUTPUT_INT (FILE, gen_rtx(CONST_INT, VOIDmode, 0x0058)); \ + ASM_OUTPUT_INT (FILE, const0_rtx); \ + } + + #define TRAMPOLINE_SIZE 8 + #define TRAMPOLINE_ALIGN 16 + + /* Emit RTL insns to initialize the variable parts of a trampoline. + FNADDR is an RTX for the address of the function's pure code. + CXT is an RTX for the static chain value for the function. */ + + #define INITIALIZE_TRAMPOLINE(TRAMP,FNADDR,CXT) \ + { \ + if (TARGET_SPLIT) \ + abort(); \ + \ + emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 2)), CXT); \ + emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 6)), FNADDR); \ + } + + + /* Some machines may desire to change what optimizations are + performed for various optimization levels. This macro, if + defined, is executed once just after the optimization level is + determined and before the remainder of the command options have + been parsed. Values set in this macro are used as the default + values for the other command line options. + + LEVEL is the optimization level specified; 2 if -O2 is + specified, 1 if -O is specified, and 0 if neither is specified. */ + + #define OPTIMIZATION_OPTIONS(LEVEL) \ + { \ + if (LEVEL >= 3) \ + { \ + flag_inline_functions = 1; \ + flag_omit_frame_pointer = 1; \ + /* flag_unroll_loops = 1; */ \ + } \ + } + + + /* Provide the costs of a rtl expression. This is in the body of a + switch on CODE. + + we don't say how expensive SImode is - pretty expensive!!! + + there is something wrong in MULT because MULT is not + as cheap as total = 2 even if we can shift! + + if TARGET_SPACE make mult etc cheap, but not 1, so when + in doubt the faster insn is chosen. + */ + + #define RTX_COSTS(X,CODE,OUTER_CODE) \ + case MULT: \ + if (TARGET_SPACE) \ + total = COSTS_N_INSNS(2); \ + else \ + total = COSTS_N_INSNS (11); \ + break; \ + case DIV: \ + if (TARGET_SPACE) \ + total = COSTS_N_INSNS(2); \ + else \ + total = COSTS_N_INSNS (25); \ + break; \ + case MOD: \ + if (TARGET_SPACE) \ + total = COSTS_N_INSNS(2); \ + else \ + total = COSTS_N_INSNS (26); \ + break; \ + case ABS: \ + /* equivalent to length, so same for TARGET_SPACE */ \ + total = COSTS_N_INSNS (3); \ + break; \ + case ZERO_EXTEND: \ + /* only used for: qi->hi */ \ + total = COSTS_N_INSNS(1); \ + break; \ + case SIGN_EXTEND: \ + if (GET_MODE(X) == HImode) \ + total = COSTS_N_INSNS(1); \ + else if (GET_MODE(X) == SImode) \ + total = COSTS_N_INSNS(6); \ + else \ + abort(); \ + break; \ + /* case LSHIFT: */ \ + case ASHIFT: \ + case LSHIFTRT: \ + case ASHIFTRT: \ + if (TARGET_SPACE) \ + total = COSTS_N_INSNS(1); \ + else if (GET_MODE(X) == QImode) \ + { \ + if (GET_CODE(XEXP (X,1)) != CONST_INT) \ + abort(); \ + total = COSTS_N_INSNS(INTVAL(XEXP (X,1))); \ + } \ + else if (GET_MODE(X) == HImode) \ + { \ + if (GET_CODE(XEXP (X,1)) == CONST_INT) \ + { \ + if (abs (INTVAL (XEXP (X, 1))) == 1) \ + total = COSTS_N_INSNS(1); \ + else \ + total = COSTS_N_INSNS(2.5 + 0.5 *INTVAL(XEXP(X,1))); \ + } \ + else /* worst case */ \ + total = COSTS_N_INSNS (10); \ + } \ + else if (GET_MODE(X) == SImode) \ + { \ + if (GET_CODE(XEXP (X,1)) == CONST_INT) \ + total = COSTS_N_INSNS(2.5 + 0.5 *INTVAL(XEXP(X,1))); \ + else /* worst case */ \ + total = COSTS_N_INSNS(18); \ + } \ + break; + + + /* there is no point in avoiding branches on a pdp, + since branches are really cheap - I just want to find out + how much difference the BRANCH_COST macro makes in code */ + #define BRANCH_COST (TARGET_BRANCH_CHEAP ? 0 : 1) + + + #define COMPARE_FLAG_MODE HImode + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pdp11/pdp11.md gcc-2.6.1/config/pdp11/pdp11.md *** gcc-2.6.0/config/pdp11/pdp11.md --- gcc-2.6.1/config/pdp11/pdp11.md Wed Oct 26 14:26:21 1994 *************** *** 0 **** --- 1,1958 ---- + ;;- Machine description for the pdp11 for GNU C compiler + ;; Copyright (C) 1994 Free Software Foundation, Inc. + ;; Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at). + + ;; 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 1, 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. + + + ;; HI is 16 bit + ;; QI is 8 bit + + ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al. + + ;;- cpp macro #define NOTICE_UPDATE_CC in file tm.h handles condition code + ;;- updates for most instructions. + + ;;- Operand classes for the register allocator: + + ;; Compare instructions. + + ;; currently we only support df floats, which saves us quite some + ;; hassle switching the FP mode! + ;; we assume that CPU is always in long float mode, and + ;; 16 bit integer mode - currently, the prologue for main does this, + ;; but maybe we should just set up a NEW crt0 properly, + ;; -- and what about signal handling code? + ;; (we don't even let sf floats in the register file, so + ;; we only should have to worry about truncating and widening + ;; when going to memory) + + ;; abort() call by g++ - must define libfunc for cmp_optab + ;; and ucmp_optab for mode SImode, because we don't have that!!! + ;; - yet since no libfunc is there, we abort () + + ;; The only thing that remains to be done then is output + ;; the floats in a way the assembler can handle it (and + ;; if you're really into it, use a PDP11 float emulation + ;; libary to do floating point constant folding - but + ;; I guess you'll get reasonable results even when not + ;; doing this) + ;; the last thing to do is fix the UPDATE_CC macro to check + ;; for floating point condition codes, and set cc_status + ;; properly, also setting the CC_IN_FCCR flag. + + ;; define attributes + ;; currently type is only fpu or arith or unknown, maybe branch later ? + ;; default is arith + (define_attr "type" "unknown,arith,fp" (const_string "arith")) + + ;; length default is 1 word each + (define_attr "length" "" (const_int 1)) + + ;; a users asm staement + (define_asm_attributes + [(set_attr "type" "unknown") + ; all bets are off how long it is - make it 256, forces long jumps + ; whenever jumping around it !!! + (set_attr "length" "256")]) + + ;; define function units + + ;; arithmetic - values here immediately when next insn issued + ;; or does it mean the number of cycles after this insn was issued? + ;; how do I say that fpu insns use cpu also? (pre-interaction phase) + + ;(define_function_unit "cpu" 1 1 (eq_attr "type" "arith") 0 0) + ;(define_function_unit "fpu" 1 1 (eq_attr "type" "fp") 0 0) + + ;; compare + (define_insn "cmpdf" + [(set (cc0) + (compare (match_operand:DF 0 "general_operand" "fR,Q,F") + (match_operand:DF 1 "register_operand" "a,a,a")))] + "TARGET_FPU" + "* + { + cc_status.flags = CC_IN_FPU; + return \"cmpd %0, %1\;cfcc\"; + }" + [(set_attr "length" "2,3,6")]) + + ;; a bit of brain damage, maybe inline later - + ;; problem is - gcc seems to NEED SImode because + ;; of the cmp weirdness - maybe change gcc to handle this? + + (define_expand "cmpsi" + [(set (reg:SI 0) + (match_operand:SI 0 "general_operand" "g")) + (set (reg:SI 2) + (match_operand:SI 1 "general_operand" "g")) + (parallel [(set (cc0) + (compare (reg:SI 0) + (reg:SI 2))) + (clobber (reg:SI 0))])] + "0" ;; disable for test + "") + + ;; check for next insn for branch code - does this still + ;; work in gcc 2.* ? + + (define_insn "" + [(set (cc0) + (compare (reg:SI 0) + (reg:SI 2))) + (clobber (reg:SI 0))] + "" + "* + { + rtx br_insn = NEXT_INSN (insn); + RTX_CODE br_code; + + if (GET_CODE (br_insn) != JUMP_INSN) + abort(); + br_code = GET_CODE (XEXP (XEXP (PATTERN (br_insn), 1), 0)); + + switch(br_code) + { + case GEU: + case LTU: + case GTU: + case LEU: + + return \"jsr pc, ___ucmpsi\;cmp $1,r0\"; + + case GE: + case LT: + case GT: + case LE: + case EQ: + case NE: + + return \"jsr pc, ___cmpsi\;tst r0\"; + + default: + + abort(); + } + }" + [(set_attr "length" "4")]) + + + (define_insn "cmphi" + [(set (cc0) + (compare (match_operand:HI 0 "general_operand" "rR,rR,Qi,Qi") + (match_operand:HI 1 "general_operand" "rR,Qi,rR,Qi")))] + "" + "cmp %0,%1" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "cmpqi" + [(set (cc0) + (compare (match_operand:QI 0 "general_operand" "rR,rR,Qi,Qi") + (match_operand:QI 1 "general_operand" "rR,Qi,rR,Qi")))] + "" + "cmpb %0,%1" + [(set_attr "length" "1,2,2,3")]) + + + ;; We have to have this because cse can optimize the previous pattern + ;; into this one. + + (define_insn "tstdf" + [(set (cc0) + (match_operand:DF 0 "general_operand" "fR,Q"))] + "TARGET_FPU" + "* + { + cc_status.flags = CC_IN_FPU; + return \"tstd %0\;cfcc\"; + }" + [(set_attr "length" "2,3")]) + + + (define_expand "tstsi" + [(set (reg:SI 0) + (match_operand:SI 0 "general_operand" "g")) + (parallel [(set (cc0) + (reg:SI 0)) + (clobber (reg:SI 0))])] + "0" ;; disable for test + "") + + (define_insn "" + [(set (cc0) + (reg:SI 0)) + (clobber (reg:SI 0))] + "" + "jsr pc, ___tstsi\;tst r0" + [(set_attr "length" "3")]) + + + (define_insn "tsthi" + [(set (cc0) + (match_operand:HI 0 "general_operand" "rR,Q"))] + "" + "tst %0" + [(set_attr "length" "1,2")]) + + (define_insn "tstqi" + [(set (cc0) + (match_operand:QI 0 "general_operand" "rR,Q"))] + "" + "tstb %0" + [(set_attr "length" "1,2")]) + + ;; sob instruction - we need an assembler which can make this instruction + ;; valid under _all_ circumstances! + + (define_insn "" + [(set (pc) + (if_then_else + (ne (plus:HI (match_operand:HI 0 "register_operand" "r") + (const_int -1)) + (const_int 0)) + (label_ref (match_operand 1 "" "")) + (pc))) + (set (match_dup 0) + (plus:HI (match_dup 0) + (const_int -1)))] + "TARGET_40_PLUS" + "* + { + static int labelcount = 0; + static char buf[1000]; + + if (get_attr_length (insn) == 1) + return \"sob %0, %l1\"; + + /* emulate sob */ + output_asm_insn (\"dec %0\", operands); + + sprintf (buf, \"bge LONG_SOB%d\", labelcount); + output_asm_insn (buf, NULL); + + output_asm_insn (\"jmp %l1\", operands); + + sprintf (buf, \"LONG_SOB%d:\", labelcount++); + output_asm_insn (buf, NULL); + + return \"\"; + }" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -256)) + (ge (minus (match_dup 0) + (pc)) + (const_int 0))) + (const_int 4) + (const_int 1)))]) + + ;; These control RTL generation for conditional jump insns + ;; and match them for register allocation. + + ;; problem with too short jump distance! we need an assembler which can + ;; make this legal for all jump distances! + ;; e.g. gas! + + ;; these must be changed to check for CC_IN_FCCR if float is to be + ;; enabled + + (define_insn "beq" + [(set (pc) + (if_then_else (eq (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"beq\", \"bne\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + + (define_insn "bne" + [(set (pc) + (if_then_else (ne (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"bne\", \"beq\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "bgt" + [(set (pc) + (if_then_else (gt (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"bgt\", \"ble\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "bgtu" + [(set (pc) + (if_then_else (gtu (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"bhi\", \"blos\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "blt" + [(set (pc) + (if_then_else (lt (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"blt\", \"bge\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + + (define_insn "bltu" + [(set (pc) + (if_then_else (ltu (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"blo\", \"bhos\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "bge" + [(set (pc) + (if_then_else (ge (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"bge\", \"blt\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "bgeu" + [(set (pc) + (if_then_else (geu (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"bhis\", \"blo\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "ble" + [(set (pc) + (if_then_else (le (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"ble\", \"bgt\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "bleu" + [(set (pc) + (if_then_else (leu (cc0) + (const_int 0)) + (label_ref (match_operand 0 "" "")) + (pc)))] + "" + "* return output_jump(\"blos\", \"bhi\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + + ;; These match inverted jump insns for register allocation. + + (define_insn "" + [(set (pc) + (if_then_else (eq (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"bne\", \"beq\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (ne (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"beq\", \"bne\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (gt (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"ble\", \"bgt\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (gtu (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"blos\", \"bhi\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (lt (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"bge\", \"blt\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (ltu (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"bhos\", \"blo\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (ge (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"blt\", \"bge\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (geu (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"blo\", \"bhos\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (le (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"bgt\", \"ble\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + (define_insn "" + [(set (pc) + (if_then_else (leu (cc0) + (const_int 0)) + (pc) + (label_ref (match_operand 0 "" ""))))] + "" + "* return output_jump(\"bhi\", \"blos\", get_attr_length(insn));" + [(set (attr "length") (if_then_else (ior (le (minus (match_dup 0) + (pc)) + (const_int -128)) + (ge (minus (match_dup 0) + (pc)) + (const_int 128))) + (const_int 3) + (const_int 1)))]) + + ;; Move instructions + + (define_insn "movdi" + [(set (match_operand:DI 0 "general_operand" "=g") + (match_operand:DI 1 "general_operand" "g"))] + "" + "* return output_move_quad (operands);" + ;; what's the mose expensive code - say twice movsi = 16 + [(set_attr "length" "16")]) + + (define_insn "movsi" + [(set (match_operand:SI 0 "general_operand" "=r,r,r,rm,m") + (match_operand:SI 1 "general_operand" "rN,IJ,K,m,r"))] + "" + "* return output_move_double (operands);" + ;; what's the most expensive code ? - I think 8! + ;; we could split it up and make several sub-cases... + [(set_attr "length" "2,3,4,8,8")]) + + (define_insn "movhi" + [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q") + (match_operand:HI 1 "general_operand" "rRN,Qi,rRN,Qi"))] + "" + "* + { + if (operands[1] == const0_rtx) + return \"clr %0\"; + + return \"mov %1, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "movqi" + [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q") + (match_operand:QI 1 "general_operand" "rRN,Qi,rRN,Qi"))] + "" + "* + { + if (operands[1] == const0_rtx) + return \"clrb %0\"; + + return \"movb %1, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + ;; do we have to supply all these moves? e.g. to + ;; NO_LOAD_FPU_REGs ? + (define_insn "movdf" + [(set (match_operand:DF 0 "general_operand" "=f,R,f,Q,f,m") + (match_operand:DF 1 "general_operand" "fR,f,Q,f,F,m"))] + "" + "* return output_move_quad (operands);" + ;; just a guess.. + [(set_attr "length" "1,1,2,2,5,16")]) + + (define_insn "movsf" + [(set (match_operand:SF 0 "general_operand" "=g,r,g") + (match_operand:SF 1 "general_operand" "r,rmF,g"))] + "TARGET_FPU" + "* return output_move_double (operands);" + [(set_attr "length" "8,8,8")]) + + ;; maybe fiddle a bit with move_ratio, then + ;; let contraints only accept a register ... + + (define_expand "movstrhi" + [(parallel [(set (mem:BLK (match_operand:BLK 0 "general_operand" "=g,g")) + (mem:BLK (match_operand:BLK 1 "general_operand" "g,g"))) + (use (match_operand:HI 2 "arith_operand" "n,&mr")) + (use (match_operand:HI 3 "immediate_operand" "i,i")) + (clobber (match_scratch:HI 4 "=&r,X")) + (clobber (match_dup 0)) + (clobber (match_dup 1)) + (clobber (match_dup 2))])] + "(TARGET_BCOPY_BUILTIN)" + " + { + operands[0] = copy_to_mode_reg (Pmode, XEXP (operands[0], 0)); + operands[1] = copy_to_mode_reg (Pmode, XEXP (operands[1], 0)); + operands[2] = force_not_mem (operands[2]); + }") + + + (define_insn "" ; "movstrhi" + [(set (mem:BLK (match_operand:HI 0 "general_operand" "=r,r")) + (mem:BLK (match_operand:HI 1 "general_operand" "r,r"))) + (use (match_operand:HI 2 "arith_operand" "n,&r")) + (use (match_operand:HI 3 "immediate_operand" "i,i")) + (clobber (match_scratch:HI 4 "=&r,X")) + (clobber (match_dup 0)) + (clobber (match_dup 1)) + (clobber (match_dup 2))] + "(TARGET_BCOPY_BUILTIN)" + "* return output_block_move (operands);" + ;;; just a guess + [(set_attr "length" "40")]) + + + + ;;- truncation instructions + + (define_insn "truncdfsf2" + [(set (match_operand:SF 0 "memory_operand" "=R,Q") + (float_truncate:SF (match_operand:DF 1 "register_operand" "a,a")))] + "TARGET_FPU" + "stcdf %1, %0" + [(set_attr "length" "1,2")]) + + (define_expand "truncsihi2" + [(set (match_operand:HI 0 "general_operand" "=g") + (subreg:HI + (match_operand:SI 1 "general_operand" "or") + 0))] + "" + "") + + + ;;- zero extension instructions + + (define_insn "zero_extendqihi2" + [(set (match_operand:HI 0 "general_operand" "=r") + (zero_extend:HI (match_operand:QI 1 "general_operand" "0")))] + "" + "bic $(256*255), %0" + [(set_attr "length" "2")]) + + (define_expand "zero_extendhisi2" + [(set (subreg:HI + (match_dup 0) + 1) + (match_operand:HI 1 "register_operand" "r")) + (set (subreg:HI + (match_operand:SI 0 "register_operand" "=r") + 0) + (const_int 0))] + "" + "/* operands[1] = make_safe_from (operands[1], operands[0]); */") + + + ;;- sign extension instructions + + (define_insn "extendsfdf2" + [(set (match_operand:DF 0 "register_operand" "=a,a") + (float_extend:SF (match_operand:SF 1 "memory_operand" "R,Q")))] + "TARGET_FPU" + "ldcfd %1, %0" + [(set_attr "length" "1,2")]) + + ;; does movb sign extend in register-to-register move? + (define_insn "extendqihi2" + [(set (match_operand:HI 0 "register_operand" "=r,r") + (sign_extend:HI (match_operand:QI 1 "general_operand" "rR,Q")))] + "" + "movb %1, %0" + [(set_attr "length" "1,2")]) + + (define_insn "extendqisi2" + [(set (match_operand:SI 0 "register_operand" "=r,r") + (sign_extend:SI (match_operand:QI 1 "general_operand" "rR,Q")))] + "TARGET_40_PLUS" + "* + { + rtx latehalf[2]; + + /* make register pair available */ + latehalf[0] = operands[0]; + operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1); + + output_asm_insn(\"movb %1, %0\", operands); + output_asm_insn(\"sxt %0\", latehalf); + + return \"\"; + }" + [(set_attr "length" "2,3")]) + + ;; maybe we have to use define_expand to say that we have the instruction, + ;; unconditionally, and then match dependent on CPU type: + + (define_expand "extendhisi2" + [(set (match_operand:SI 0 "general_operand" "=g") + (sign_extend:SI (match_operand:HI 1 "general_operand" "g")))] + "" + "") + + (define_insn "" ; "extendhisi2" + [(set (match_operand:SI 0 "general_operand" "=o,<,r") + (sign_extend:SI (match_operand:HI 1 "general_operand" "g,g,g")))] + "TARGET_40_PLUS" + "* + { + rtx latehalf[2]; + + /* we don't want to mess with auto increment */ + + switch(which_alternative) + { + case 0: + + latehalf[0] = operands[0]; + operands[0] = adj_offsettable_operand(operands[0], 2); + + output_asm_insn(\"mov %1, %0\", operands); + output_asm_insn(\"sxt %0\", latehalf); + + return \"\"; + + case 1: + + /* - auto-decrement - right direction ;-) */ + output_asm_insn(\"mov %1, %0\", operands); + output_asm_insn(\"sxt %0\", operands); + + return \"\"; + + case 2: + + /* make register pair available */ + latehalf[0] = operands[0]; + operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1); + + output_asm_insn(\"mov %1, %0\", operands); + output_asm_insn(\"sxt %0\", latehalf); + + return \"\"; + + default: + + abort(); + } + }" + [(set_attr "length" "5,3,3")]) + + + (define_insn "" + [(set (match_operand:SI 0 "register_operand" "=r") + (sign_extend:SI (match_operand:HI 1 "general_operand" "0")))] + "(! TARGET_40_PLUS)" + "* + { + static count = 0; + char buf[100]; + rtx lateoperands[2]; + + lateoperands[0] = operands[0]; + operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1); + + output_asm_insn(\"tst %0\", operands); + sprintf(buf, \"bge extendhisi%d\", count); + output_asm_insn(buf, NULL); + output_asm_insn(\"mov -1, %0\", lateoperands); + sprintf(buf, \"bne extendhisi%d\", count+1); + output_asm_insn(buf, NULL); + sprintf(buf, \"\\nextendhisi%d:\", count); + output_asm_insn(buf, NULL); + output_asm_insn(\"clr %0\", lateoperands); + sprintf(buf, \"\\nextendhisi%d:\", count+1); + output_asm_insn(buf, NULL); + + count += 2; + + return \"\"; + }" + [(set_attr "length" "6")]) + + ;; make float to int and vice versa + ;; using the cc_status.flag field we coulf probably cut down + ;; on seti and setl + ;; assume that we are normally in double and integer mode - + ;; what do pdp library routines do to fpu mode ? + + (define_insn "floatsidf2" + [(set (match_operand:DF 0 "register_operand" "=a,a") + (float:DF (match_operand:SI 1 "memory_operand" "R,Q")))] + "TARGET_FPU" + "setl\;ldcld %1, %0\;seti" + [(set_attr "length" "3,4")]) + + (define_insn "floathidf2" + [(set (match_operand:DF 0 "register_operand" "=a,a") + (float:DF (match_operand:HI 1 "general_operand" "rR,Qi")))] + "TARGET_FPU" + "ldcid %1, %0" + [(set_attr "length" "1,2")]) + + ;; cut float to int + (define_insn "fix_truncdfsi2" + [(set (match_operand:SI 0 "memory_operand" "=R,Q") + (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "a,a"))))] + "TARGET_FPU" + "setl\;stcdl %1, %0\;seti" + [(set_attr "length" "3,4")]) + + (define_insn "fix_truncdfhi2" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (fix:HI (fix:DF (match_operand:DF 1 "register_operand" "a,a"))))] + "TARGET_FPU" + "stcdi %1, %0" + [(set_attr "length" "1,2")]) + + + ;;- arithmetic instructions + ;;- add instructions + + (define_insn "adddf3" + [(set (match_operand:DF 0 "register_operand" "=a,a,a") + (plus:DF (match_operand:DF 1 "register_operand" "%0,0,0") + (match_operand:DF 2 "general_operand" "fR,Q,F")))] + "TARGET_FPU" + "addd %2, %0" + [(set_attr "length" "1,2,5")]) + + (define_insn "addsi3" + [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o") + (plus:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0") + (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K")))] + "" + "* + { /* Here we trust that operands don't overlap + + or is lateoperands the low word?? - looks like it! */ + + unsigned int i; + rtx lateoperands[3]; + + lateoperands[0] = operands[0]; + + if (REG_P (operands[0])) + operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1); + else + operands[0] = adj_offsettable_operand (operands[0], 2); + + if (! CONSTANT_P(operands[2])) + { + lateoperands[2] = operands[2]; + + if (REG_P (operands[2])) + operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1); + else + operands[2] = adj_offsettable_operand(operands[2], 2); + + output_asm_insn (\"add %2, %0\", operands); + output_asm_insn (\"adc %0\", lateoperands); + output_asm_insn (\"add %2, %0\", lateoperands); + return \"\"; + } + + lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff); + operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff); + + if (INTVAL(operands[2])) + { + output_asm_insn (\"add %2, %0\", operands); + output_asm_insn (\"adc %0\", lateoperands); + } + + if (INTVAL(lateoperands[2])) + output_asm_insn (\"add %2, %0\", lateoperands); + + return \"\"; + }" + [(set_attr "length" "3,5,6,8,3,1,5,5,3,8")]) + + (define_insn "addhi3" + [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q") + (plus:HI (match_operand:HI 1 "general_operand" "%0,0,0,0") + (match_operand:HI 2 "general_operand" "rRLM,Qi,rRLM,Qi")))] + "" + "* + { + if (GET_CODE (operands[2]) == CONST_INT) + if (INTVAL(operands[2]) == 1) + return \"inc %0\"; + else if (INTVAL(operands[2]) == -1) + return \"dec %0\"; + + return \"add %2, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "addqi3" + [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q") + (plus:QI (match_operand:QI 1 "general_operand" "%0,0,0,0") + (match_operand:QI 2 "general_operand" "rRLM,Qi,rRLM,Qi")))] + "" + "* + { + if (GET_CODE (operands[2]) == CONST_INT) + if (INTVAL(operands[2]) == 1) + return \"incb %0\"; + else if (INTVAL(operands[2]) == -1) + return \"decb %0\"; + + return \"addb %2, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + + ;;- subtract instructions + ;; we don't have to care for constant second + ;; args, since they are cononical plus:xx now! + ;; also for minus:DF ?? + + (define_insn "subdf3" + [(set (match_operand:DF 0 "register_operand" "=a,a") + (minus:DF (match_operand:DF 1 "register_operand" "0,0") + (match_operand:DF 2 "general_operand" "fR,Q")))] + "TARGET_FPU" + "subd %2, %0" + [(set_attr "length" "1,2")]) + + (define_insn "subsi3" + [(set (match_operand:SI 0 "general_operand" "=r,r,o,o") + (minus:SI (match_operand:SI 1 "general_operand" "0,0,0,0") + (match_operand:SI 2 "general_operand" "r,o,r,o")))] + "" + "* + { /* Here we trust that operands don't overlap + + or is lateoperands the low word?? - looks like it! */ + + unsigned int i; + rtx lateoperands[3]; + + lateoperands[0] = operands[0]; + + if (REG_P (operands[0])) + operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1); + else + operands[0] = adj_offsettable_operand (operands[0], 2); + + lateoperands[2] = operands[2]; + + if (REG_P (operands[2])) + operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1); + else + operands[2] = adj_offsettable_operand(operands[2], 2); + + output_asm_insn (\"sub %2, %0\", operands); + output_asm_insn (\"sbc %0\", lateoperands); + output_asm_insn (\"sub %2, %0\", lateoperands); + return \"\"; + }" + ;; offsetable memory addresses always are expensive!!! + [(set_attr "length" "3,5,6,8")]) + + (define_insn "subhi3" + [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q") + (minus:HI (match_operand:HI 1 "general_operand" "0,0,0,0") + (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi")))] + "" + "* + { + if (GET_CODE (operands[2]) == CONST_INT) + abort(); + + return \"sub %2, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "subqi3" + [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q") + (minus:QI (match_operand:QI 1 "general_operand" "0,0,0,0") + (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi")))] + "" + "* + { + if (GET_CODE (operands[2]) == CONST_INT) + abort(); + + return \"subb %2, %0\"; + }" + [(set_attr "length" "1,2,2,3")]) + + ;;;;- and instructions + ;; Bit-and on the pdp (like on the vax) is done with a clear-bits insn. + (define_expand "andsi3" + [(set (match_operand:SI 0 "general_operand" "=g") + (and:SI (match_operand:SI 1 "general_operand" "0") + (not:SI (match_operand:SI 2 "general_operand" "g"))))] + "" + " + { + extern rtx expand_unop (); + if (GET_CODE (operands[2]) == CONST_INT) + operands[2] = gen_rtx (CONST_INT, VOIDmode, ~INTVAL (operands[2])); + else + operands[2] = expand_unop (SImode, one_cmpl_optab, operands[2], 0, 1); + }") + + (define_expand "andhi3" + [(set (match_operand:HI 0 "general_operand" "=g") + (and:HI (match_operand:HI 1 "general_operand" "0") + (not:HI (match_operand:HI 2 "general_operand" "g"))))] + "" + " + { + extern rtx expand_unop (); + if (GET_CODE (operands[2]) == CONST_INT) + operands[2] = gen_rtx (CONST_INT, VOIDmode, ~INTVAL (operands[2])); + else + operands[2] = expand_unop (HImode, one_cmpl_optab, operands[2], 0, 1); + }") + + (define_expand "andqi3" + [(set (match_operand:QI 0 "general_operand" "=g") + (and:QI (match_operand:QI 1 "general_operand" "0") + (not:QI (match_operand:QI 2 "general_operand" "g"))))] + "" + " + { + extern rtx expand_unop (); + rtx op = operands[2]; + if (GET_CODE (op) == CONST_INT) + operands[2] = gen_rtx (CONST_INT, VOIDmode, + ((1 << 8) - 1) & ~INTVAL (op)); + else + operands[2] = expand_unop (QImode, one_cmpl_optab, op, 0, 1); + }") + + (define_insn "andcbsi3" + [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o") + (and:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0") + (not:SI (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K"))))] + "" + "* + { /* Here we trust that operands don't overlap + + or is lateoperands the low word?? - looks like it! */ + + unsigned int i; + rtx lateoperands[3]; + + lateoperands[0] = operands[0]; + + if (REG_P (operands[0])) + operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1); + else + operands[0] = adj_offsettable_operand (operands[0], 2); + + if (! CONSTANT_P(operands[2])) + { + lateoperands[2] = operands[2]; + + if (REG_P (operands[2])) + operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1); + else + operands[2] = adj_offsettable_operand(operands[2], 2); + + output_asm_insn (\"bic %2, %0\", operands); + output_asm_insn (\"bic %2, %0\", lateoperands); + return \"\"; + } + + lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff); + operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff); + + /* these have different lengths, so we should have + different constraints! */ + if (INTVAL(operands[2])) + output_asm_insn (\"bic %2, %0\", operands); + + if (INTVAL(lateoperands[2])) + output_asm_insn (\"bic %2, %0\", lateoperands); + + return \"\"; + }" + [(set_attr "length" "2,4,4,6,2,2,4,3,3,6")]) + + (define_insn "andcbhi3" + [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q") + (and:HI (match_operand:HI 1 "general_operand" "0,0,0,0") + (not:HI (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi"))))] + "" + "bic %2, %0" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "andcbqi3" + [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q") + (and:QI (match_operand:QI 1 "general_operand" "0,0,0,0") + (not:QI (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi"))))] + "" + "bicb %2, %0" + [(set_attr "length" "1,2,2,3")]) + + ;;- Bit set (inclusive or) instructions + (define_insn "iorsi3" + [(set (match_operand:SI 0 "general_operand" "=r,r,o,o,r,r,r,o,o,o") + (ior:SI (match_operand:SI 1 "general_operand" "%0,0,0,0,0,0,0,0,0,0") + (match_operand:SI 2 "general_operand" "r,o,r,o,I,J,K,I,J,K")))] + "" + "* + { /* Here we trust that operands don't overlap + + or is lateoperands the low word?? - looks like it! */ + + unsigned int i; + rtx lateoperands[3]; + + lateoperands[0] = operands[0]; + + if (REG_P (operands[0])) + operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1); + else + operands[0] = adj_offsettable_operand (operands[0], 2); + + if (! CONSTANT_P(operands[2])) + { + lateoperands[2] = operands[2]; + + if (REG_P (operands[2])) + operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1); + else + operands[2] = adj_offsettable_operand(operands[2], 2); + + output_asm_insn (\"bis %2, %0\", operands); + output_asm_insn (\"bis %2, %0\", lateoperands); + return \"\"; + } + + lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff); + operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff); + + /* these have different lengths, so we should have + different constraints! */ + if (INTVAL(operands[2])) + output_asm_insn (\"bis %2, %0\", operands); + + if (INTVAL(lateoperands[2])) + output_asm_insn (\"bis %2, %0\", lateoperands); + + return \"\"; + }" + [(set_attr "length" "2,4,4,6,2,2,4,3,3,6")]) + + (define_insn "iorhi3" + [(set (match_operand:HI 0 "general_operand" "=rR,rR,Q,Q") + (ior:HI (match_operand:HI 1 "general_operand" "%0,0,0,0") + (match_operand:HI 2 "general_operand" "rR,Qi,rR,Qi")))] + "" + "bis %2, %0" + [(set_attr "length" "1,2,2,3")]) + + (define_insn "iorqi3" + [(set (match_operand:QI 0 "general_operand" "=rR,rR,Q,Q") + (ior:QI (match_operand:QI 1 "general_operand" "%0,0,0,0") + (match_operand:QI 2 "general_operand" "rR,Qi,rR,Qi")))] + "" + "bisb %2, %0") + + ;;- xor instructions + (define_insn "xorsi3" + [(set (match_operand:SI 0 "register_operand" "=r,r,r,r") + (xor:SI (match_operand:SI 1 "register_operand" "%0,0,0,0") + (match_operand:SI 2 "arith_operand" "r,I,J,K")))] + "TARGET_40_PLUS" + "* + { /* Here we trust that operands don't overlap */ + + unsigned int i; + rtx lateoperands[3]; + + lateoperands[0] = operands[0]; + operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1); + + if (REG_P(operands[2])) + { + lateoperands[2] = operands[2]; + operands[2] = gen_rtx(REG, HImode, REGNO(operands[2]) + 1); + + output_asm_insn (\"xor %2, %0\", operands); + output_asm_insn (\"xor %2, %0\", lateoperands); + + return \"\"; + } + + lateoperands[2] = gen_rtx(CONST_INT, VOIDmode, (INTVAL(operands[2]) >> 16) & 0xffff); + operands[2] = gen_rtx(CONST_INT, VOIDmode, INTVAL(operands[2]) & 0xffff); + + if (INTVAL(operands[2])) + output_asm_insn (\"xor %2, %0\", operands); + + if (INTVAL(lateoperands[2])) + output_asm_insn (\"xor %2, %0\", lateoperands); + + return \"\"; + }" + [(set_attr "length" "2,1,1,2")]) + + (define_insn "xorhi3" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (xor:HI (match_operand:HI 1 "general_operand" "%0,0") + (match_operand:HI 2 "register_operand" "r,r")))] + "TARGET_40_PLUS" + "xor %2, %0" + [(set_attr "length" "1,2")]) + + ;;- one complement instructions + + (define_insn "one_cmplhi2" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (not:HI (match_operand:HI 1 "general_operand" "0,0")))] + "" + "com %0" + [(set_attr "length" "1,2")]) + + (define_insn "one_cmplqi2" + [(set (match_operand:QI 0 "general_operand" "=rR,Q") + (not:QI (match_operand:QI 1 "general_operand" "0,0")))] + "" + "comb %0" + [(set_attr "length" "1,2")]) + + ;;- arithmetic shift instructions + (define_insn "ashlsi3" + [(set (match_operand:SI 0 "register_operand" "=r,r") + (ashift:SI (match_operand:SI 1 "register_operand" "0,0") + (match_operand:HI 2 "general_operand" "rR,Qi")))] + "TARGET_45" + "ashc %2,%0" + [(set_attr "length" "1,2")]) + + ;; Arithmetic right shift on the pdp works by negating the shift count. + (define_expand "ashrsi3" + [(set (match_operand:SI 0 "register_operand" "=r") + (ashift:SI (match_operand:SI 1 "register_operand" "0") + (match_operand:HI 2 "general_operand" "g")))] + "" + " + { + operands[2] = negate_rtx (HImode, operands[2]); + }") + + ;; define asl aslb asr asrb - ashc missing! + + ;; asl + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (ashift:HI (match_operand:HI 1 "general_operand" "0,0") + (const_int 1)))] + "" + "asl %0" + [(set_attr "length" "1,2")]) + + ;; and another possibility for asr is << -1 + ;; might cause problems since -1 can also be encoded as 65535! + ;; not in gcc2 ??? + + ;; asr + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (ashift:HI (match_operand:HI 1 "general_operand" "0,0") + (const_int -1)))] + "" + "asr %0" + [(set_attr "length" "1,2")]) + + ;; shift is by arbitrary count is expensive, + ;; shift by one cheap - so let's do that, if + ;; space doesn't matter + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=r") + (ashift:HI (match_operand:HI 1 "general_operand" "0") + (match_operand:HI 2 "expand_shift_operand" "O")))] + "TARGET_TIME" + "* + { + register int i; + + for (i = 1; i <= abs(INTVAL(operands[2])); i++) + if (INTVAL(operands[2]) < 0) + output_asm_insn(\"asr %0\", operands); + else + output_asm_insn(\"asl %0\", operands); + + return \"\"; + }" + ;; longest is 4 + [(set (attr "length") (const_int 4))]) + + ;; aslb + (define_insn "" + [(set (match_operand:QI 0 "general_operand" "=r,o") + (ashift:QI (match_operand:QI 1 "general_operand" "0,0") + (match_operand:HI 2 "const_immediate_operand" "n,n")))] + "" + "* + { /* allowing predec or post_inc is possible, but hairy! */ + int i, cnt; + + cnt = INTVAL(operands[2]) & 0x0007; + + for (i=0 ; i < cnt ; i++) + output_asm_insn(\"aslb %0\", operands); + + return \"\"; + }" + ;; set attribute length ( match_dup 2 & 7 ) *(1 or 2) !!! + [(set_attr_alternative "length" + [(const_int 7) + (const_int 14)])]) + + ;;; asr + ;(define_insn "" + ; [(set (match_operand:HI 0 "general_operand" "=rR,Q") + ; (ashiftrt:HI (match_operand:HI 1 "general_operand" "0,0") + ; (const_int 1)))] + ; "" + ; "asr %0" + ; [(set_attr "length" "1,2")]) + + ;; asrb + (define_insn "" + [(set (match_operand:QI 0 "general_operand" "=r,o") + (ashiftrt:QI (match_operand:QI 1 "general_operand" "0,0") + (match_operand:HI 2 "const_immediate_operand" "n,n")))] + "" + "* + { /* allowing predec or post_inc is possible, but hairy! */ + int i, cnt; + + cnt = INTVAL(operands[2]) & 0x0007; + + for (i=0 ; i < cnt ; i++) + output_asm_insn(\"asrb %0\", operands); + + return \"\"; + }" + [(set_attr_alternative "length" + [(const_int 7) + (const_int 14)])]) + + ;; the following is illegal - too complex!!! - just say 14 !!! + ; [(set (attr "length") (plus (and (match_dup 2) + ; (const_int 7)) + ; (and (match_dup 2) + ; (const_int 7))))]) + + + + ;; can we get +-1 in the next pattern? should + ;; have been caught by previous patterns! + + (define_insn "ashlhi3" + [(set (match_operand:HI 0 "register_operand" "=r,r") + (ashift:HI (match_operand:HI 1 "register_operand" "0,0") + (match_operand:HI 2 "general_operand" "rR,Qi")))] + "" + "* + { + if (GET_CODE(operands[2]) == CONST_INT) + if (INTVAL(operands[2]) == 1) + return \"asl %0\"; + else if (INTVAL(operands[2]) == -1) + return \"asr %0\"; + + return \"ash %2,%0\"; + }" + [(set_attr "length" "1,2")]) + + ;; Arithmetic right shift on the pdp works by negating the shift count. + (define_expand "ashrhi3" + [(set (match_operand:HI 0 "register_operand" "=r") + (ashift:HI (match_operand:HI 1 "register_operand" "0") + (match_operand:HI 2 "general_operand" "g")))] + "" + " + { + operands[2] = negate_rtx (HImode, operands[2]); + }") + + ;;;;- logical shift instructions + ;;(define_insn "lshrsi3" + ;; [(set (match_operand:HI 0 "register_operand" "=r") + ;; (lshiftrt:HI (match_operand:HI 1 "register_operand" "0") + ;; (match_operand:HI 2 "arith_operand" "rI")))] + ;; "" + ;; "srl %0,%2") + + ;; absolute + + (define_insn "absdf2" + [(set (match_operand:DF 0 "general_operand" "=fR,Q") + (abs:DF (match_operand:DF 1 "general_operand" "0,0")))] + "TARGET_FPU" + "absd %0" + [(set_attr "length" "1,2")]) + + (define_insn "abshi2" + [(set (match_operand:HI 0 "general_operand" "=r,o") + (abs:HI (match_operand:HI 1 "general_operand" "0,0")))] + "TARGET_ABSHI_BUILTIN" + "* + { + static count = 0; + char buf[200]; + + output_asm_insn(\"tst %0\", operands); + sprintf(buf, \"bge abshi%d\", count); + output_asm_insn(buf, NULL); + output_asm_insn(\"neg %0\", operands); + sprintf(buf, \"\\nabshi%d:\", count++); + output_asm_insn(buf, NULL); + + return \"\"; + }" + [(set_attr "length" "3,5")]) + + + ;; define expand abshi - is much better !!! - but + ;; will it be optimized into an abshi2 ? + ;; it will leave better code, because the tsthi might be + ;; optimized away!! + ; -- just a thought - don't have time to check + ; + ;(define_expand "abshi2" + ; [(match_operand:HI 0 "general_operand" "") + ; (match_operand:HI 1 "general_operand" "")] + ; "" + ; " + ;{ + ; rtx label = gen_label_rtx (); + ; + ; /* do I need this? */ + ; do_pending_stack_adjust (); + ; + ; emit_move_insn (operands[0], operands[1]); + ; + ; emit_insn (gen_tsthi (operands[0])); + ; emit_insn (gen_bge (label1)); + ; + ; emit_insn (gen_neghi(operands[0], operands[0]) + ; + ; emit_barrier (); + ; + ; emit_label (label); + ; + ; /* allow REG_NOTES to be set on last insn (labels don't have enough + ; fields, and can't be used for REG_NOTES anyway). */ + ; emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx)); + ; DONE; + ;}") + + ;; negate insns + + (define_insn "negdf2" + [(set (match_operand:DF 0 "general_operand" "=fR,Q") + (neg:DF (match_operand:DF 1 "register_operand" "0,0")))] + "TARGET_FPU" + "negd %0" + [(set_attr "length" "1,2")]) + + (define_insn "neghi2" + [(set (match_operand:HI 0 "general_operand" "=rR,Q") + (neg:HI (match_operand:HI 1 "general_operand" "0,0")))] + "" + "neg %0" + [(set_attr "length" "1,2")]) + + (define_insn "negqi2" + [(set (match_operand:QI 0 "general_operand" "=rR,Q") + (neg:QI (match_operand:QI 1 "general_operand" "0,0")))] + "" + "negb %0" + [(set_attr "length" "1,2")]) + + + ;; Unconditional and other jump instructions + (define_insn "jump" + [(set (pc) + (label_ref (match_operand 0 "" "")))] + "" + "jmp %l0" + [(set_attr "length" "2")]) + + (define_insn "" + [(set (pc) + (label_ref (match_operand 0 "" ""))) + (clobber (const_int 1))] + "" + "jmp %l0" + [(set_attr "length" "2")]) + + (define_insn "tablejump" + [(set (pc) (match_operand:HI 0 "general_operand" "rR,Q")) + (use (label_ref (match_operand 1 "" "")))] + "" + "jmp %0" + [(set_attr "length" "1,2")]) + + ;; indirect jump - let's be conservative! + ;; allow only register_operand, even though we could also + ;; allow labels etc. + + (define_insn "indirect_jump" + [(set (pc) (match_operand:HI 0 "register_operand" "r"))] + "" + "jmp (%0)") + + ;;- jump to subroutine + + (define_insn "call" + [(call (match_operand:HI 0 "general_operand" "R,Q") + (match_operand:HI 1 "general_operand" "g,g")) + ;; (use (reg:HI 0)) what was that ??? + ] + ;;- Don't use operand 1 for most machines. + "" + "jsr pc, %0" + [(set_attr "length" "1,2")]) + + ;;- jump to subroutine + (define_insn "call_value" + [(set (match_operand 0 "" "") + (call (match_operand:HI 1 "general_operand" "R,Q") + (match_operand:HI 2 "general_operand" "g,g"))) + ;; (use (reg:HI 0)) - what was that ???? + ] + ;;- Don't use operand 2 for most machines. + "" + "jsr pc, %1" + [(set_attr "length" "1,2")]) + + ;;- nop instruction + (define_insn "nop" + [(const_int 0)] + "" + "nop") + + + ;;- multiply + + (define_insn "muldf3" + [(set (match_operand:DF 0 "register_operand" "=a,a,a") + (mult:DF (match_operand:DF 1 "register_operand" "%0,0,0") + (match_operand:DF 2 "general_operand" "fR,Q,F")))] + "TARGET_FPU" + "muld %2, %0" + [(set_attr "length" "1,2,5")]) + + ;; 16 bit result multiply: + ;; currently we multiply only into odd registers, so we don't use two + ;; registers - but this is a bit inefficient at times. If we define + ;; a register class for each register, then we can specify properly + ;; which register need which scratch register .... + + (define_insn "mulhi3" + [(set (match_operand:HI 0 "register_operand" "=d,d") ; multiply regs + (mult:HI (match_operand:HI 1 "register_operand" "%0,0") + (match_operand:HI 2 "general_operand" "rR,Qi")))] + "TARGET_45" + "mul %2, %0" + [(set_attr "length" "1,2")]) + + ;; 32 bit result + (define_insn "mulhisi3" + [(set (match_operand:SI 0 "register_operand" "=r,r") ; even numbered! + (mult:SI (match_operand:HI 1 "register_operand" "%0,0") + (match_operand:HI 2 "general_operand" "rR,Qi")))] + "TARGET_45" + "mul %2, %0" + [(set_attr "length" "1,2")]) + + ;;- divide + ;; how can I use the remainder ? - + ;; modsidi and move upper register to lower ???? + + (define_insn "divdf3" + [(set (match_operand:DF 0 "register_operand" "=a,a,a") + (div:DF (match_operand:DF 1 "register_operand" "0,0,0") + (match_operand:DF 2 "general_operand" "fR,Q,F")))] + "TARGET_FPU" + "divd %2, %0" + [(set_attr "length" "1,2,5")]) + + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=r,r") + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0,0") + (sign_extend:SI (match_operand:HI 2 "general_operand" "rR,Q")))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "1,2")]) + + ;; - problem matching the (sign_extend:SI (const_int ...)) + ; used without -O + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=r") + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0") + (sign_extend:SI (match_operand 2 "immediate_operand" "n")))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "2")]) + + ; used with -O + (define_insn "" + [(set (match_operand:HI 0 "general_operand" "=r") + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0") + (match_operand:SI 2 "immediate_operand" "i"))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "2")]) + + (define_expand "divhi3" + [(set (match_dup 3) + (sign_extend:SI (match_operand:HI 1 "general_operand" "g"))) + (set (match_operand:HI 0 "general_operand" "g") + (truncate:HI + (div:SI + (match_dup 3) + (sign_extend:SI (match_operand:HI 2 "general_operand" "g")))))] + "TARGET_45" + "operands[3] = gen_reg_rtx (SImode);") + + (define_expand "udivqi" + [(set (subreg:HI (match_dup 3) 1) + (zero_extend:HI (match_operand:QI 1 "general_operand" "g"))) + (set (subreg:HI (match_dup 3) 0) + (const_int 0)) + (set (match_dup 4) + (sign_extend:HI (match_operand:QI 2 "general_operand" "g"))) + (set (match_dup 5) + (and:HI (match_dup 4) + (const_int 255))) + (set (match_dup 6) + (truncate:HI + (div:SI + (match_dup 3) + (sign_extend:SI (match_dup 5))))) + (set (match_operand:QI 0 "general_operand" "g") + (truncate:QI (match_dup 6)))] + "TARGET_45" + " + { + operands[3] = gen_reg_rtx (SImode); + operands[4] = gen_reg_rtx (HImode); + operands[5] = gen_reg_rtx (HImode); + operands[6] = gen_reg_rtx (HImode); + }") + + ;; we must restrict it to divide by 15-bit constant... + (define_expand "udivhi3" + [(set (subreg:HI (match_dup 3) 1) + (match_operand:HI 1 "general_operand" "g")) + (set (subreg:HI (match_dup 3) 0) + (const_int 0)) + (set (match_operand:HI 0 "general_operand" "g") + (truncate:HI + (div:SI + (match_dup 3) + (sign_extend:SI (match_operand:HI 2 "immediate15_operand" "n")))))] + "TARGET_45" + " + { + operands[3] = gen_reg_rtx (SImode); + + if (GET_CODE (operands[2]) != CONST_INT + || ((INTVAL (operands[2]) & 0x8000) != 0x0000)) + FAIL; + }") + + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r,r") 1) + (truncate:HI + (mod:SI + (match_operand:SI 1 "general_operand" "0,0") + (sign_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rR,Q")))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "1,2")]) + + ;; (sign_extend:SI (const_int )) + ; w/o -O + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 1) + (truncate:HI + (mod:SI + (match_operand:SI 1 "general_operand" "0") + (sign_extend:SI (match_operand 2 "immediate_operand" "i")))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "2")]) + ; w/ -O + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 1) + (truncate:HI + (mod:SI + (match_operand:SI 1 "general_operand" "0") + (match_operand:SI 2 "immediate_operand" "i"))))] + "TARGET_45" + "div %2,%0" + [(set_attr "length" "2")]) + + (define_expand "modhi3" + [(set (match_dup 3) + (sign_extend:SI (match_operand:HI 1 "general_operand" "g"))) + (set (subreg:HI (match_dup 3) 1) + (truncate:HI + (mod:SI + (match_dup 3) + (sign_extend:SI (match_operand:HI 2 "general_operand" "g"))))) + (set (match_operand:HI 0 "general_operand" "g") + (subreg:HI (match_dup 3) 1))] + "TARGET_45" + "operands[3] = gen_reg_rtx (SImode);") + + ;; we must restrict it to mod by 15 bit constant + (define_expand "umodhi3" + [(set (subreg:HI (match_dup 3) 0) + (match_operand:HI 1 "general_operand" "g")) + (set (subreg:HI (match_dup 3) 1) + (const_int 0)) + (set (subreg:HI (match_dup 3) 1) + (truncate:HI + (mod:SI + (match_dup 3) + (sign_extend:SI (match_operand:HI 2 "immediate15_operand" "n"))))) + (set (match_operand:HI 0 "general_operand" "g") + (subreg:HI (match_dup 3) 1))] + "TARGET_45" + " + { + operands[3] = gen_reg_rtx (SImode); + + if (GET_CODE (operands[2]) != CONST_INT + || ((INTVAL (operands[2]) & 0x8000) != 0x0000)) + FAIL; + }") + + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r,r") 0) + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0,0") + (sign_extend:SI (match_operand:HI 2 "nonimmediate_operand" "rR,Q"))))) + (set (subreg:HI (match_dup 0) 1) + (truncate:HI + (mod:SI + (match_dup 1) + (sign_extend:SI (match_dup 2)))))] + "TARGET_45" + "div %2, %0" + [(set_attr "length" "1,2")]) + + ;; (sign_extend:SI (const_int)) + ; w/o -O + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 0) + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0") + (sign_extend:SI (match_operand 2 "immediate_operand" "i"))))) + (set (subreg:HI (match_dup 0) 1) + (truncate:HI + (mod:SI + (match_dup 1) + (sign_extend:SI (match_dup 2)))))] + "TARGET_45" + "div %2, %0" + [(set_attr "length" "2")]) + ; w/ -O + (define_insn "" + [(set (subreg:HI (match_operand:SI 0 "general_operand" "=r") 0) + (truncate:HI + (div:SI + (match_operand:SI 1 "general_operand" "0") + (match_operand:SI 2 "immediate_operand" "i")))) + (set (subreg:HI (match_dup 0) 1) + (truncate:HI + (mod:SI + (match_dup 1) + (match_dup 2))))] + "TARGET_45" + "div %2, %0" + [(set_attr "length" "2")]) + + (define_expand "divmodhi4" + [(set (match_dup 4) + (sign_extend:SI (match_operand:HI 1 "general_operand" "g"))) + (set (subreg:HI (match_dup 4) 0) + (truncate:HI + (div:SI + (match_dup 4) + (sign_extend:SI (match_operand:HI 2 "general_operand" "g"))))) + (set (subreg:HI (match_dup 4) 1) + (truncate:HI + (mod:SI + (match_dup 4) + (sign_extend:SI (match_dup 2))))) + (set (match_operand:HI 0 "general_operand" "g") + (subreg:HI (match_dup 4) 0)) + (set (match_operand:HI 3 "general_operand" "g") + (subreg:HI (match_dup 4) 1))] + "TARGET_45" + "operands[4] = gen_reg_rtx(SImode);") + + (define_expand "udivmodhi4" + [(set (subreg:HI (match_dup 3) 1) + (match_operand:HI 1 "general_operand" "g")) + (set (subreg:HI (match_dup 3) 0) + (const_int 0)) + (set (subreg:HI (match_dup 4) 0) + (truncate:HI + (div:SI + (match_dup 4) + (sign_extend:SI (match_operand:HI 2 "immediate15_operand" "n"))))) + (set (subreg:HI (match_dup 4) 1) + (truncate:HI + (mod:SI + (match_dup 4) + (sign_extend:SI (match_dup 2))))) + (set (match_operand:HI 0 "general_operand" "g") + (subreg:HI (match_dup 4) 0)) + (set (match_operand:HI 3 "general_operand" "g") + (subreg:HI (match_dup 4) 1))] + "TARGET_45" + " + { + operands[3] = gen_reg_rtx (SImode); + + if (GET_CODE (operands[2]) != CONST_INT + || ((INTVAL (operands[2]) & 0x8000) != 0x0000)) + FAIL; + }") + + ;; truncate used in div/mod patterns + (define_insn "" + [(set (match_operand:QI 0 "general_operand" "=r,r") + (truncate:QI (match_operand:HI 1 "general_operand" "0,r")))] + "TARGET_45" + "@ + ; nop + movb %1, %0" + [(set_attr "length" "0,1")]) + + ;; is rotate doing the right thing to be included here ???? diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pdp11/xm-pdp11.h gcc-2.6.1/config/pdp11/xm-pdp11.h *** gcc-2.6.0/config/pdp11/xm-pdp11.h --- gcc-2.6.1/config/pdp11/xm-pdp11.h Wed Oct 26 13:39:23 1994 *************** *** 0 **** --- 1,29 ---- + /* Configuration for GNU C-compiler for pdp-11 family. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at). + + 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 1, 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. + + */ + + /* ???? */ + /* xm is if you want to run gcc here ??? */ + /* too big !!! */ + + #error YOU LOSE! Gcc cannot run on a pdp-11 due to size problems! + + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/pyr/pyr.h gcc-2.6.1/config/pyr/pyr.h *** gcc-2.6.0/config/pyr/pyr.h Mon Oct 11 07:36:32 1993 --- gcc-2.6.1/config/pyr/pyr.h Sat Jul 30 14:11:37 1994 *************** *** 1332,1336 **** fprintf (FILE, "$0x%x", u1.i); } \ \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != DImode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ --- 1332,1336 ---- fprintf (FILE, "$0x%x", u1.i); } \ \ ! else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) != VOIDmode) \ { union { double d; int i[2]; } u; \ u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X); \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/romp/romp.md gcc-2.6.1/config/romp/romp.md *** gcc-2.6.0/config/romp/romp.md Mon Jul 5 17:43:00 1993 --- gcc-2.6.1/config/romp/romp.md Fri Jul 29 17:49:58 1994 *************** *** 1,5 **** ;;- Machine description for ROMP chip for GNU C compiler ! ;; Copyright (C) 1988, 1991, 1993 Free Software Foundation, Inc. ! ;; Contributed by Richard Kenner (kenner@nyu.edu) ;; This file is part of GNU CC. --- 1,5 ---- ;;- Machine description for ROMP chip for GNU C compiler ! ;; Copyright (C) 1988, 1991, 1993, 1994 Free Software Foundation, Inc. ! ;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu) ;; This file is part of GNU CC. *************** *** 2545,2550 **** "* { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE, ! operands[0], immed_real_const_1 (0, 0, ! GET_MODE (operands[0])), 0, insn); }" --- 2545,2549 ---- "* { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE, ! operands[0], CONST0_RTX (GET_MODE (operands[0])), 0, insn); }" *************** *** 2560,2565 **** "* { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE, ! operands[1], immed_real_const_1 (0, 0, ! GET_MODE (operands[1])), 0, insn); }" --- 2559,2563 ---- "* { return output_fpop (next_insn_tests_no_inequality (insn) ? EQ : GE, ! operands[1], CONST0_RTX (GET_MODE (operands[1])), 0, insn); }" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/rs6000/aix41.h gcc-2.6.1/config/rs6000/aix41.h *** gcc-2.6.0/config/rs6000/aix41.h --- gcc-2.6.1/config/rs6000/aix41.h Mon Oct 17 19:18:26 1994 *************** *** 0 **** --- 1,26 ---- + /* Definitions of target machine for GNU compiler, + for IBM RS/6000 POWER running AIX version 4.1. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by David Edelsohn (edelsohn@npac.syr.edu). + + 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 "rs6000/rs6000.h" + + #undef ASM_SPEC + #define ASM_SPEC "-u -mpwr" diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/rs6000/rs6000.h gcc-2.6.1/config/rs6000/rs6000.h *** gcc-2.6.0/config/rs6000/rs6000.h Mon Jul 4 22:57:15 1994 --- gcc-2.6.1/config/rs6000/rs6000.h Tue Oct 11 18:38:57 1994 *************** *** 479,482 **** --- 479,486 ---- : (CLASS1) == FLOAT_REGS && (CLASS2) != FLOAT_REGS ? 10 \ : (CLASS1) != FLOAT_REGS && (CLASS2) == FLOAT_REGS ? 10 \ + : (((CLASS1) == SPECIAL_REGS || (CLASS1) == MQ_REGS \ + || (CLASS1) == LINK_REGS || (CLASS1) == CTR_REGS) \ + && ((CLASS2) == SPECIAL_REGS || (CLASS2) == MQ_REGS \ + || (CLASS2) == LINK_REGS || (CLASS2) == CTR_REGS)) ? 10 \ : 2) *************** *** 716,719 **** --- 720,728 ---- ? ((GET_MODE_SIZE (MODE) + 2 * UNITS_PER_WORD - 1) / (2 * UNITS_PER_WORD)) \ : ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)) + + /* If defined, gives a class of registers that cannot be used as the + operand of a SUBREG that changes the size of the object. */ + + #define CLASS_CANNOT_CHANGE_SIZE FLOAT_REGS /* Stack layout; function entry, exit and calling. */ *************** *** 1722,1726 **** fprintf (FILE, "\n"); \ } \ ! else if (write_symbols == XCOFF_DEBUG) \ { \ fprintf (FILE, "\t.lglobl ."); \ --- 1731,1735 ---- fprintf (FILE, "\n"); \ } \ ! else \ { \ fprintf (FILE, "\t.lglobl ."); \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/rs6000/rs6000.md gcc-2.6.1/config/rs6000/rs6000.md *** gcc-2.6.0/config/rs6000/rs6000.md Tue Jul 12 16:18:40 1994 --- gcc-2.6.1/config/rs6000/rs6000.md Mon Sep 19 20:23:41 1994 *************** *** 1290,1294 **** (zero_extend:DI (match_dup 4))) (match_dup 3)))] - "TARGET_POWER" "div %0,%1,%3" --- 1290,1293 ---- *************** *** 3560,3565 **** [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*q,*c*l,*h") (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,r,0"))] ! "TARGET_POWER && (gpc_reg_operand (operands[0], SImode) ! || gpc_reg_operand (operands[1], SImode))" "@ mr %0,%1 --- 3559,3564 ---- [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*q,*c*l,*h") (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,r,0"))] ! "gpc_reg_operand (operands[0], SImode) ! || gpc_reg_operand (operands[1], SImode)" "@ mr %0,%1 *************** *** 3566,3571 **** {l%U1%X1|lwz%U1%X1} %0,%1 {st%U0%X0|stw%U0%X0} %1,%0 ! {cal %0,%1(0)|li %0,%1} ! {cau %0,0,%u1|lis %0,%u1} mf%1 %0 mt%0 %1 --- 3565,3570 ---- {l%U1%X1|lwz%U1%X1} %0,%1 {st%U0%X0|stw%U0%X0} %1,%0 ! {lil|li} %0,%1 ! {liu|lis} %0,%u1 mf%1 %0 mt%0 %1 *************** *** 3574,3593 **** [(set_attr "type" "*,load,*,*,*,*,*,mtjmpr,*")]) - (define_insn "" - [(set (match_operand:SI 0 "nonimmediate_operand" "=r,r,m,r,r,r,*h,*h") - (match_operand:SI 1 "input_operand" "r,m,r,I,J,*h,r,0"))] - "! TARGET_POWER && (gpc_reg_operand (operands[0], SImode) - || gpc_reg_operand (operands[1], SImode))" - "@ - mr %0,%1 - lwz%U1%X1 %0,%1 - stw%U0%X0 %1,%0 - li %0,%1 - lis %0,%u1 - mf%1 %0 - mt%0 %1 - cror 0,0,0" - [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")]) - ;; Split a load of a large constant into the appropriate two-insn ;; sequence. --- 3573,3576 ---- *************** *** 3641,3646 **** [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h") (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))] ! "TARGET_POWER && (gpc_reg_operand (operands[0], HImode) ! || gpc_reg_operand (operands[1], HImode))" "@ mr %0,%1 --- 3624,3629 ---- [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h") (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,r,0"))] ! "gpc_reg_operand (operands[0], HImode) ! || gpc_reg_operand (operands[1], HImode)" "@ mr %0,%1 *************** *** 3647,3651 **** lhz%U1%X1 %0,%1 sth%U0%X0 %1,%0 ! {cal %0,%w1(0)|li %0,%w1} mf%1 %0 mt%0 %1 --- 3630,3634 ---- lhz%U1%X1 %0,%1 sth%U0%X0 %1,%0 ! {lil|li} %0,%w1 mf%1 %0 mt%0 %1 *************** *** 3654,3672 **** [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")]) - (define_insn "" - [(set (match_operand:HI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h") - (match_operand:HI 1 "input_operand" "r,m,r,i,*h,r,0"))] - "! TARGET_POWER && (gpc_reg_operand (operands[0], HImode) - || gpc_reg_operand (operands[1], HImode))" - "@ - mr %0,%1 - lhz%U1%X1 %0,%1 - sth%U0%X0 %1,%0 - li %0,%w1 - mf%1 %0 - mt%0 %1 - cror 0,0,0" - [(set_attr "type" "*,load,*,*,*,mtjmpr,*")]) - (define_expand "movqi" [(set (match_operand:QI 0 "general_operand" "") --- 3637,3640 ---- *************** *** 3691,3696 **** [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h") (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))] ! "TARGET_POWER && (gpc_reg_operand (operands[0], QImode) ! || gpc_reg_operand (operands[1], QImode))" "@ mr %0,%1 --- 3659,3664 ---- [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*q,*c*l,*h") (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,r,0"))] ! "gpc_reg_operand (operands[0], QImode) ! || gpc_reg_operand (operands[1], QImode)" "@ mr %0,%1 *************** *** 3697,3701 **** lbz%U1%X1 %0,%1 stb%U0%X0 %1,%0 ! {cal %0,%1(0)|li %0,%1} mf%1 %0 mt%0 %1 --- 3665,3669 ---- lbz%U1%X1 %0,%1 stb%U0%X0 %1,%0 ! {lil|li} %0,%1 mf%1 %0 mt%0 %1 *************** *** 3703,3721 **** cror 0,0,0" [(set_attr "type" "*,load,*,*,*,*,mtjmpr,*")]) - - (define_insn "" - [(set (match_operand:QI 0 "nonimmediate_operand" "=r,r,m,r,r,*h,*h") - (match_operand:QI 1 "input_operand" "r,m,r,i,*h,r,0"))] - "! TARGET_POWER && (gpc_reg_operand (operands[0], QImode) - || gpc_reg_operand (operands[1], QImode))" - "@ - mr %0,%1 - lbz%U1%X1 %0,%1 - stb%U0%X0 %1,%0 - li %0,%1 - mf%1 %0 - mt%0 %1 - cror 0,0,0" - [(set_attr "type" "*,load,*,*,*,mtjmpr,*")]) ;; Here is how to move condition codes around. When we store CC data in --- 3671,3674 ---- *************** *** 3795,3810 **** if (GET_CODE (operands[0]) == MEM) { ! operands[1] = force_reg (SFmode, operands[1]); ! if (! TARGET_POWERPC) ! if (reload_in_progress || reload_completed) ! emit_insn (gen_truncdfsf2 (operands[1], gen_rtx (SUBREG, DFmode, operands[1], 0))); ! else ! { ! rtx newreg = gen_reg_rtx (SFmode); ! emit_insn (gen_truncdfsf2 (newreg, ! gen_rtx (SUBREG, DFmode, operands[1], 0))); ! operands[1] = newreg; ! } } --- 3748,3763 ---- if (GET_CODE (operands[0]) == MEM) { ! /* If operands[1] is a register, it may have double-precision data ! in it, so truncate it to single precision. We need not do ! this for POWERPC. */ ! if (! TARGET_POWERPC && GET_CODE (operands[1]) == REG) ! { ! rtx newreg = reload_in_progress ? operands[1] : gen_reg_rtx (SFmode); ! emit_insn (gen_truncdfsf2 (newreg, gen_rtx (SUBREG, DFmode, operands[1], 0))); ! operands[1] = newreg; ! } ! ! operands[1] = force_reg (SFmode, operands[1]); } *************** *** 3862,3867 **** lfs%U1%X1 %0,%1 stfs%U0%X0 %1,%0" ! [(set_attr "type" "fp,fpload,*") ! (set_attr "length" "*,*,8")]) (define_expand "movdf" --- 3815,3819 ---- lfs%U1%X1 %0,%1 stfs%U0%X0 %1,%0" ! [(set_attr "type" "fp,fpload,*")]) (define_expand "movdf" *************** *** 4440,4444 **** (define_insn "" [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f") ! (mem:SI (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0") (match_operand:SI 2 "reg_or_short_operand" "r,I")))) (set (match_operand:SI 0 "gpc_reg_operand" "=b,b") --- 4392,4396 ---- (define_insn "" [(set (match_operand:SF 3 "gpc_reg_operand" "=f,f") ! (mem:SF (plus:SI (match_operand:SI 1 "gpc_reg_operand" "0,0") (match_operand:SI 2 "reg_or_short_operand" "r,I")))) (set (match_operand:SI 0 "gpc_reg_operand" "=b,b") diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/ashlsi3.c gcc-2.6.1/config/sh/ashlsi3.c *** gcc-2.6.0/config/sh/ashlsi3.c --- gcc-2.6.1/config/sh/ashlsi3.c Fri Sep 9 19:41:57 1994 *************** *** 0 **** --- 1,79 ---- + /* Copyright (C) 1994 Free Software Foundation, Inc. + + This file 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. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file with other programs, and to distribute + those programs without any restriction coming from the use of this + file. (The General Public License restrictions do apply in other + respects; for example, they cover modification of the file, and + distribution when not linked into another program.) + + This file 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 this program; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + + + /* libgcc1 routines for the Hitachi SH cpu. + Contributed by Steve Chamberlain. + sac@cygnus.com */ + + + + long + __ashlsi3 (int a, int b) + { + switch (b) + { + default : return 0; + case 0: return a << 0; + case 1: return a << 1; + case 2: return a << 2; + case 3: return a << 3; + case 4: return a << 4; + case 5: return a << 5; + case 6: return a << 6; + case 7: return a << 7; + case 8: return a << 8; + case 9: return a << 9; + case 10: return a << 10; + case 11: return a << 11; + case 12: return a << 12; + case 13: return a << 13; + case 14: return a << 14; + case 15: return a << 15; + case 16: return a << 16; + case 17: return a << 17; + case 18: return a << 18; + case 19: return a << 19; + case 20: return a << 20; + case 21: return a << 21; + case 22: return a << 22; + case 23: return a << 23; + case 24: return a << 24; + case 25: return a << 25; + case 26: return a << 26; + case 27: return a << 27; + case 28: return a << 28; + case 29: return a << 29; + case 30: return a << 30; + case 31: return a << 31; + } + } + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/ashrsi3.c gcc-2.6.1/config/sh/ashrsi3.c *** gcc-2.6.0/config/sh/ashrsi3.c --- gcc-2.6.1/config/sh/ashrsi3.c Fri Sep 9 19:42:02 1994 *************** *** 0 **** --- 1,110 ---- + /* Copyright (C) 1994 Free Software Foundation, Inc. + + This file 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. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file with other programs, and to distribute + those programs without any restriction coming from the use of this + file. (The General Public License restrictions do apply in other + respects; for example, they cover modification of the file, and + distribution when not linked into another program.) + + This file 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 this program; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + + + /* libgcc1 routines for the Hitachi SH cpu. + Contributed by Steve Chamberlain. + sac@cygnus.com */ + + + + long + __ashrsi3 (int a, int b) + { + switch ((b - 1)) + { + case 24 + 7: + a >>= 1; + case 24 + 6: + a >>= 1; + case 24 + 5: + a >>= 1; + case 24 + 4: + a >>= 1; + case 24 + 3: + a >>= 1; + case 24 + 2: + a >>= 1; + case 24 + 1: + a >>= 1; + case 24 + 0: + a >>= 1; + case 16 + 7: + a >>= 1; + case 16 + 6: + a >>= 1; + case 16 + 5: + a >>= 1; + case 16 + 4: + a >>= 1; + case 16 + 3: + a >>= 1; + case 16 + 2: + a >>= 1; + case 16 + 1: + a >>= 1; + case 16 + 0: + a >>= 1; + case 8 + 7: + a >>= 1; + case 8 + 6: + a >>= 1; + case 8 + 5: + a >>= 1; + case 8 + 4: + a >>= 1; + case 8 + 3: + a >>= 1; + case 8 + 2: + a >>= 1; + case 8 + 1: + a >>= 1; + case 8 + 0: + a >>= 1; + case 0 + 7: + a >>= 1; + case 0 + 6: + a >>= 1; + case 0 + 5: + a >>= 1; + case 0 + 4: + a >>= 1; + case 0 + 3: + a >>= 1; + case 0 + 2: + a >>= 1; + case 0 + 1: + a >>= 1; + case 0 + 0: + a >>= 1;; + }; + return a; + } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/lib1funcs.asm gcc-2.6.1/config/sh/lib1funcs.asm *** gcc-2.6.0/config/sh/lib1funcs.asm --- gcc-2.6.1/config/sh/lib1funcs.asm Fri Sep 9 19:40:46 1994 *************** *** 0 **** --- 1,483 ---- + /* Copyright (C) 1994 Free Software Foundation, Inc. + + This file 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. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file with other programs, and to distribute + those programs without any restriction coming from the use of this + file. (The General Public License restrictions do apply in other + respects; for example, they cover modification of the file, and + distribution when not linked into another program.) + + This file 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 this program; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + + + !! libgcc1 routines for the Hitachi SH cpu. + !! Contributed by Steve Chamberlain. + !! sac@cygnus.com + + + #ifdef L_ashiftrt + .global ___ashiftrt_r4_0 + .global ___ashiftrt_r4_1 + .global ___ashiftrt_r4_2 + .global ___ashiftrt_r4_3 + .global ___ashiftrt_r4_4 + .global ___ashiftrt_r4_5 + .global ___ashiftrt_r4_6 + .global ___ashiftrt_r4_7 + .global ___ashiftrt_r4_8 + .global ___ashiftrt_r4_9 + .global ___ashiftrt_r4_10 + .global ___ashiftrt_r4_11 + .global ___ashiftrt_r4_12 + .global ___ashiftrt_r4_13 + .global ___ashiftrt_r4_14 + .global ___ashiftrt_r4_15 + .global ___ashiftrt_r4_16 + .global ___ashiftrt_r4_17 + .global ___ashiftrt_r4_18 + .global ___ashiftrt_r4_19 + .global ___ashiftrt_r4_20 + .global ___ashiftrt_r4_21 + .global ___ashiftrt_r4_22 + .global ___ashiftrt_r4_23 + .global ___ashiftrt_r4_24 + .global ___ashiftrt_r4_25 + .global ___ashiftrt_r4_26 + .global ___ashiftrt_r4_27 + .global ___ashiftrt_r4_28 + .global ___ashiftrt_r4_29 + .global ___ashiftrt_r4_30 + .global ___ashiftrt_r4_31 + .global ___ashiftrt_r4_32 + + ___ashiftrt_r4_32: + shar r4 + ___ashiftrt_r4_31: + shar r4 + ___ashiftrt_r4_30: + shar r4 + ___ashiftrt_r4_29: + shar r4 + ___ashiftrt_r4_28: + shar r4 + ___ashiftrt_r4_27: + shar r4 + ___ashiftrt_r4_26: + shar r4 + ___ashiftrt_r4_25: + shar r4 + ___ashiftrt_r4_24: + shar r4 + ___ashiftrt_r4_23: + shar r4 + ___ashiftrt_r4_22: + shar r4 + ___ashiftrt_r4_21: + shar r4 + ___ashiftrt_r4_20: + shar r4 + ___ashiftrt_r4_19: + shar r4 + ___ashiftrt_r4_18: + shar r4 + ___ashiftrt_r4_17: + shar r4 + ___ashiftrt_r4_16: + shar r4 + ___ashiftrt_r4_15: + shar r4 + ___ashiftrt_r4_14: + shar r4 + ___ashiftrt_r4_13: + shar r4 + ___ashiftrt_r4_12: + shar r4 + ___ashiftrt_r4_11: + shar r4 + ___ashiftrt_r4_10: + shar r4 + ___ashiftrt_r4_9: + shar r4 + ___ashiftrt_r4_8: + shar r4 + ___ashiftrt_r4_7: + shar r4 + ___ashiftrt_r4_6: + shar r4 + ___ashiftrt_r4_5: + shar r4 + ___ashiftrt_r4_4: + shar r4 + ___ashiftrt_r4_3: + shar r4 + ___ashiftrt_r4_2: + shar r4 + ___ashiftrt_r4_1: + rts + shar r4 + + ___ashiftrt_r4_0: + or r0,r0 + rts + #endif + + #ifdef L_movstr + .text + ! done all the large groups, do the remainder + + ! jump to movstr+ + done: + add #64,r5 + mova ___movstrSI0,r0 + shll2 r6 + add r6,r0 + jmp @r0 + add #64,r4 + .align 4 + .global ___movstrSI64 + ___movstrSI64: + mov.l @(60,r5),r0 + mov.l r0,@(60,r4) + .global ___movstrSI60 + ___movstrSI60: + mov.l @(56,r5),r0 + mov.l r0,@(56,r4) + .global ___movstrSI56 + ___movstrSI56: + mov.l @(52,r5),r0 + mov.l r0,@(52,r4) + .global ___movstrSI52 + ___movstrSI52: + mov.l @(48,r5),r0 + mov.l r0,@(48,r4) + .global ___movstrSI48 + ___movstrSI48: + mov.l @(44,r5),r0 + mov.l r0,@(44,r4) + .global ___movstrSI44 + ___movstrSI44: + mov.l @(40,r5),r0 + mov.l r0,@(40,r4) + .global ___movstrSI40 + ___movstrSI40: + mov.l @(36,r5),r0 + mov.l r0,@(36,r4) + .global ___movstrSI36 + ___movstrSI36: + mov.l @(32,r5),r0 + mov.l r0,@(32,r4) + .global ___movstrSI32 + ___movstrSI32: + mov.l @(28,r5),r0 + mov.l r0,@(28,r4) + .global ___movstrSI28 + ___movstrSI28: + mov.l @(24,r5),r0 + mov.l r0,@(24,r4) + .global ___movstrSI24 + ___movstrSI24: + mov.l @(20,r5),r0 + mov.l r0,@(20,r4) + .global ___movstrSI20 + ___movstrSI20: + mov.l @(16,r5),r0 + mov.l r0,@(16,r4) + .global ___movstrSI16 + ___movstrSI16: + mov.l @(12,r5),r0 + mov.l r0,@(12,r4) + .global ___movstrSI12 + ___movstrSI12: + mov.l @(8,r5),r0 + mov.l r0,@(8,r4) + .global ___movstrSI8 + ___movstrSI8: + mov.l @(4,r5),r0 + mov.l r0,@(4,r4) + .global ___movstrSI4 + ___movstrSI4: + mov.l @(0,r5),r0 + mov.l r0,@(0,r4) + ___movstrSI0: + rts + or r0,r0,r0 + + .align 4 + + .global ___movstr + ___movstr: + mov.l @(60,r5),r0 + mov.l r0,@(60,r4) + + mov.l @(56,r5),r0 + mov.l r0,@(56,r4) + + mov.l @(52,r5),r0 + mov.l r0,@(52,r4) + + mov.l @(48,r5),r0 + mov.l r0,@(48,r4) + + mov.l @(44,r5),r0 + mov.l r0,@(44,r4) + + mov.l @(40,r5),r0 + mov.l r0,@(40,r4) + + mov.l @(36,r5),r0 + mov.l r0,@(36,r4) + + mov.l @(32,r5),r0 + mov.l r0,@(32,r4) + + mov.l @(28,r5),r0 + mov.l r0,@(28,r4) + + mov.l @(24,r5),r0 + mov.l r0,@(24,r4) + + mov.l @(20,r5),r0 + mov.l r0,@(20,r4) + + mov.l @(16,r5),r0 + mov.l r0,@(16,r4) + + mov.l @(12,r5),r0 + mov.l r0,@(12,r4) + + mov.l @(8,r5),r0 + mov.l r0,@(8,r4) + + mov.l @(4,r5),r0 + mov.l r0,@(4,r4) + + mov.l @(0,r5),r0 + mov.l r0,@(0,r4) + + add #-16,r6 + cmp/pl r6 + bf done + + add #64,r5 + bra ___movstr + add #64,r4 + #endif + + #ifdef L_mulsi3 + + + .global ___mulsi3 + + ! r4 = aabb + ! r5 = ccdd + ! r0 = aabb*ccdd via partial products + ! + ! if aa == 0 and cc = 0 + ! r0 = bb*dd + ! + ! else + ! aa = bb*dd + (aa*dd*65536) + (cc*bb*65536) + ! + + ___mulsi3: + mulu r4,r5 ! multiply the lsws macl=bb*dd + mov r5,r3 ! r3 = ccdd + swap.w r4,r2 ! r2 = bbaa + xtrct r2,r3 ! r3 = aacc + tst r3,r3 ! msws zero ? + bf hiset + rts ! yes - then weve got the answer + sts macl,r0 + + hiset: sts macl,r0 ! r0 = bb*dd + mulu r2,r5 | brewing macl = aa*dd + sts macl,r1 + mulu r3,r4 | brewing macl = cc*bb + sts macl,r2 + add r1,r2 + shll16 r2 + rts + add r2,r0 + + + #endif + #ifdef L_sdivsi3 + .title "SH DIVIDE" + !! 4 byte integer Divide code for the Hitachi SH + !! + !! Steve Chamberlain + !! sac@cygnus.com + !! + !! + + !! args in r4 and r5, result in r0 clobber r1,r2,r3 + + .global ___sdivsi3 + ___sdivsi3: + mov r4,r1 + mov r5,r0 + + tst r0,r0 + bt div0 + mov #0,r2 + div0s r2,r1 + subc r3,r3 + subc r2,r1 + div0s r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + div1 r0,r3 + rotcl r1 + addc r2,r1 + rts + mov r1,r0 + + + div0: rts + mov #0,r0 + + #endif + #ifdef L_udivsi3 + + .title "SH DIVIDE" + !! 4 byte integer Divide code for the Hitachi SH + !! + !! Steve Chamberlain + !! sac@cygnus.com + !! + !! + + !! args in r4 and r5, result in r0, clobbers r4,r6, pr and t bit + .global ___udivsi3 + + ___udivsi3: + longway: + mov #0,r0 + div0u + ! get one bit from the msb of the numerator into the T + ! bit and divide it by whats in r5. Put the answer bit + ! into the T bit so it can come out again at the bottom + + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + shortway: + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + + vshortway: + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 ; div1 r5,r0 + rotcl r4 + ret: rts + mov r4,r0 + + #endif + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/lshrsi3.c gcc-2.6.1/config/sh/lshrsi3.c *** gcc-2.6.0/config/sh/lshrsi3.c --- gcc-2.6.1/config/sh/lshrsi3.c Fri Sep 9 19:42:10 1994 *************** *** 0 **** --- 1,82 ---- + /* Copyright (C) 1994 Free Software Foundation, Inc. + + This file 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. + + In addition to the permissions in the GNU General Public License, the + Free Software Foundation gives you unlimited permission to link the + compiled version of this file with other programs, and to distribute + those programs without any restriction coming from the use of this + file. (The General Public License restrictions do apply in other + respects; for example, they cover modification of the file, and + distribution when not linked into another program.) + + This file 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 this program; see the file COPYING. If not, write to + the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + /* As a special exception, if you link this library with other files, + some of which are compiled with GCC, to produce an executable, + this library does not by itself cause the resulting executable + to be covered by the GNU General Public License. + This exception does not however invalidate any other reasons why + the executable file might be covered by the GNU General Public License. */ + + + /* libgcc1 routines for the Hitachi SH cpu. + Contributed by Steve Chamberlain. + sac@cygnus.com */ + + + + + + + long + __lshrsi3 (unsigned a, int b) + { + switch (b) + { + default : return 0; + case 0: return a >> 0; + case 1: return a >> 1; + case 2: return a >> 2; + case 3: return a >> 3; + case 4: return a >> 4; + case 5: return a >> 5; + case 6: return a >> 6; + case 7: return a >> 7; + case 8: return a >> 8; + case 9: return a >> 9; + case 10: return a >> 10; + case 11: return a >> 11; + case 12: return a >> 12; + case 13: return a >> 13; + case 14: return a >> 14; + case 15: return a >> 15; + case 16: return a >> 16; + case 17: return a >> 17; + case 18: return a >> 18; + case 19: return a >> 19; + case 20: return a >> 20; + case 21: return a >> 21; + case 22: return a >> 22; + case 23: return a >> 23; + case 24: return a >> 24; + case 25: return a >> 25; + case 26: return a >> 26; + case 27: return a >> 27; + case 28: return a >> 28; + case 29: return a >> 29; + case 30: return a >> 30; + case 31: return a >> 31; + } + } + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/sh.c gcc-2.6.1/config/sh/sh.c *** gcc-2.6.0/config/sh/sh.c Wed Apr 20 15:16:59 1994 --- gcc-2.6.1/config/sh/sh.c Fri Sep 9 19:33:03 1994 *************** *** 66,75 **** int regno_reg_class[FIRST_PSEUDO_REGISTER] = { ! R0_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, ! GENERAL_REGS, PR_REGS, T_REGS, NO_REGS, ! MAC_REGS, MAC_REGS, }; --- 66,75 ---- int regno_reg_class[FIRST_PSEUDO_REGISTER] = { ! R0_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, ! GENERAL_REGS, PR_REGS, T_REGS, NO_REGS, ! MAC_REGS, MAC_REGS, }; *************** *** 105,114 **** int hard_regno_mode_ok[] = { ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG, 0, SI_ONLY, SI_ONLY, ! SI_ONLY, SI_ONLY }; --- 105,114 ---- int hard_regno_mode_ok[] = { ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG_EVEN, REG_ODD, REG_EVEN, REG_ODD, ! REG, 0, SI_ONLY, SI_ONLY, ! SI_ONLY, SI_ONLY }; *************** *** 121,127 **** between expand_prologue and expand_epilogue. */ static int extra_push; - void push (rn) --- 121,127 ---- between expand_prologue and expand_epilogue. */ static int extra_push; + void push (rn) *************** *** 128,132 **** int rn; { ! emit_insn (gen_push (gen_rtx (REG, SImode, rn))); } --- 128,135 ---- int rn; { ! rtx x ; ! x= emit_insn (gen_push (gen_rtx (REG, SImode, rn))); ! REG_NOTES (x) = gen_rtx (EXPR_LIST, REG_INC, ! gen_rtx(REG, SImode, STACK_POINTER_REGNUM), 0); } *************** *** 133,138 **** void pop (rn) { ! emit_insn (gen_pop (gen_rtx (REG, SImode, rn))); } --- 136,145 ---- void pop (rn) + int rn; { ! rtx x; ! x = emit_insn (gen_pop (gen_rtx (REG, SImode, rn))); ! REG_NOTES (x) = gen_rtx (EXPR_LIST, REG_INC, ! gen_rtx(REG, SImode, STACK_POINTER_REGNUM), 0); } *************** *** 139,143 **** /* Adjust the stack and return the number of bytes taken to do it */ ! static void output_stack_adjust (size) --- 146,151 ---- /* Adjust the stack and return the number of bytes taken to do it */ ! static rtx lastreg; ! int lastval; static void output_stack_adjust (size) *************** *** 151,157 **** if (!CONST_OK_FOR_I (size)) { ! rtx nval = gen_rtx (REG, SImode, 3); ! emit_insn (gen_movsi (nval, val)); ! val = nval; } --- 159,167 ---- if (!CONST_OK_FOR_I (size)) { ! lastreg = gen_rtx (REG, SImode, 3); ! lastval = size; ! emit_insn (gen_movsi (lastreg, val)); ! val = lastreg; ! } *************** *** 161,164 **** --- 171,175 ---- } + /* Generate code to push the regs specified in the mask, and return the number of bytes the insns take. */ *************** *** 300,304 **** default: debug_rtx (x); - abort (); } --- 311,314 ---- *************** *** 355,361 **** case '@': if (pragma_interrupt) ! fprintf (stream,"rte"); else ! fprintf (stream,"rts"); break; case '#': --- 365,371 ---- case '@': if (pragma_interrupt) ! fprintf (stream, "rte"); else ! fprintf (stream, "rts"); break; case '#': *************** *** 406,410 **** --- 416,422 ---- + static int sextb (x) + int x; { x &= 0xff; *************** *** 421,425 **** devious shifting. If so, generate the instruction sequence and return 1, otherwise return 0. ! OPERANDS[0] Destination register OPERANDS[1] Source constant --- 433,437 ---- devious shifting. If so, generate the instruction sequence and return 1, otherwise return 0. ! OPERANDS[0] Destination register OPERANDS[1] Source constant *************** *** 443,447 **** ! */ static int --- 455,459 ---- ! */ static int *************** *** 452,457 **** rtx dst; int i = INTVAL (operands[1]) & 0xffffffff; ! ! if (CONST_OK_FOR_I (i)) return 0; --- 464,469 ---- rtx dst; int i = INTVAL (operands[1]) & 0xffffffff; ! ! if (CONST_OK_FOR_I (i)) return 0; *************** *** 461,469 **** if (mode != SImode) { ! if (reload_in_progress) return 0; dst = gen_reg_rtx (SImode); } ! else { dst = operands[0]; --- 473,481 ---- if (mode != SImode) { ! if (reload_in_progress) return 0; dst = gen_reg_rtx (SImode); } ! else { dst = operands[0]; *************** *** 470,473 **** --- 482,486 ---- } + /* 00000000 00000000 11111111 1NNNNNNNN load and zero extend word */ if ((i & 0xffffff80) == 0x0000ff80) *************** *** 509,514 **** /* 00000000 0NNNNNNN 00000000 000000000 load and shift by 16 11111111 1NNNNNNN 00000000 000000000 load and shift by 16 */ ! else if ((i & 0xff80ffff) == 0 ! || (i & 0xff80ffff) == 0xff80ffff) { emit_move_insn (dst, GEN_INT (sextb (i >> 16))); --- 522,527 ---- /* 00000000 0NNNNNNN 00000000 000000000 load and shift by 16 11111111 1NNNNNNN 00000000 000000000 load and shift by 16 */ ! else if ((i & 0xff80ffff) == 0x00000000 ! || (i & 0xff80ffff) == 0xff800000) { emit_move_insn (dst, GEN_INT (sextb (i >> 16))); *************** *** 525,529 **** return 0; ! if (mode != SImode) { emit_insn (gen_rtx (SET, VOIDmode, operands[0], --- 538,554 ---- return 0; ! if (mode == DImode) ! { ! /* Moving from SI to DI, we've got to zero out the high part */ ! ! emit_insn (gen_rtx (SET, VOIDmode, ! gen_rtx (SUBREG, SImode, operands[0], 0), ! dst)); ! emit_insn (gen_rtx (SET, VOIDmode, ! gen_rtx (SUBREG, SImode, operands[0], 1), ! const0_rtx)); ! ! } ! else if (mode != SImode) { emit_insn (gen_rtx (SET, VOIDmode, operands[0], *************** *** 593,600 **** if (mode == SImode && constp && (bytes % 4 == 0)) { - char entry[30]; tree entry_name; rtx func_addr_rtx; - int groups; rtx r4 = gen_rtx (REG, SImode, 4); rtx r5 = gen_rtx (REG, SImode, 5); --- 618,623 ---- *************** *** 671,675 **** operands[1] = copy_to_mode_reg (mode, operands[1]); } ! if ((mode == DImode || mode == SImode || mode == HImode || mode == QImode) && GET_CODE (operands[1]) == CONST_INT) { --- 694,698 ---- operands[1] = copy_to_mode_reg (mode, operands[1]); } ! if ((mode == SImode || mode == HImode || mode == QImode) && GET_CODE (operands[1]) == CONST_INT) { *************** *** 741,744 **** --- 764,768 ---- rtx prepare_scc_operands (code) + int code; { if (GET_CODE (sh_compare_op0) != REG *************** *** 864,867 **** --- 888,895 ---- return "mov.l %1,%0\n\tmov.l %1+4,%R0"; } + else if (GET_CODE (inside) == POST_INC) + { + return "mov.l %1,%0\n\tmov.l %1,%R0 !mdi\n"; + } else abort (); *************** *** 1023,1031 **** rtx thislab = gen_label_rtx (); - /* See if we can grab a reg from the prev insn */ - rtx gotone = 0; - rtx prev = PREV_INSN (insn); - rtx link; - if (dbr_sequence_length ()) { --- 1051,1054 ---- *************** *** 1042,1052 **** { vec[1] = gen_rtx (REG, SImode, i); ! if (!reg_referenced_p (vec[1], PATTERN (XVECEXP (final_sequence, 0, 1)))) break; } output_asm_insn ("mov.l %1,@-r15", vec); output_asm_insn ("mov.l %O0,%1", vec); ! print_slot (final_sequence); output_asm_insn ("jmp @%1 ! 32 xcond", vec); output_asm_insn ("mov.l @r15+,%1", vec); --- 1065,1078 ---- { vec[1] = gen_rtx (REG, SImode, i); ! if (!reg_referenced_p (vec[1], ! PATTERN (XVECEXP (final_sequence, 0, 1)))) break; } + + print_slot (final_sequence); output_asm_insn ("mov.l %1,@-r15", vec); output_asm_insn ("mov.l %O0,%1", vec); ! output_asm_insn ("jmp @%1 ! 32 xcond", vec); output_asm_insn ("mov.l @r15+,%1", vec); *************** *** 1073,1079 **** extern rtx recog_operand[]; int label = lf++; ! int rn = -1; ! int need_save; ! /* fprintf (asm_out_file, "! pc %04x\n", insn_addresses[INSN_UID (insn)]);*/ switch (get_attr_length (insn)) --- 1099,1104 ---- extern rtx recog_operand[]; int label = lf++; ! ! /* fprintf (asm_out_file, "! pc %04x\n", insn_addresses[INSN_UID (insn)]);*/ switch (get_attr_length (insn)) *************** *** 1229,1235 **** continue; } } - if (rtx_equal_p (x, pool_vector[i].value)) - return pool_vector[i].label; } --- 1254,1260 ---- continue; } + if (rtx_equal_p (x, pool_vector[i].value)) + return pool_vector[i].label; } } *************** *** 1246,1250 **** /* Dump out interesting debug info */ ! rtx final_prescan_insn (insn, opvec, noperands) rtx insn; --- 1271,1275 ---- /* Dump out interesting debug info */ ! void final_prescan_insn (insn, opvec, noperands) rtx insn; *************** *** 1259,1265 **** } } - /* Stuff taken from m88k.c */ --- 1284,1290 ---- } } + /* Stuff taken from m88k.c */ *************** *** 1366,1370 **** ! pos = fprintf (file, "\n! Hitachi SH cc1 (%s) (release D-1) arguments:", version_string); output_options (file, f_options, f_len, W_options, W_len, pos, 75, " ", "\n! ", "\n\n"); --- 1391,1395 ---- ! pos = fprintf (file, "\n! Hitachi SH cc1 (%s) (release I-1) arguments:", version_string); output_options (file, f_options, f_len, W_options, W_len, pos, 75, " ", "\n! ", "\n\n"); *************** *** 1394,1398 **** } ! int andcosts (RTX) rtx RTX; --- 1419,1423 ---- } ! int andcosts (RTX) rtx RTX; *************** *** 1411,1416 **** } ! int howshift (i) ! int i; { int total = 0; --- 1436,1442 ---- } ! int ! howshift (i) ! int i; { int total = 0; *************** *** 1417,1436 **** while (i > 0) { ! if (i >= 16) { ! total++; ! i -= 16; ! } ! else if (i >= 8) { ! total++; ! i -= 8; ! } ! else if (i >= 2) { ! total++; ! i -= 2; ! } ! else if (i>=1) { ! total++; ! i--; ! } } return total; --- 1443,1466 ---- while (i > 0) { ! if (i >= 16) ! { ! total++; ! i -= 16; ! } ! else if (i >= 8) ! { ! total++; ! i -= 8; ! } ! else if (i >= 2) ! { ! total++; ! i -= 2; ! } ! else if (i >= 1) ! { ! total++; ! i--; ! } } return total; *************** *** 1443,1454 **** { /* If mult by a power of 2 then work out how we'd shift to make it */ ! int insn_cost; ! if (GET_CODE (XEXP (RTX, 1)) == CONST_INT) { int i = exact_log2 (INTVAL (XEXP (RTX, 1))); ! if (i >= 0) insn_cost = howshift (i); ! else insn_cost = 100000; } --- 1473,1484 ---- { /* If mult by a power of 2 then work out how we'd shift to make it */ ! int insn_cost = 0; ! if (GET_CODE (XEXP (RTX, 1)) == CONST_INT) { int i = exact_log2 (INTVAL (XEXP (RTX, 1))); ! if (i >= 0) insn_cost = howshift (i); ! else insn_cost = 100000; } *************** *** 1459,1463 **** usage */ if (TARGET_SMALLCODE) ! return 2; if (insn_cost > 5) return 5; --- 1489,1493 ---- usage */ if (TARGET_SMALLCODE) ! return 2; if (insn_cost > 5) return 5; *************** *** 1468,1472 **** insns in a multiply call sequence */ ! if (TARGET_SMALLCODE) { if (insn_cost > 6) --- 1498,1502 ---- insns in a multiply call sequence */ ! if (TARGET_SMALLCODE) { if (insn_cost > 6) *************** *** 1628,1632 **** { int i; - int pass; int need_align = 1; --- 1658,1661 ---- *************** *** 1707,1710 **** --- 1736,1743 ---- return 1; } + if (GET_CODE (src) == LABEL_REF) + { + return 1; + } if (GET_CODE (src) == CONST_INT) { *************** *** 1751,1755 **** int found_si = 0; rtx found_barrier = 0; - while (from && count_si < max_count_si --- 1784,1787 ---- *************** *** 1761,1766 **** found_barrier = from; } ! /* Count the length of this insn - we assume that all the pcrelloads ! will work out to be only 2 bytes long */ if (GET_CODE (from) == INSN && --- 1793,1798 ---- found_barrier = from; } ! /* Count the length of this insn - we assume that all moves will ! be 2 bytes long, except the DIs */ if (GET_CODE (from) == INSN && *************** *** 1772,1776 **** else found_si = 1; ! inc = 2; } else --- 1804,1808 ---- else found_si = 1; ! inc = (GET_MODE_SIZE (GET_MODE (src)) > 4) ? 4 : 2; } else *************** *** 1787,1795 **** if (!found_barrier) { ! /* Insert a jump around the barrier here */ rtx label = gen_label_rtx (); /* Walk back to be just before any jump */ while (GET_CODE (from) == JUMP_INSN ! || GET_CODE (from) == NOTE) { from = PREV_INSN (from); --- 1819,1830 ---- if (!found_barrier) { ! /* We didn't find a barrier in time to ! dump our stuff, so we'll make one */ rtx label = gen_label_rtx (); /* Walk back to be just before any jump */ + from = PREV_INSN (from); while (GET_CODE (from) == JUMP_INSN ! || GET_CODE (from) == NOTE ! || GET_CODE (from) == CODE_LABEL) { from = PREV_INSN (from); *************** *** 1837,1841 **** { rtx insn; - int limit; for (insn = first; insn; insn = NEXT_INSN (insn)) { --- 1872,1875 ---- *************** *** 1896,1900 **** /* Called from the md file, set up the operands of a compare instruction */ ! int from_compare (operands, code) rtx *operands; --- 1930,1934 ---- /* Called from the md file, set up the operands of a compare instruction */ ! void from_compare (operands, code) rtx *operands; *************** *** 1906,1910 **** sh_compare_op0 = force_reg (SImode, sh_compare_op0); if (sh_compare_op1 != const0_rtx) ! sh_compare_op1 = force_reg (SImode, sh_compare_op1); } operands[1] = sh_compare_op0; --- 1940,1944 ---- sh_compare_op0 = force_reg (SImode, sh_compare_op0); if (sh_compare_op1 != const0_rtx) ! sh_compare_op1 = force_reg (SImode, sh_compare_op1); } operands[1] = sh_compare_op0; *************** *** 1924,1954 **** ! /* Framefull frame looks like: ! arg-5 ! arg-4 ! [ if current_function_anonymous_args ! arg-3 ! arg-2 ! arg-1 ! arg-0 ] ! saved-fp ! saved-r10 ! saved-r11 ! saved-r12 ! saved-pr ! local-n ! .. ! local-1 ! local-0 <- fp points here ! If TARGET_SMALLCALL, then the preserved registers are pushed by a ! wrapper before the routine is entered, so the regs are always pushed ! and there are two pr's on the stack - the caller and the wrapper. ! */ ! /* Code to generate prologue and epilogue sequences */ --- 1958,2022 ---- ! /* Add this function to the list of ones seen - temporary ! gross hack to try out bsrs. */ ! struct flist ! { ! char *name; ! struct flist *next; ! }; ! struct flist *head; ! static void ! add_function (name) ! char *name; ! { ! struct flist *n = (struct flist *) xmalloc (sizeof (struct flist)); ! int l = strlen (name) + 1; ! n->name = xmalloc (l); ! memcpy (n->name, name, l); ! n->next = head; ! head = n; ! } ! ! static int ! seen_function (name) ! char *name; ! { ! struct flist *p = head; ! for (p = head; p; p = p->next) ! { ! if (strcmp (p->name, name) == 0) ! return 1; ! } ! return 0; ! } + /* Framefull frame looks like: ! arg-5 ! arg-4 ! [ if current_function_anonymous_args ! arg-3 ! arg-2 ! arg-1 ! arg-0 ] ! saved-fp ! saved-r10 ! saved-r11 ! saved-r12 ! saved-pr ! local-n ! .. ! local-1 ! local-0 <- fp points here ! ! ! If TARGET_SMALLCALL, then the preserved registers are pushed by a ! wrapper before the routine is entered, so the regs are always pushed ! and there are two pr's on the stack - the caller and the wrapper. ! */ ! /* Code to generate prologue and epilogue sequences */ *************** *** 1958,1962 **** int live_regs_mask; int d; ! live_regs_mask = calc_live_regs (&d); --- 2026,2030 ---- int live_regs_mask; int d; ! extern tree current_function_decl; live_regs_mask = calc_live_regs (&d); *************** *** 1985,1988 **** --- 2053,2062 ---- emit_insn (gen_movsi (frame_pointer_rtx, stack_pointer_rtx)); } + if (TARGET_BSR) + { + add_function (IDENTIFIER_POINTER (DECL_NAME (current_function_decl))); + } + + } *************** *** 1996,1999 **** --- 2070,2074 ---- live_regs_mask = calc_live_regs (&d); + if (frame_pointer_needed) { *************** *** 2028,2036 **** int initial_elimination_offset (from, to) { int regs_saved; - int regs_saved_mask = calc_live_regs (®s_saved); int total_saved_regs_space; int total_auto_space = get_frame_size (); total_saved_regs_space = (regs_saved) * 4; --- 2103,2114 ---- int initial_elimination_offset (from, to) + int from; + int to; { int regs_saved; int total_saved_regs_space; int total_auto_space = get_frame_size (); + + calc_live_regs (®s_saved); total_saved_regs_space = (regs_saved) * 4; *************** *** 2075,2079 **** { pragma_interrupt = 1; ! return; } if (psize == 5 && strncmp (pbuf, "trapa", 5) == 0) --- 2153,2157 ---- { pragma_interrupt = 1; ! return ' '; } if (psize == 5 && strncmp (pbuf, "trapa", 5) == 0) *************** *** 2080,2084 **** { pragma_interrupt = pragma_trapa = 1; ! return; } c = getc (file); --- 2158,2162 ---- { pragma_interrupt = pragma_trapa = 1; ! return ' '; } c = getc (file); *************** *** 2089,2093 **** /* insn expand helpers */ ! /* Emit insns to perform a call. If TARGET_SHORTADDR then use a bsr. If TARGET_SMALLCALL, then load the target address into r1 and call __saveargs, otherwise --- 2167,2171 ---- /* insn expand helpers */ ! /* Emit insns to perform a call. If TARGET_SHORTADDR then use a bsr. If TARGET_SMALLCALL, then load the target address into r1 and call __saveargs, otherwise *************** *** 2104,2130 **** rtx numargs = operands[isa_retval + 1]; ! if (TARGET_BSR) { call = gen_rtx (CALL, VOIDmode, call_target, numargs); } ! else { ! ! if (GET_CODE (call_target) == MEM) ! { ! call_target = force_reg (Pmode, ! XEXP (call_target, 0)); ! } ! if (TARGET_SMALLCALL) ! { ! rtx tmp = gen_reg_rtx (SImode); ! rtx r1 = gen_rtx (REG, SImode, 1); ! emit_move_insn (tmp, gen_rtx (SYMBOL_REF, SImode, "__saveargs")); ! emit_move_insn (r1, call_target); ! emit_insn (gen_rtx (USE, VOIDmode, r1)); ! call_target = tmp; ! } ! call = gen_rtx (CALL, VOIDmode, gen_rtx (MEM, SImode, call_target), numargs); ! } if (isa_retval) { --- 2182,2208 ---- rtx numargs = operands[isa_retval + 1]; ! if (TARGET_BSR && bsr_operand (call_target, VOIDmode)) { call = gen_rtx (CALL, VOIDmode, call_target, numargs); } ! else ! { ! if (GET_CODE (call_target) == MEM) ! { ! call_target = force_reg (Pmode, ! XEXP (call_target, 0)); ! } ! if (TARGET_SMALLCALL) ! { ! rtx tmp = gen_reg_rtx (SImode); ! rtx r1 = gen_rtx (REG, SImode, 1); ! emit_move_insn (tmp, gen_rtx (SYMBOL_REF, SImode, "__saveargs")); ! emit_move_insn (r1, call_target); ! emit_insn (gen_rtx (USE, VOIDmode, r1)); ! call_target = tmp; ! } ! call = gen_rtx (CALL, VOIDmode, gen_rtx (MEM, SImode, call_target), numargs); ! } if (isa_retval) { *************** *** 2135,2139 **** gen_rtvec (2, call, ! gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, 17))))); } --- 2213,2217 ---- gen_rtvec (2, call, ! gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, 17))))); } *************** *** 2153,2165 **** { /* Any MEM(label_ref) is ok, that's a pcrel load */ ! if (GET_CODE (op) == MEM && ! GET_CODE (XEXP (op, 0)) == LABEL_REF) return 1; ! /* No predec allowed */ ! if (GET_CODE (op) == MEM ! && GET_CODE (XEXP (op, 0)) == PRE_DEC) ! return 0; if ((mode == QImode || mode == HImode) --- 2231,2263 ---- { /* Any MEM(label_ref) is ok, that's a pcrel load */ ! if (GET_CODE (op) == MEM ! && GET_CODE (XEXP (op, 0)) == LABEL_REF) return 1; ! if (GET_CODE (op) == MEM) ! { ! rtx inside = XEXP (op, 0); ! if (GET_CODE (inside) == CONST) ! inside = XEXP (inside, 0); ! ! if (GET_CODE (inside) == LABEL_REF) ! return 1; ! if (GET_CODE (inside) == PLUS ! && GET_CODE (XEXP (inside,0)) == LABEL_REF ! && GET_CODE (XEXP (inside,1)) == CONST_INT) ! return 1; ! ! /* No post inc allowed */ ! if (GET_CODE (inside) == POST_DEC ! || GET_CODE (inside) == PRE_INC ! || GET_CODE (inside) == PRE_DEC) ! return 0; ! ! /* Can't do that with large modes */ ! if (GET_CODE (inside) == POST_INC ! && GET_MODE_SIZE (mode) > 4) ! return 0; ! } if ((mode == QImode || mode == HImode) *************** *** 2186,2189 **** --- 2284,2288 ---- enum machine_mode mode; { + /* No pre dec allowed */ if (GET_CODE (op) == MEM && (GET_CODE (XEXP (op, 0)) == PRE_INC *************** *** 2192,2195 **** --- 2291,2299 ---- return 0; + if (GET_CODE (op) == MEM + && GET_CODE (XEXP (op, 0)) == PRE_DEC + && GET_MODE_SIZE (mode) > 4) + return 0; + return general_operand (op, mode); } *************** *** 2201,2209 **** int bsr_operand (op, mode) ! rtx op; ! enum machine_mode mode; { ! if (GET_CODE (op) == SYMBOL_REF) ! return 1; return 0; } --- 2305,2321 ---- int bsr_operand (op, mode) ! rtx op; ! enum machine_mode mode; { ! if (TARGET_BSR) ! { ! if (GET_CODE (op) == SYMBOL_REF) ! { ! if (!strcmp (XSTR (op, 0), ! IDENTIFIER_POINTER (DECL_NAME (current_function_decl)))) ! return 1; ! return (seen_function (XSTR (op, 0))); ! } ! } return 0; } *************** *** 2330,2334 **** return 1; #if 0 ! Turned off till mac is understood if (GET_CODE (op) == MEM) return 1; --- 2442,2446 ---- return 1; #if 0 ! Turned off till mac is understood if (GET_CODE (op) == MEM) return 1; *************** *** 2350,2374 **** (otherwise it is an extra parameter matching an ellipsis). */ ! rtx sh_function_arg (cum, mode, type, named) ! CUMULATIVE_ARGS cum; ! enum machine_mode mode; ! tree type; ! int named; { if (named) { ! int rr = (ROUND_REG ((cum), (mode))); if (rr < NPARM_REGS) { ! return ((((mode) != BLKmode ! && ((type)==0 || ! TREE_ADDRESSABLE ((tree)(type))) ! && ((type)==0 || (mode) != BLKmode ! || (TYPE_ALIGN ((type)) % PARM_BOUNDARY == 0)) ! ? gen_rtx (REG, (mode), ! (FIRST_PARM_REG + rr)): 0))); ! } } return 0; --- 2462,2486 ---- (otherwise it is an extra parameter matching an ellipsis). */ ! rtx sh_function_arg (cum, mode, type, named) ! CUMULATIVE_ARGS cum; ! enum machine_mode mode; ! tree type; ! int named; { if (named) { ! int rr = (ROUND_REG ((cum), (mode))); if (rr < NPARM_REGS) { ! return (((type) == 0 || !TREE_ADDRESSABLE ((tree) (type))) ! && ((type) == 0 || (mode) != BLKmode ! || (TYPE_ALIGN ((type)) % PARM_BOUNDARY == 0)) ! ? gen_rtx (REG, (mode), ! (FIRST_PARM_REG + rr)) ! : 0); ! } } return 0; *************** *** 2388,2399 **** int NAMED; { ! if ((CUM) < NPARM_REGS) { ! if (((TYPE)==0 || ! TREE_ADDRESSABLE ((tree)(TYPE))) ! && ((TYPE)==0 || (MODE) != BLKmode ! || (TYPE_ALIGN ((TYPE)) % PARM_BOUNDARY == 0)) ! && ((CUM) + ((MODE) == BLKmode ! ? ROUND_ADVANCE (int_size_in_bytes (TYPE)) ! : ROUND_ADVANCE (GET_MODE_SIZE (MODE))) - NPARM_REGS > 0)) { return NPARM_REGS - CUM; --- 2500,2510 ---- int NAMED; { ! if ((CUM) < NPARM_REGS) { ! if (((TYPE) == 0 || !TREE_ADDRESSABLE ((tree) (TYPE))) ! && ((TYPE) == 0 || (TYPE_ALIGN ((TYPE)) % PARM_BOUNDARY == 0)) ! && ((CUM) + ((MODE) == BLKmode ! ? ROUND_ADVANCE (int_size_in_bytes (TYPE)) ! : ROUND_ADVANCE (GET_MODE_SIZE (MODE))) - NPARM_REGS > 0)) { return NPARM_REGS - CUM; *************** *** 2403,2404 **** --- 2514,2525 ---- } + /* Turn this on to recognise shift insns which aren't supported in the + hardware. This will allow the combiner to notice more patterns, + but the down side is that the asm outputter will have to emit + several instructions for each shift which isn't possible in the + hardware, this makes scheduling perform badly .*/ + + int fake_shift() + { + return 0; + } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/sh.h gcc-2.6.1/config/sh/sh.h *** gcc-2.6.0/config/sh/sh.h Wed Apr 20 15:17:02 1994 --- gcc-2.6.1/config/sh/sh.h Tue Sep 6 14:36:43 1994 *************** *** 1,3 **** ! /* Definitions of target machine for GNU compiler, for Hitachi Super-H. Copyright (C) 1993, 1994 Free Software Foundation, Inc. --- 1,4 ---- ! /* Definitions of target machine for GNU compiler, ! for Hitachi Super-H. Copyright (C) 1993, 1994 Free Software Foundation, Inc. *************** *** 31,34 **** --- 32,44 ---- #define SDB_DEBUGGING_INFO 1 + /* CYGNUS LOCAL stabs-in-coff */ + /* Output DBX (stabs) debugging information if doing -gstabs. */ + + #define DBX_DEBUGGING_INFO + + /* Generate SDB debugging information by default. */ + + #define PREFERRED_DEBUGGING_TYPE SDB_DEBUG + #define SDB_DELIM ";" *************** *** 84,87 **** --- 94,98 ---- #define BSR_BIT (1<<26) #define SHORTADDR_BIT (1<<27) + #define PACKSTRUCT_BIT (1<<28) /* Nonzero if we should generate code using type 0 insns */ *************** *** 142,145 **** --- 153,157 ---- /* Nonzero if using Hitachi's calling convention */ #define TARGET_HITACHI (target_flags & HITACHI_BIT) + #define TARGET_PARANOID (target_flags & PARANOID_BIT) #define TARGET_RETR2 (target_flags & RETR2_BIT) *************** *** 147,150 **** --- 159,164 ---- #define TARGET_BSR (target_flags & BSR_BIT) + /* Nonzero if packing structures as small as they'll go (incompatible with Hitachi's compiler) */ + #define TARGET_PACKSTRUCT (target_flags & PACKSTRUCT_BIT) #define TARGET_SWITCHES \ *************** *** 171,174 **** --- 185,189 ---- {"shortaddr", ( SHORTADDR_BIT) }, \ {"bsr", ( BSR_BIT) }, \ + {"packstruct",( PACKSTRUCT_BIT) }, \ {"", TARGET_DEFAULT} \ } *************** *** 207,211 **** max_count_hi = atoi (max_hi); \ else \ ! max_count_hi = 505; \ if (TARGET_BSR) \ flag_no_function_cse = 1; \ --- 222,226 ---- max_count_hi = atoi (max_hi); \ else \ ! max_count_hi = 500; \ if (TARGET_BSR) \ flag_no_function_cse = 1; \ *************** *** 265,271 **** #define FASTEST_ALIGNMENT 32 - /* Every structures size must be a multiple of 32 bits. */ - #define STRUCTURE_SIZE_BOUNDARY 32 - /* Make strings word-aligned so strcpy from constants will be faster. */ #define CONSTANT_ALIGNMENT(EXP, ALIGN) \ --- 280,283 ---- *************** *** 280,283 **** --- 292,300 ---- && (ALIGN) < FASTEST_ALIGNMENT ? FASTEST_ALIGNMENT : (ALIGN)) + /* Number of bits which any structure or union's size must be a + multiple of. Each structure or union's size is rounded up to a + multiple of this. */ + #define STRUCTURE_SIZE_BOUNDARY (TARGET_PACKSTRUCT ? 8 : 32) + /* Set this nonzero if move instructions will actually fail to work when given unaligned data. */ *************** *** 306,312 **** from 0 to just below FIRST_PSEUDO_REGISTER. All registers that the compiler knows about must be given numbers, ! even those that are not normally considered general registers. ! ! */ #define AP_REG 16 --- 323,327 ---- from 0 to just below FIRST_PSEUDO_REGISTER. All registers that the compiler knows about must be given numbers, ! even those that are not normally considered general registers. */ #define AP_REG 16 *************** *** 786,790 **** No definition is equivalent to always zero. */ ! #define EXIT_IGNORE_STACK 0 /* Generate the assembly code for function exit --- 801,805 ---- No definition is equivalent to always zero. */ ! #define EXIT_IGNORE_STACK 1 /* Generate the assembly code for function exit *************** *** 868,872 **** #define LEGITIMATE_CONSTANT_P(X) \ ! (GET_CODE(X) != CONST_DOUBLE && GET_CODE(X) != LABEL_REF) --- 883,887 ---- #define LEGITIMATE_CONSTANT_P(X) \ ! (GET_CODE(X) != CONST_DOUBLE /*&& GET_CODE(X) != LABEL_REF*/) *************** *** 878,884 **** The symbol REG_OK_STRICT causes the latter definition to be used. */ ! #define MODE_DISP_OK_4(X,MODE) ((GET_MODE_SIZE(MODE)==4) && ((unsigned)INTVAL(X)<64)) ! #define MODE_DISP_OK_8(X,MODE) ((GET_MODE_SIZE(MODE)==8) && ((unsigned)INTVAL(X)<60)) ! #define MODE_DISP_OK_2(X,MODE) ((GET_MODE_SIZE(MODE)==2) && ((unsigned)INTVAL(X)<32) && TARGET_TRYR0) #define MODE_DISP_OK_1(X,MODE) ((GET_MODE_SIZE(MODE)==1) && ((unsigned)INTVAL(X)<16) && TARGET_TRYR0) --- 893,899 ---- The symbol REG_OK_STRICT causes the latter definition to be used. */ ! #define MODE_DISP_OK_4(X,MODE) ((GET_MODE_SIZE(MODE)==4) && ((unsigned)INTVAL(X)<64) && (!(INTVAL(X) &3))) ! #define MODE_DISP_OK_8(X,MODE) ((GET_MODE_SIZE(MODE)==8) && ((unsigned)INTVAL(X)<60) && (!(INTVAL(X) &3))) ! #define MODE_DISP_OK_2(X,MODE) ((GET_MODE_SIZE(MODE)==2) && ((unsigned)INTVAL(X)<32) && TARGET_TRYR0 && (!INTVAL(X) &1)) #define MODE_DISP_OK_1(X,MODE) ((GET_MODE_SIZE(MODE)==1) && ((unsigned)INTVAL(X)<16) && TARGET_TRYR0) *************** *** 897,901 **** #define REG_OK_FOR_PRE_POST_P(X) \ ! (REG_OK_FOR_INDEX_P (X)) #else --- 912,916 ---- #define REG_OK_FOR_PRE_POST_P(X) \ ! (REG_OK_FOR_BASE_P (X)) #else *************** *** 909,918 **** #define REG_OK_FOR_PRE_POST_P(X) \ ! (REGNO_OK_FOR_INDEX_P (REGNO (X))) #endif /* The Q is a pc relative load operand */ ! #define EXTRA_CONSTRAINT_Q(OP) \ ! (GET_CODE (OP) == MEM && GET_CODE (XEXP (OP,0)) == LABEL_REF) /* The U is a label ref */ --- 924,938 ---- #define REG_OK_FOR_PRE_POST_P(X) \ ! (REGNO_OK_FOR_BASE_P (REGNO (X))) #endif /* The Q is a pc relative load operand */ ! #define EXTRA_CONSTRAINT_Q(OP) \ ! (GET_CODE (OP) == MEM && \ ! ((GET_CODE (XEXP (OP, 0)) == LABEL_REF) \ ! || (GET_CODE (XEXP (OP, 0)) == CONST \ ! && GET_CODE (XEXP (XEXP (OP, 0), 0)) == PLUS \ ! && GET_CODE (XEXP (XEXP (XEXP (OP, 0), 0), 0)) == LABEL_REF \ ! && GET_CODE (XEXP (XEXP (XEXP (OP, 0), 0), 1)) == CONST_INT))) /* The U is a label ref */ *************** *** 920,927 **** (GET_CODE (OP) == LABEL_REF) ! #define IS_INDEX(OP) \ ! ((GET_CODE(OP) == PLUS && \ ! (INDEX_REGISTER_RTX_P(XEXP(OP,0)) && BASE_REGISTER_RTX_P(XEXP(OP,1))) || \ ! (INDEX_REGISTER_RTX_P(XEXP(OP,1)) && BASE_REGISTER_RTX_P(XEXP(OP,0))))) --- 940,947 ---- (GET_CODE (OP) == LABEL_REF) ! #define IS_INDEX(OP) \ ! ((GET_CODE (OP) == PLUS && \ ! (INDEX_REGISTER_RTX_P (XEXP (OP, 0)) && BASE_REGISTER_RTX_P (XEXP (OP, 1))) || \ ! (INDEX_REGISTER_RTX_P (XEXP (OP, 1)) && BASE_REGISTER_RTX_P (XEXP (OP, 0))))) *************** *** 1054,1057 **** --- 1074,1080 ---- #define SIZE_TYPE "unsigned int" + #define WCHAR_TYPE "short unsigned int" + #define WCHAR_TYPE_SIZE 16 + /* Don't cse the address of the function being compiled. */ /*#define NO_RECURSIVE_FUNCTION_CSE 1*/ *************** *** 1196,1206 **** /* How to change between sections. */ ! #define TEXT_SECTION_ASM_OP "\t.text" ! #define DATA_SECTION_ASM_OP "\t.data" ! #define CTORS_SECTION_ASM_OP "\t.section\t.ctors\n" ! #define DTORS_SECTION_ASM_OP "\t.section\t.dtors\n" ! #define INIT_SECTION_ASM_OP "\t.section\t.init\n" ! #define EXTRA_SECTIONS in_ctors, in_dtors ! #define EXTRA_SECTION_FUNCTIONS \ void \ --- 1219,1228 ---- /* How to change between sections. */ ! #define TEXT_SECTION_ASM_OP "\t.text" ! #define DATA_SECTION_ASM_OP "\t.data" ! #define CTORS_SECTION_ASM_OP "\t.section\t.ctors\n" ! #define DTORS_SECTION_ASM_OP "\t.section\t.dtors\n" ! #define INIT_SECTION_ASM_OP "\t.section\t.init\n" ! #define EXTRA_SECTIONS in_ctors, in_dtors #define EXTRA_SECTION_FUNCTIONS \ void \ *************** *** 1221,1225 **** in_section = in_dtors; \ } \ ! } /* Assemble generic sections. --- 1243,1247 ---- in_section = in_dtors; \ } \ ! } /* Assemble generic sections. *************** *** 1463,1467 **** #define TARGET_MEM_FUNCTIONS ! #define HANDLE_PRAGMA(finput) handle_pragma (finput) /* Set when processing a function with pragma interrupt turned on. */ --- 1485,1489 ---- #define TARGET_MEM_FUNCTIONS ! #define HANDLE_PRAGMA(finput) return handle_pragma (finput) /* Set when processing a function with pragma interrupt turned on. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/sh.md gcc-2.6.1/config/sh/sh.md *** gcc-2.6.0/config/sh/sh.md Wed Apr 20 15:17:05 1994 --- gcc-2.6.1/config/sh/sh.md Fri Sep 9 19:33:37 1994 *************** *** 159,162 **** --- 159,164 ---- (eq_attr "type" "jump") (const_string "no") (eq_attr "type" "pload") (const_string "no") + (eq_attr "type" "pcloadsi") (const_string "no") + (eq_attr "type" "pcloadhi") (const_string "no") (eq_attr "type" "return") (const_string "no") (eq_attr "length" "2") (const_string "yes") *************** *** 164,167 **** --- 166,170 ---- ] (const_string "yes"))) + ;; ------------------------------------------------------------------------- *************** *** 260,296 **** ;; ------------------------------------------------------------------------- - (define_insn "addc" - [(set (match_operand:SI 0 "arith_reg_operand" "=r") - (plus:SI (reg:SI 18) - (plus:SI (match_operand:SI 1 "arith_reg_operand" "%0") - (match_operand:SI 2 "arith_reg_operand" "r")))) - (set (reg:SI 18) (gt:SI (match_dup 1) (match_dup 0)))] - "" - "addc %2,%0") - - ;; this should be a define split. ! (define_expand "adddi3" ! [(set (match_operand:DI 0 "register_operand" "") ! (plus:DI (match_operand:DI 1 "register_operand" "") ! (match_operand:DI 2 "register_operand" "")))] "" ! " ! { ! rtx low_a = gen_rtx (SUBREG, SImode, operands[1], 1); ! rtx low_b = gen_rtx (SUBREG, SImode, operands[2], 1); ! rtx low_s = gen_rtx (SUBREG, SImode, operands[0], 1); ! ! rtx high_a = gen_rtx (SUBREG, SImode, operands[1], 0); ! rtx high_b = gen_rtx (SUBREG, SImode, operands[2], 0); ! rtx high_s = gen_rtx (SUBREG, SImode, operands[0], 0); ! ! emit_insn (gen_clrt ()); ! emit_insn (gen_addc (low_s, low_a, low_b)); ! emit_insn (gen_addc (high_s, high_a, high_b)); - DONE; - }") (define_insn "addsi3_real" --- 263,277 ---- ;; ------------------------------------------------------------------------- ;; this should be a define split. ! (define_insn "adddi3" ! [(set (match_operand:DI 0 "register_operand" "=r") ! (plus:DI (match_operand:DI 1 "register_operand" "%0") ! (match_operand:DI 2 "register_operand" "r"))) ! (clobber (reg:SI 18))] "" ! "clrt\;addc %R2,%R0\;addc %2,%0" ! [(set_attr "length" "6")]) (define_insn "addsi3_real" *************** *** 315,328 **** ;; ------------------------------------------------------------------------- (define_insn "subdi3" ! [(set (match_operand:DI 0 "arith_reg_operand" "=r") ! (minus:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (match_operand:DI 2 "arith_reg_operand" "r"))) (clobber (reg:SI 18))] "" "clrt\;subc %R2,%R0\;subc %2,%0" ! [(set_attr "length" "6") ! (set_attr "in_delay_slot" "no") ! (set_attr "type" "arith")]) (define_insn "subsi3" --- 296,308 ---- ;; ------------------------------------------------------------------------- + (define_insn "subdi3" ! [(set (match_operand:DI 0 "register_operand" "=r") ! (minus:DI (match_operand:DI 1 "register_operand" "%0") ! (match_operand:DI 2 "register_operand" "r"))) (clobber (reg:SI 18))] "" "clrt\;subc %R2,%R0\;subc %2,%0" ! [(set_attr "length" "6")]) (define_insn "subsi3" *************** *** 381,385 **** (clobber (reg:SI 18)) (clobber (reg:SI 17)) ! (clobber (reg:SI 4)) (clobber (reg:SI 3)) (use (match_operand:SI 0 "register_operand" "r"))] --- 361,366 ---- (clobber (reg:SI 18)) (clobber (reg:SI 17)) ! (clobber (reg:SI 1)) ! (clobber (reg:SI 2)) (clobber (reg:SI 3)) (use (match_operand:SI 0 "register_operand" "r"))] *************** *** 399,403 **** (clobber (reg:SI 18)) (clobber (reg:SI 17)) ! (clobber (reg:SI 4)) (clobber (reg:SI 3)) (use (match_dup 3))]) --- 380,385 ---- (clobber (reg:SI 18)) (clobber (reg:SI 17)) ! (clobber (reg:SI 1)) ! (clobber (reg:SI 2)) (clobber (reg:SI 3)) (use (match_dup 3))]) *************** *** 505,516 **** (reg:SI 21))] "TARGET_SH2" ! " ! { ! if (!TARGET_SH2) ! { ! emit_insn (gen_mulsi3_call (operands[0], operands[1], operands[2])); ! DONE; ! } ! }") (define_insn "" --- 487,491 ---- (reg:SI 21))] "TARGET_SH2" ! "") (define_insn "" *************** *** 660,664 **** (match_operand:SI 2 "immediate_operand" "n"))) (clobber (reg:SI 18))] ! "" "*return output_shift(\"shll\", operands[0], operands[2], ASHIFT);" [(set_attr "length" "12") --- 635,639 ---- (match_operand:SI 2 "immediate_operand" "n"))) (clobber (reg:SI 18))] ! "fake_shift()" "*return output_shift(\"shll\", operands[0], operands[2], ASHIFT);" [(set_attr "length" "12") *************** *** 753,757 **** (match_operand:SI 2 "immediate_operand" "n"))) (clobber (reg:SI 18))] ! "" "* return output_shift (\"shlr\", operands[0], operands[2], LSHIFTRT);" [(set_attr "length" "12") --- 728,732 ---- (match_operand:SI 2 "immediate_operand" "n"))) (clobber (reg:SI 18))] ! "fake_shift()" "* return output_shift (\"shlr\", operands[0], operands[2], LSHIFTRT);" [(set_attr "length" "12") *************** *** 770,774 **** [(set (match_operand:DI 0 "arith_reg_operand" "=r") (ashift:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (match_operand:DI 2 "immediate_operand" "I"))) (clobber (reg:SI 18))] "" --- 745,749 ---- [(set (match_operand:DI 0 "arith_reg_operand" "=r") (ashift:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (const_int 1))) (clobber (reg:SI 18))] "" *************** *** 789,793 **** [(set (match_operand:DI 0 "arith_reg_operand" "=r") (lshiftrt:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (match_operand:DI 2 "immediate_operand" "I"))) (clobber (reg:SI 18))] "" --- 764,768 ---- [(set (match_operand:DI 0 "arith_reg_operand" "=r") (lshiftrt:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (const_int 1))) (clobber (reg:SI 18))] "" *************** *** 807,811 **** [(set (match_operand:DI 0 "arith_reg_operand" "=r") (ashiftrt:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (match_operand:DI 2 "immediate_operand" ""))) (clobber (reg:SI 18))] "" --- 782,786 ---- [(set (match_operand:DI 0 "arith_reg_operand" "=r") (ashiftrt:DI (match_operand:DI 1 "arith_reg_operand" "0") ! (const_int 1))) (clobber (reg:SI 18))] "" *************** *** 827,839 **** ;; ------------------------------------------------------------------------- ! (define_insn "negdi2" ! [(set (match_operand:DI 0 "arith_reg_operand" "=&r") ! (neg:DI (match_operand:DI 1 "arith_reg_operand" "0"))) ! (clobber (reg:SI 18))] "" ! "clrt\;negc %R1,%R0\;negc %1,%0" ! [(set_attr "length" "6") (set_attr "type" "arith")]) (define_insn "negsi2" [(set (match_operand:SI 0 "arith_reg_operand" "=r") --- 802,834 ---- ;; ------------------------------------------------------------------------- ! ! (define_insn "negc" ! [(set (match_operand:SI 0 "arith_reg_operand" "=r") ! (neg:SI (plus:SI (reg:SI 18) (match_operand:SI 1 "arith_reg_operand" "r"))))] "" ! "negc %1,%0" ! [(set_attr "length" "2") (set_attr "type" "arith")]) + (define_expand "negdi2" + [(set (match_operand:DI 0 "arith_reg_operand" "=r") + (neg:DI (match_operand:DI 1 "arith_reg_operand" "r"))) + (clobber (reg:SI 18))] + "" + "{ + rtx low_src = operand_subword (operands[1], 1, 0, DImode); + rtx high_src = operand_subword (operands[1], 0, 0, DImode); + + rtx low_dst = operand_subword (operands[0], 1, 1, DImode); + rtx high_dst = operand_subword (operands[0], 0, 1, DImode); + + emit_insn (gen_clrt ()); + emit_insn (gen_negc (low_dst, low_src)); + emit_insn (gen_negc (high_dst, high_src)); + DONE; + } + ") + + (define_insn "negsi2" [(set (match_operand:SI 0 "arith_reg_operand" "=r") *************** *** 983,1012 **** (match_operand:SI 1 "general_movsrc_operand" "Q,rI,>m,xl,t,r,xl,r,>,r,i"))] "" ! "* ! { ! switch (which_alternative) ! { ! case 0: ! switch (get_attr_length(insn)) ! { ! case 2: ! return \"mov.l %1,%0\"; ! case 12: ! return \"mov.l TA%*,%0\;bra TB%*\;mov.l @%0,%0\;.align 2\;TA%*: .long %1\;TB%*:%^\"; ! } ! case 1: return \"mov %1,%0\"; ! case 2: return \"mov.l %1,%0\"; ! case 3: return \"sts %1,%0\"; ! case 4: return \"movt %0\"; ! case 5: return \"mov.l %1,%0\"; ! case 6: return \"sts.l %1,%0\"; ! case 7: return \"lds %1,%0\"; ! case 8: return \"lds.l %1,%0\"; ! case 9: return \"tst %1,%1\;bt T%*\;bra F%*\;sett\;T%*:clrt\;F%*:%^\"; ! case 10: return \"fake %1,%0\"; ! } ! }" ! [(set_attr "length" "*,2,2,2,2,2,2,2,2,6,2") ! (set_attr "type" "pcloadsi,move,load,move,store,store,move,load,move,move,move")]) (define_expand "movsi" --- 978,994 ---- (match_operand:SI 1 "general_movsrc_operand" "Q,rI,>m,xl,t,r,xl,r,>,r,i"))] "" ! "@ ! mov.l %1,%0 ! mov %1,%0 ! mov.l %1,%0 ! sts %1,%0 ! movt %0 ! mov.l %1,%0 ! sts.l %1,%0 ! lds %1,%0 ! lds.l %1,%0 ! tst %1,%1\;bt T%*\;bra F%*\;sett\;T%*:clrt\;F%*:%^ ! fake %1,%0" ! [(set_attr "type" "pcloadsi,move,load,move,store,store,move,load,move,move,move")]) (define_expand "movsi" *************** *** 1043,1067 **** (match_operand:HI 1 "general_movsrc_operand" "Q,rI,>m,t,r,i,l,r"))] "" ! "* ! { ! switch (which_alternative) ! { ! case 0: ! switch (get_attr_length(insn)) ! { ! case 2: ! return \"mov.w %1,%0\"; ! case 12: ! return \"mov.l TA%*,%0\;bra TB%*\;mov.w @%0,%0\;.align 2\;TA%*: .long %1\;TB%*:%^\"; ! } ! case 1: return \"mov %1,%0\"; ! case 2: return \"mov.w %1,%0\"; ! case 3: return \"movt %0\"; ! case 4: return \"mov.w %1,%0\"; ! case 5: return \"fake %1,%0\"; ! case 6: return \"sts %1,%0\"; ! case 7: return \"lds %1,%0\"; ! } ! }" [(set_attr "length" "*,2,2,2,2,2,2,2") (set_attr "type" "pcloadhi,move,load,move,store,move,move,move")]) --- 1025,1037 ---- (match_operand:HI 1 "general_movsrc_operand" "Q,rI,>m,t,r,i,l,r"))] "" ! "@ ! mov.w %1,%0 ! mov %1,%0 ! mov.w %1,%0 ! movt %0 ! mov.w %1,%0 ! fake %1,%0 ! sts %1,%0 ! lds %1,%0" [(set_attr "length" "*,2,2,2,2,2,2,2") (set_attr "type" "pcloadhi,move,load,move,store,move,move,move")]) *************** *** 1090,1093 **** --- 1060,1101 ---- (set_attr "type" "pcloadsi,move,load,store,move")]) + ;; If the output is a register and the input is memory, we have to be careful + ;; and see which word needs to be loaded first. + ;; + (define_split + [(set (match_operand:DI 0 "general_movdst_operand" "") + (match_operand:DI 1 "general_movsrc_operand" ""))] + "! (GET_CODE (operands[0]) == REG + && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER) + && ! (GET_CODE (operands[1]) == REG + && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER) + && ! (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG + && ! reload_completed + && reg_overlap_mentioned_p (operands[0], operands[1])) + && ! EXTRA_CONSTRAINT_Q (operands[1])" + [(set (match_dup 2) (match_dup 3)) + (set (match_dup 4) (match_dup 5))] + " + { if (GET_CODE (operands[0]) != REG + || ! refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1, + operands[1], 0)) + { + operands[2] = operand_subword (operands[0], 0, 0, DImode); + operands[3] = operand_subword (operands[1], 0, 0, DImode); + operands[4] = operand_subword (operands[0], 1, 0, DImode); + operands[5] = operand_subword (operands[1], 1, 0, DImode); + } + else + { + operands[2] = operand_subword (operands[0], 1, 0, DImode); + operands[3] = operand_subword (operands[1], 1, 0, DImode); + operands[4] = operand_subword (operands[0], 0, 0, DImode); + operands[5] = operand_subword (operands[1], 0, 0, DImode); + } + + if (operands[2] == 0 || operands[3] == 0 + || operands[4] == 0 || operands[5] == 0) + FAIL; + }") *************** *** 1115,1118 **** --- 1123,1165 ---- (set_attr "type" "move,load,store")]) + ;; If the output is a register and the input is memory, we have to be careful + ;; and see which word needs to be loaded first. + ;; + (define_split + [(set (match_operand:DF 0 "general_movdst_operand" "") + (match_operand:DF 1 "general_movsrc_operand" ""))] + "! (GET_CODE (operands[0]) == REG + && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER) + && ! (GET_CODE (operands[1]) == REG + && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER) + && ! (GET_CODE (operands[0]) == REG && GET_CODE (operands[1]) == REG + && ! reload_completed + && reg_overlap_mentioned_p (operands[0], operands[1]))" + [(set (match_dup 2) (match_dup 3)) + (set (match_dup 4) (match_dup 5))] + " + { if (GET_CODE (operands[0]) != REG + || ! refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1, + operands[1], 0)) + { + operands[2] = operand_subword (operands[0], 0, 0, DFmode); + operands[3] = operand_subword (operands[1], 0, 0, DFmode); + operands[4] = operand_subword (operands[0], 1, 0, DFmode); + operands[5] = operand_subword (operands[1], 1, 0, DFmode); + } + else + { + operands[2] = operand_subword (operands[0], 1, 0, DFmode); + operands[3] = operand_subword (operands[1], 1, 0, DFmode); + operands[4] = operand_subword (operands[0], 0, 0, DFmode); + operands[5] = operand_subword (operands[1], 0, 0, DFmode); + } + + if (operands[2] == 0 || operands[3] == 0 + || operands[4] == 0 || operands[5] == 0) + FAIL; + }") + + (define_expand "movdf" [(set (match_operand:DF 0 "general_movdst_operand" "") *************** *** 1444,1448 **** (label_ref (match_operand 4 "" "")) (pc))) ! (set (match_dup 6) (plus:SI (match_dup 5) (match_dup 5))) (set (reg:SI 0) (label_ref (match_operand 3 "" ""))) (parallel[(set (reg:SI 0) (plus:SI (reg:SI 0) --- 1491,1497 ---- (label_ref (match_operand 4 "" "")) (pc))) ! (set (match_dup 6) (match_dup 5)) ! (parallel[(set (match_dup 6) (ashift:SI (match_dup 6) (match_dup 7))) ! (clobber (reg:SI 18))]) (set (reg:SI 0) (label_ref (match_operand 3 "" ""))) (parallel[(set (reg:SI 0) (plus:SI (reg:SI 0) *************** *** 1458,1461 **** --- 1507,1511 ---- operands[5] = gen_reg_rtx (SImode); operands[6] = gen_reg_rtx (SImode); + operands[7] = GEN_INT (TARGET_BIGTABLE ? 2 : 1); }") *************** *** 1468,1475 **** (match_dup 0))))] "" ! "mov.w @(r0,%0),%0\;add %0,r0" [(set_attr "needs_delay_slot" "no") (set_attr "in_delay_slot" "no") ! (set_attr "length" "6")]) --- 1518,1529 ---- (match_dup 0))))] "" ! "* ! if (TARGET_BIGTABLE) ! return \"mov.l @(r0,%0),%0\;add %0,r0\"; ! else ! return \"mov.w @(r0,%0),%0\;add %0,r0\";" [(set_attr "needs_delay_slot" "no") (set_attr "in_delay_slot" "no") ! (set_attr "length" "4")]) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sh/t-sh gcc-2.6.1/config/sh/t-sh *** gcc-2.6.0/config/sh/t-sh Thu Sep 9 16:02:49 1993 --- gcc-2.6.1/config/sh/t-sh Fri Sep 9 19:33:44 1994 *************** *** 1,6 **** ! LIBGCC1 = libgcc1.null ! CROSS_LIBGCC1 = libgcc1.null ! T_CFLAGS = -DDONT_HAVE_STDIO -DDONT_HAVE_SETJMP -Dinhibit_libc ! LIBGCC2_CFLAGS=-g -O5 $(GCC_CFLAGS) --- 1,32 ---- ! CROSS_LIBGCC1 = libgcc1-asm.a ! LIB1ASMSRC = sh/lib1funcs.asm ! LIB1ASMFUNCS = _ashiftrt _movstr _mulsi3 _sdivsi3 _udivsi3 ! ! LIBGCC2_CFLAGS=-g -O5 $(GCC_CFLAGS) ! ! # CYGNUS LOCAL sh ! LANGUAGES=c c++ proto ! ! # CYGNUS LOCAL sh ! # These are really part of libgcc1, but this will cause them to be ! # built correctly, so... [taken from t-ose68k] ! ! LIB2FUNCS_EXTRA = fp-bit.c dp-bit.c ashlsi3.c ashrsi3.c lshrsi3.c ! ! ashlsi3.c: $(srcdir)/config/sh/ashlsi3.c ! cp $(srcdir)/config/sh/ashlsi3.c ashlsi3.c ! ! ashrsi3.c: $(srcdir)/config/sh/ashrsi3.c ! cp $(srcdir)/config/sh/ashrsi3.c ashrsi3.c ! ! lshrsi3.c: $(srcdir)/config/sh/lshrsi3.c ! cp $(srcdir)/config/sh/lshrsi3.c lshrsi3.c ! ! dp-bit.c: $(srcdir)/config/fp-bit.c ! cat $(srcdir)/config/fp-bit.c > dp-bit.c ! ! fp-bit.c: $(srcdir)/config/fp-bit.c ! echo '#define FLOAT' > fp-bit.c ! cat $(srcdir)/config/fp-bit.c >> fp-bit.c diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/netbsd.h gcc-2.6.1/config/sparc/netbsd.h *** gcc-2.6.0/config/sparc/netbsd.h --- gcc-2.6.1/config/sparc/netbsd.h Fri Sep 9 15:16:50 1994 *************** *** 0 **** --- 1,43 ---- + #include "sparc/sparc.h" + + /* Get generic NetBSD definitions. */ + + #include "netbsd.h" + + /* Names to predefine in the preprocessor for this target machine. */ + + #undef CPP_PREDEFINES + #define CPP_PREDEFINES "-Dunix -Dsparc -D__NetBSD__ -Asystem(unix) -Asystem(NetBSD) -Acpu(sparc) -Amachine(sparc)" + + /* Make gcc agree with */ + + #undef SIZE_TYPE + #define SIZE_TYPE "unsigned int" + + #undef PTRDIFF_TYPE + #define PTRDIFF_TYPE "int" + + #undef WCHAR_TYPE + #define WCHAR_TYPE "short unsigned int" + #define WCHAR_UNSIGNED 1 + + #undef WCHAR_TYPE_SIZE + #define WCHAR_TYPE_SIZE 16 + + /* This is BSD, so it wants DBX format. */ + + #define DBX_DEBUGGING_INFO + + /* This is the char to use for continuation (in case we need to turn + continuation back on). */ + + #define DBX_CONTIN_CHAR '?' + + /* Don't use the `xsfoo;' construct in DBX output; this system + doesn't support it. */ + + #define DBX_NO_XREFS + + /* Don't default to pcc-struct-return, because gcc is the only compiler, and + we want to retain compatibility with older gcc versions. */ + #define DEFAULT_PCC_STRUCT_RETURN 0 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/sol2.h gcc-2.6.1/config/sparc/sol2.h *** gcc-2.6.0/config/sparc/sol2.h Tue Jun 28 15:24:40 1994 --- gcc-2.6.1/config/sparc/sol2.h Fri Sep 2 14:23:40 1994 *************** *** 52,70 **** /* We use stabs-in-elf for debugging, because that is what the native toolchain uses. */ ! #define DBX_DEBUGGING_INFO #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG - #define DBX_BLOCKS_FUNCTION_RELATIVE 1 - - /* "gcc2_compiled." must be a .stabs, not an ordinary symbol, or GDB won't - see it. Furthermore, since GDB reads the input piecemeal, starting - with each N_SO, it's a lot easier if the gcc2 flag symbol is *after* - the N_SO rather than before it. So we emit an N_OPT stab here. */ - - #define ASM_IDENTIFY_GCC(FILE) /* Do nothing */ - - #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) \ - fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE) - /* The Solaris 2 assembler uses .skip, not .zero, so put this back. */ #undef ASM_OUTPUT_SKIP --- 52,58 ---- /* We use stabs-in-elf for debugging, because that is what the native toolchain uses. */ ! #undef PREFERRED_DEBUGGING_TYPE #define PREFERRED_DEBUGGING_TYPE DBX_DEBUG /* The Solaris 2 assembler uses .skip, not .zero, so put this back. */ #undef ASM_OUTPUT_SKIP *************** *** 106,123 **** #define ASM_GENERATE_INTERNAL_LABEL(LABEL,PREFIX,NUM) \ sprintf (LABEL, "*.L%s%d", PREFIX, NUM) - - /* in Solaris 2.0, linenos are relative to the current fn. */ - #undef ASM_OUTPUT_SOURCE_LINE - #define ASM_OUTPUT_SOURCE_LINE(file, line) \ - { static int sym_lineno = 1; \ - fprintf (file, ".stabn 68,0,%d,.LM%d-%s\n.LM%d:\n", \ - line, sym_lineno, \ - XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0), \ - sym_lineno); \ - sym_lineno += 1; } - - /* But, to make this work, we have to output the stabs for the function - name *first*... */ - #define DBX_FUNCTION_FIRST --- 94,97 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/sparc.c gcc-2.6.1/config/sparc/sparc.c *** gcc-2.6.0/config/sparc/sparc.c Tue Jun 28 15:24:54 1994 --- gcc-2.6.1/config/sparc/sparc.c Tue Oct 18 20:51:05 1994 *************** *** 114,122 **** /* Option handling. */ - /* Contains one of: medium-low, medium-anywhere. */ - /* ??? These names are quite long. */ - - char *sparc_code_model; - /* Validate and override various options, and do some machine dependent initialization. */ --- 114,117 ---- *************** *** 125,146 **** sparc_override_options () { - if (sparc_code_model == 0) - /* Nothing to do. */ - ; - else if (! TARGET_V9) - error ("code model support is only available with -mv9"); - else if (strcmp (sparc_code_model, "medium-low") == 0) - { - target_flags &= ~MASK_CODE_MODEL; - target_flags |= MASK_MEDLOW; - } - else if (strcmp (sparc_code_model, "medium-anywhere") == 0) - { - target_flags &= ~MASK_CODE_MODEL; - target_flags |= MASK_MEDANY; - } - else - error ("bad value (%s) for -mcode-model switch", sparc_code_model); - /* Check for any conflicts in the choice of options. */ /* ??? This stuff isn't really usable yet. */ --- 120,123 ---- *************** *** 148,151 **** --- 125,130 ---- if (! TARGET_V9) { + if (target_flags & MASK_CODE_MODEL) + error ("code model support is only available with -mv9"); if (TARGET_INT64) error ("-mint64 is only available with -mv9"); *************** *** 218,222 **** if (op == const0_rtx || register_operand (op, mode)) return 1; ! if (GET_MODE (op) == DImode && GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_HIGH (op) == 0 && CONST_DOUBLE_LOW (op) == 0) --- 197,201 ---- if (op == const0_rtx || register_operand (op, mode)) return 1; ! if (GET_MODE (op) == VOIDmode && GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_HIGH (op) == 0 && CONST_DOUBLE_LOW (op) == 0) *************** *** 295,299 **** abort (); op = XEXP (op, 0); ! return (CONSTANT_P (op) || memory_address_p (Pmode, op)); } --- 274,278 ---- abort (); op = XEXP (op, 0); ! return (symbolic_operand (op, mode) || memory_address_p (Pmode, op)); } *************** *** 303,307 **** enum machine_mode mode; { ! return (CONSTANT_P (op) || memory_address_p (Pmode, op)); } --- 282,286 ---- enum machine_mode mode; { ! return (symbolic_operand (op, mode) || memory_address_p (Pmode, op)); } *************** *** 2853,2856 **** --- 2832,2836 ---- /* Build a (32 bit) big number in a register. */ + /* ??? We may be able to use the set macro here too. */ static void *************** *** 3108,3117 **** tree fntype = TREE_TYPE (current_function_decl); /* First unnamed integer register. */ ! int first_intreg = current_function_args_info.arg_count[0]; /* Number of integer registers we need to save. */ int n_intregs = MAX (0, NPARM_REGS (SImode) - first_intreg); /* First unnamed SFmode float reg (no, you can't pass SFmode floats as ! unnamed arguments, we just number them that way). */ ! int first_floatreg = current_function_args_info.arg_count[1] + 1 & ~1; /* Number of SFmode float regs to save. */ int n_floatregs = MAX (0, NPARM_REGS (SFmode) - first_floatreg); --- 3088,3098 ---- tree fntype = TREE_TYPE (current_function_decl); /* First unnamed integer register. */ ! int first_intreg = current_function_args_info.arg_count[(int) SPARC_ARG_INT]; /* Number of integer registers we need to save. */ int n_intregs = MAX (0, NPARM_REGS (SImode) - first_intreg); /* First unnamed SFmode float reg (no, you can't pass SFmode floats as ! unnamed arguments, we just number them that way). We must round up to ! the next double word float reg - that is the first one to save. */ ! int first_floatreg = current_function_args_info.arg_count[(int) SPARC_ARG_FLOAT] + 1 & ~1; /* Number of SFmode float regs to save. */ int n_floatregs = MAX (0, NPARM_REGS (SFmode) - first_floatreg); *************** *** 3118,3132 **** int ptrsize = GET_MODE_SIZE (Pmode); rtx valist, regbuf, fpregs; ! int regno; /* Allocate block of memory for the regs. ! We only allocate as much as we need. */ /* ??? If n_intregs + n_floatregs == 0, should we allocate at least 1 byte? Or can assign_stack_local accept a 0 SIZE argument? */ ! regbuf = assign_stack_local (BLKmode, ! (n_intregs * UNITS_PER_WORD ! + n_floatregs * FLOAT_TYPE_SIZE/BITS_PER_UNIT), ! BITS_PER_WORD); MEM_IN_STRUCT_P (regbuf) = 1; --- 3099,3121 ---- int ptrsize = GET_MODE_SIZE (Pmode); rtx valist, regbuf, fpregs; ! int bufsize, adjust, regno; /* Allocate block of memory for the regs. ! We only allocate as much as we need, but we must ensure quadword float ! regs are stored with the appropriate alignment. */ /* ??? If n_intregs + n_floatregs == 0, should we allocate at least 1 byte? Or can assign_stack_local accept a 0 SIZE argument? */ ! bufsize = (n_intregs * UNITS_PER_WORD) + (n_floatregs * (UNITS_PER_WORD / 2)); ! /* Add space in front of the int regs to ensure proper alignment of quadword ! fp regs. We must add the space in front because va_start assumes this. */ ! if (n_floatregs >= 4) ! adjust = ((n_intregs + first_floatreg / 2) % 2) * UNITS_PER_WORD; ! else ! adjust = 0; ! ! regbuf = assign_stack_local (BLKmode, bufsize + adjust, ! GET_MODE_BITSIZE (TFmode)); ! regbuf = gen_rtx (MEM, BLKmode, plus_constant (XEXP (regbuf, 0), adjust)); MEM_IN_STRUCT_P (regbuf) = 1; *************** *** 3152,3158 **** emit_move_insn (gen_rtx (MEM, DFmode, plus_constant (fpregs, ! GET_MODE_SIZE (SFmode) * regno)), ! gen_rtx (REG, DFmode, BASE_INCOMING_ARG_REG (DFmode) ! + regno)); /* Return the address of the regbuf. */ --- 3141,3148 ---- emit_move_insn (gen_rtx (MEM, DFmode, plus_constant (fpregs, ! GET_MODE_SIZE (SFmode) ! * (regno - first_floatreg))), ! gen_rtx (REG, DFmode, ! BASE_INCOMING_ARG_REG (DFmode) + regno)); /* Return the address of the regbuf. */ *************** *** 4055,4059 **** mechanism would be better here. ! Emit 3 FLUSH instructions (UNSPEC_VOLATILE 2) to synchonize the data and instruction caches. --- 4045,4049 ---- mechanism would be better here. ! Emit 3 FLUSH instructions (UNSPEC_VOLATILE 3) to synchonize the data and instruction caches. *************** *** 4093,4103 **** emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 0)), ! 2)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 8)), ! 2)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 16)), ! 2)); } --- 4083,4093 ---- emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 0)), ! 3)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 8)), ! 3)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 16)), ! 3)); } *************** *** 4141,4151 **** emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 0)), ! 2)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 8)), ! 2)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 16)), ! 2)); } --- 4131,4141 ---- emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 0)), ! 3)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 8)), ! 3)); emit_insn (gen_rtx (UNSPEC_VOLATILE, VOIDmode, gen_rtvec (1, plus_constant (tramp, 16)), ! 3)); } *************** *** 4157,4163 **** Before call After call +-----------------------+ +-----------------------+ ! high | | | | ! mem. | | | | ! | caller's temps. | | caller's temps. | | | | | +-----------------------+ +-----------------------+ --- 4147,4152 ---- Before call After call +-----------------------+ +-----------------------+ ! high | | | | ! mem | caller's temps. | | caller's temps. | | | | | +-----------------------+ +-----------------------+ *************** *** 4164,4214 **** | | | | | arguments on stack. | | arguments on stack. | ! | |FP+92->| | ! +-----------------------+ +-----------------------+ | 6 words to save | | 6 words to save | | arguments passed | | arguments passed | | in registers, even | | in registers, even | ! SP+68->| if not passed. |FP+68->| if not passed. | ! +-----------------------+ +-----------------------+ ! | 1 word struct addr |FP+64->| 1 word struct addr | ! +-----------------------+ +-----------------------+ ! | | | | ! | 16 word reg save area | | 16 word reg save area | ! SP->| | FP->| | ! +-----------------------+ +-----------------------+ ! | 4 word area for | ! FP-16->| fp/alu reg moves | ! +-----------------------+ ! | | ! | local variables | ! | | ! +-----------------------+ ! | | | fp register save | ! | | ! +-----------------------+ ! | | | gp register save | | | ! +-----------------------+ ! | | | alloca allocations | ! | | ! +-----------------------+ ! | | | arguments on stack | ! SP+92->| | ! +-----------------------+ | 6 words to save | ! | arguments passed | | in registers, even | ! low SP+68->| if not passed. | ! memory +-----------------------+ ! SP+64->| 1 word struct addr | ! +-----------------------+ ! | | ! I 16 word reg save area | ! SP->| | ! +-----------------------+ */ /* Structure to be filled in by sparc_flat_compute_frame_size with register --- 4153,4203 ---- | | | | | arguments on stack. | | arguments on stack. | ! | | | | ! +-----------------------+FP+92->+-----------------------+ | 6 words to save | | 6 words to save | | arguments passed | | arguments passed | | in registers, even | | in registers, even | ! | if not passed. | | if not passed. | ! SP+68->+-----------------------+FP+68->+-----------------------+ ! | 1 word struct addr | | 1 word struct addr | ! +-----------------------+FP+64->+-----------------------+ ! | | | | ! | 16 word reg save area | | 16 word reg save area | ! | | | | ! SP->+-----------------------+ FP->+-----------------------+ ! | 4 word area for | ! | fp/alu reg moves | ! FP-16->+-----------------------+ ! | | ! | local variables | ! | | ! +-----------------------+ ! | | | fp register save | ! | | ! +-----------------------+ ! | | | gp register save | | | ! +-----------------------+ ! | | | alloca allocations | ! | | ! +-----------------------+ ! | | | arguments on stack | ! | | ! SP+92->+-----------------------+ | 6 words to save | ! | arguments passed | | in registers, even | ! low | if not passed. | ! memory SP+68->+-----------------------+ ! | 1 word struct addr | ! SP+64->+-----------------------+ ! | | ! I 16 word reg save area | ! | | ! SP->+-----------------------+ */ /* Structure to be filled in by sparc_flat_compute_frame_size with register *************** *** 4223,4230 **** unsigned int gp_reg_size; /* # bytes needed to store gp regs. */ unsigned int fp_reg_size; /* # bytes needed to store fp regs. */ ! unsigned long mask; /* Mask of saved gp registers. */ unsigned long fmask; /* Mask of saved fp registers. */ ! unsigned long gp_sp_offset; /* Offset from new sp to store gp regs. */ ! unsigned long fp_sp_offset; /* Offset from new sp to store fp regs. */ int initialized; /* Nonzero if frame size already calculated. */ }; --- 4212,4218 ---- unsigned int gp_reg_size; /* # bytes needed to store gp regs. */ unsigned int fp_reg_size; /* # bytes needed to store fp regs. */ ! unsigned long gmask; /* Mask of saved gp registers. */ unsigned long fmask; /* Mask of saved fp registers. */ ! unsigned long reg_offset; /* Offset from new sp to store regs. */ int initialized; /* Nonzero if frame size already calculated. */ }; *************** *** 4238,4245 **** /* Tell prologue and epilogue if register REGNO should be saved / restored. */ #define MUST_SAVE_REGISTER(regno) \ ((regs_ever_live[regno] && !call_used_regs[regno]) \ || (regno == FRAME_POINTER_REGNUM && frame_pointer_needed) \ ! || (regno == 15 && regs_ever_live[15])) /* Return the bytes needed to compute the frame pointer from the current --- 4226,4237 ---- /* Tell prologue and epilogue if register REGNO should be saved / restored. */ + #define RETURN_ADDR_REGNUM 15 + #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM)) + #define RETURN_ADDR_MASK (1 << (RETURN_ADDR_REGNUM)) + #define MUST_SAVE_REGISTER(regno) \ ((regs_ever_live[regno] && !call_used_regs[regno]) \ || (regno == FRAME_POINTER_REGNUM && frame_pointer_needed) \ ! || (regno == RETURN_ADDR_REGNUM && regs_ever_live[RETURN_ADDR_REGNUM])) /* Return the bytes needed to compute the frame pointer from the current *************** *** 4257,4266 **** unsigned int gp_reg_size; /* # bytes needed to store gp regs. */ unsigned int fp_reg_size; /* # bytes needed to store fp regs. */ ! unsigned long mask; /* Mask of saved gp registers. */ unsigned long fmask; /* Mask of saved fp registers. */ /* This is the size of the 16 word reg save area, 1 word struct addr area, and 4 word fp/alu register copy area. */ - /* ??? Is the stack bias taken into account here? */ extra_size = -STARTING_FRAME_OFFSET + FIRST_PARM_OFFSET(0); var_size = size; --- 4249,4259 ---- unsigned int gp_reg_size; /* # bytes needed to store gp regs. */ unsigned int fp_reg_size; /* # bytes needed to store fp regs. */ ! unsigned long gmask; /* Mask of saved gp registers. */ unsigned long fmask; /* Mask of saved fp registers. */ + unsigned long reg_offset; /* Offset to register save area. */ + int need_aligned_p; /* 1 if need the save area 8 byte aligned. */ /* This is the size of the 16 word reg save area, 1 word struct addr area, and 4 word fp/alu register copy area. */ extra_size = -STARTING_FRAME_OFFSET + FIRST_PARM_OFFSET(0); var_size = size; *************** *** 4270,4275 **** gp_reg_size = 0; fp_reg_size = 0; ! mask = 0; fmask = 0; /* Calculate space needed for gp registers. */ --- 4263,4270 ---- gp_reg_size = 0; fp_reg_size = 0; ! gmask = 0; fmask = 0; + reg_offset = 0; + need_aligned_p = 0; /* Calculate space needed for gp registers. */ *************** *** 4278,4288 **** if (MUST_SAVE_REGISTER (regno)) { if ((regno & 0x1) == 0 && MUST_SAVE_REGISTER (regno+1)) { if (gp_reg_size % 8 != 0) ! gp_reg_size += UNITS_PER_WORD; gp_reg_size += 2 * UNITS_PER_WORD; ! mask |= 3 << regno; regno++; } else --- 4273,4286 ---- if (MUST_SAVE_REGISTER (regno)) { + /* If we need to save two regs in a row, ensure there's room to bump + up the address to align it to a doubleword boundary. */ if ((regno & 0x1) == 0 && MUST_SAVE_REGISTER (regno+1)) { if (gp_reg_size % 8 != 0) ! gp_reg_size += 4; gp_reg_size += 2 * UNITS_PER_WORD; ! gmask |= 3 << regno; regno++; + need_aligned_p = 1; } else *************** *** 4289,4300 **** { gp_reg_size += UNITS_PER_WORD; ! mask |= 1 << regno; } } } - /* Add extra word in case we have to align the space to a double word - boundary. */ - if (gp_reg_size != 0) - gp_reg_size += UNITS_PER_WORD; /* Calculate space needed for fp registers. */ --- 4287,4294 ---- { gp_reg_size += UNITS_PER_WORD; ! gmask |= 1 << regno; } } } /* Calculate space needed for fp registers. */ *************** *** 4308,4313 **** } ! total_size += gp_reg_size + fp_reg_size; if (total_size == extra_size) total_size = extra_size = 0; --- 4302,4320 ---- } ! if (gmask || fmask) ! { ! int n; ! reg_offset = FIRST_PARM_OFFSET(0) + args_size; ! /* Ensure save area is 8 byte aligned if we need it. */ ! n = reg_offset % 8; ! if (need_aligned_p && n != 0) ! { ! total_size += 8 - n; ! reg_offset += 8 - n; ! } ! total_size += gp_reg_size + fp_reg_size; ! } + /* ??? This looks a little suspicious. Clarify. */ if (total_size == extra_size) total_size = extra_size = 0; *************** *** 4322,4345 **** current_frame_info.gp_reg_size = gp_reg_size; current_frame_info.fp_reg_size = fp_reg_size; ! current_frame_info.mask = mask; current_frame_info.fmask = fmask; current_frame_info.initialized = reload_completed; - if (mask) - { - unsigned long offset = args_size; - if (extra_size) - offset += FIRST_PARM_OFFSET(0); - current_frame_info.gp_sp_offset = offset; - } - - if (fmask) - { - unsigned long offset = args_size + gp_reg_size; - if (extra_size) - offset += FIRST_PARM_OFFSET(0); - current_frame_info.fp_sp_offset = offset; - } - /* Ok, we're done. */ return total_size; --- 4329,4337 ---- current_frame_info.gp_reg_size = gp_reg_size; current_frame_info.fp_reg_size = fp_reg_size; ! current_frame_info.gmask = gmask; current_frame_info.fmask = fmask; + current_frame_info.reg_offset = reg_offset; current_frame_info.initialized = reload_completed; /* Ok, we're done. */ return total_size; *************** *** 4346,4411 **** } ! /* Common code to save/restore registers. */ void ! sparc_flat_save_restore (file, word_op, doubleword_op) ! FILE *file; /* Stream to write to. */ ! char *word_op; /* Operation to do for one word. */ ! char *doubleword_op; /* Operation to do for doubleword. */ { int regno; - unsigned long mask = current_frame_info.mask; - unsigned long fmask = current_frame_info.fmask; - unsigned long gp_offset; - unsigned long fp_offset; - unsigned long max_offset; - char *base_reg; ! if (mask == 0 && fmask == 0) return; ! base_reg = reg_names[STACK_POINTER_REGNUM]; ! gp_offset = current_frame_info.gp_sp_offset; ! fp_offset = current_frame_info.fp_sp_offset; ! max_offset = (gp_offset > fp_offset) ? gp_offset : fp_offset; ! ! /* Deal with calling functions with a large structure. */ ! if (max_offset >= 4096) ! { ! char *temp = "%g2"; ! fprintf (file, "\tset %ld,%s\n", max_offset, temp); ! fprintf (file, "\tadd %s,%s,%s\n", temp, base_reg, temp); ! base_reg = temp; ! gp_offset = max_offset - gp_offset; ! fp_offset = max_offset - fp_offset; ! } ! ! /* Save registers starting from high to low. The debuggers prefer ! at least the return register be stored at func+4, and also it ! allows us not to need a nop in the epilog if at least one ! register is reloaded in addition to return address. */ ! if (mask || frame_pointer_needed) { for (regno = 1; regno <= 31; regno++) { ! if ((mask & (1L << regno)) != 0 ! || (regno == FRAME_POINTER_REGNUM && frame_pointer_needed)) { ! if ((regno & 0x1) == 0 && ((mask & (1L << (regno+1))) != 0)) { ! if (gp_offset % 8 != 0) ! gp_offset += UNITS_PER_WORD; ! if (word_op[0] == 's') fprintf (file, "\t%s %s,[%s+%d]\n", doubleword_op, reg_names[regno], ! base_reg, gp_offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! doubleword_op, base_reg, gp_offset, reg_names[regno]); ! gp_offset += 2 * UNITS_PER_WORD; regno++; } --- 4338,4396 ---- } ! /* Save/restore registers in GMASK and FMASK at register BASE_REG plus offset ! OFFSET. ! ! BASE_REG must be 8 byte aligned. This allows us to test OFFSET for ! appropriate alignment and use DOUBLEWORD_OP when we can. We assume ! [BASE_REG+OFFSET] will always be a valid address. + WORD_OP is either "st" for save, "ld" for restore. + DOUBLEWORD_OP is either "std" for save, "ldd" for restore. */ + void ! sparc_flat_save_restore (file, base_reg, offset, gmask, fmask, word_op, doubleword_op) ! FILE *file; ! char *base_reg; ! unsigned int offset; ! unsigned long gmask; ! unsigned long fmask; ! char *word_op; ! char *doubleword_op; { int regno; ! if (gmask == 0 && fmask == 0) return; ! /* Save registers starting from high to low. We've already saved the ! previous frame pointer and previous return address for the debugger's ! sake. The debugger allows us to not need a nop in the epilog if at least ! one register is reloaded in addition to return address. */ ! if (gmask) { for (regno = 1; regno <= 31; regno++) { ! if ((gmask & (1L << regno)) != 0) { ! if ((regno & 0x1) == 0 && ((gmask & (1L << (regno+1))) != 0)) { ! /* We can save two registers in a row. If we're not at a ! double word boundary, move to one. ! sparc_flat_compute_frame_size ensures there's room to do ! this. */ ! if (offset % 8 != 0) ! offset += UNITS_PER_WORD; ! if (word_op[0] == 's') fprintf (file, "\t%s %s,[%s+%d]\n", doubleword_op, reg_names[regno], ! base_reg, offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! doubleword_op, base_reg, offset, reg_names[regno]); ! offset += 2 * UNITS_PER_WORD; regno++; } *************** *** 4415,4424 **** fprintf (file, "\t%s %s,[%s+%d]\n", word_op, reg_names[regno], ! base_reg, gp_offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! word_op, base_reg, gp_offset, reg_names[regno]); ! gp_offset += UNITS_PER_WORD; } } --- 4400,4409 ---- fprintf (file, "\t%s %s,[%s+%d]\n", word_op, reg_names[regno], ! base_reg, offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! word_op, base_reg, offset, reg_names[regno]); ! offset += UNITS_PER_WORD; } } *************** *** 4435,4444 **** fprintf (file, "\t%s %s,[%s+%d]\n", word_op, reg_names[regno], ! base_reg, gp_offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! word_op, base_reg, gp_offset, reg_names[regno]); ! fp_offset += UNITS_PER_WORD; } } --- 4420,4429 ---- fprintf (file, "\t%s %s,[%s+%d]\n", word_op, reg_names[regno], ! base_reg, offset); else fprintf (file, "\t%s [%s+%d],%s\n", ! word_op, base_reg, offset, reg_names[regno]); ! offset += UNITS_PER_WORD; } } *************** *** 4453,4500 **** int size; { - int tsize; char *sp_str = reg_names[STACK_POINTER_REGNUM]; /* This is only for the human reader. */ fprintf (file, "\t!#PROLOGUE# 0\n"); size = SPARC_STACK_ALIGN (size); ! tsize = (! current_frame_info.initialized ! ? sparc_flat_compute_frame_size (size) ! : current_frame_info.total_size); ! ! if (tsize > 0) ! { ! if (tsize <= 4095) ! fprintf (file, ! "\tsub %s,%d,%s\t\t!# vars= %d, regs= %d/%d, args = %d, extra= %d\n", ! sp_str, tsize, sp_str, current_frame_info.var_size, ! current_frame_info.gp_reg_size / 4, ! current_frame_info.fp_reg_size / 8, ! current_function_outgoing_args_size, ! current_frame_info.extra_size); ! else ! fprintf (file, ! "\tset %d,%s\n\tsub\t%s,%s,%s\t\t!# vars= %d, regs= %d/%d, args = %d, sfo= %d\n", ! tsize, "%g1", sp_str, "%g1", ! sp_str, current_frame_info.var_size, ! current_frame_info.gp_reg_size / 4, ! current_frame_info.fp_reg_size / 8, ! current_function_outgoing_args_size, ! current_frame_info.extra_size); ! } ! sparc_flat_save_restore (file, "st", "std"); ! if (frame_pointer_needed) { char *fp_str = reg_names[FRAME_POINTER_REGNUM]; ! if (tsize <= 4095) ! fprintf (file, "\tadd %s,%d,%s\t!# set up frame pointer\n", sp_str, ! tsize, fp_str); else ! fprintf (file, "\tadd %s,%s,%s\t!# set up frame pointer\n", sp_str, ! "%g1", fp_str); } --- 4438,4575 ---- int size; { char *sp_str = reg_names[STACK_POINTER_REGNUM]; + unsigned long gmask = current_frame_info.gmask; /* This is only for the human reader. */ fprintf (file, "\t!#PROLOGUE# 0\n"); + fprintf (file, "\t!# vars= %d, regs= %d/%d, args= %d, extra= %d\n", + current_frame_info.var_size, + current_frame_info.gp_reg_size / 4, + current_frame_info.fp_reg_size / 4, + current_function_outgoing_args_size, + current_frame_info.extra_size); size = SPARC_STACK_ALIGN (size); ! size = (! current_frame_info.initialized ! ? sparc_flat_compute_frame_size (size) ! : current_frame_info.total_size); ! /* These cases shouldn't happen. Catch them now. */ ! if (size == 0 && (gmask || current_frame_info.fmask)) ! abort (); ! /* Allocate our stack frame by decrementing %sp. ! At present, the only algorithm gdb can use to determine if this is a ! flat frame is if we always set %i7 if we set %sp. This can be optimized ! in the future by putting in some sort of debugging information that says ! this is a `flat' function. However, there is still the case of debugging ! code without such debugging information (including cases where most fns ! have such info, but there is one that doesn't). So, always do this now ! so we don't get a lot of code out there that gdb can't handle. ! If the frame pointer isn't needn't then that's ok - gdb won't be able to ! distinguish us from a non-flat function but there won't (and shouldn't) ! be any differences anyway. The return pc is saved (if necessary) right ! after %i7 so gdb won't have to look too far to find it. */ ! if (size > 0) { + unsigned int reg_offset = current_frame_info.reg_offset; char *fp_str = reg_names[FRAME_POINTER_REGNUM]; + char *t1_str = "%g1"; + + /* Things get a little tricky if local variables take up more than ~4096 + bytes and outgoing arguments take up more than ~4096 bytes. When that + happens, the register save area can't be accessed from either end of + the frame. Handle this by decrementing %sp to the start of the gp + register save area, save the regs, update %i7, and then set %sp to its + final value. Given that we only have one scratch register to play + with it is the cheapest solution, and it helps gdb out as it won't + slow down recognition of flat functions. + Don't change the order of insns emitted here without checking with + the gdb folk first. */ ! /* Is the entire register save area offsetable from %sp? */ ! if (reg_offset < 4096 - 64 * UNITS_PER_WORD) ! { ! if (size <= 4096) ! { ! fprintf (file, "\tadd %s,%d,%s\n", ! sp_str, -size, sp_str); ! if (gmask & FRAME_POINTER_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n", ! fp_str, sp_str, reg_offset); ! fprintf (file, "\tsub %s,%d,%s\t!# set up frame pointer\n", ! sp_str, -size, fp_str); ! reg_offset += 4; ! } ! } ! else ! { ! fprintf (file, "\tset %d,%s\n\tsub %s,%s,%s\n", ! size, t1_str, sp_str, t1_str, sp_str); ! if (gmask & FRAME_POINTER_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n", ! fp_str, sp_str, reg_offset); ! fprintf (file, "\tadd %s,%s,%s\t!# set up frame pointer\n", ! sp_str, t1_str, fp_str); ! reg_offset += 4; ! } ! } ! if (gmask & RETURN_ADDR_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n", ! reg_names[RETURN_ADDR_REGNUM], sp_str, reg_offset); ! reg_offset += 4; ! } ! sparc_flat_save_restore (file, sp_str, reg_offset, ! gmask & ~(FRAME_POINTER_MASK | RETURN_ADDR_MASK), ! current_frame_info.fmask, ! "st", "std"); ! } else ! { ! /* Subtract %sp in two steps, but make sure there is always a ! 64 byte register save area, and %sp is properly aligned. */ ! /* Amount to decrement %sp by, the first time. */ ! unsigned int size1 = ((size - reg_offset + 64) + 15) & -16; ! /* Offset to register save area from %sp. */ ! unsigned int offset = size1 - (size - reg_offset); ! ! if (size1 <= 4096) ! { ! fprintf (file, "\tadd %s,%d,%s\n", ! sp_str, -size1, sp_str); ! if (gmask & FRAME_POINTER_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n\tsub %s,%d,%s\t!# set up frame pointer\n", ! fp_str, sp_str, offset, sp_str, -size1, fp_str); ! offset += 4; ! } ! } ! else ! { ! fprintf (file, "\tset %d,%s\n\tsub %s,%s,%s\n", ! size1, t1_str, sp_str, t1_str, sp_str); ! if (gmask & FRAME_POINTER_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n\tadd %s,%s,%s\t!# set up frame pointer\n", ! fp_str, sp_str, offset, sp_str, t1_str, fp_str); ! offset += 4; ! } ! } ! if (gmask & RETURN_ADDR_MASK) ! { ! fprintf (file, "\tst %s,[%s+%d]\n", ! reg_names[RETURN_ADDR_REGNUM], sp_str, offset); ! offset += 4; ! } ! sparc_flat_save_restore (file, sp_str, offset, ! gmask & ~(FRAME_POINTER_MASK | RETURN_ADDR_MASK), ! current_frame_info.fmask, ! "st", "std"); ! fprintf (file, "\tset %d,%s\n\tsub %s,%s,%s\n", ! size - size1, t1_str, sp_str, t1_str, sp_str); ! } } *************** *** 4510,4516 **** int size; { - int tsize; - char *sp_str = reg_names[STACK_POINTER_REGNUM]; - char *t1_str = "%g1"; rtx epilogue_delay = current_function_epilogue_delay_list; int noepilogue = FALSE; --- 4585,4588 ---- *************** *** 4525,4533 **** size = SPARC_STACK_ALIGN (size); ! tsize = (!current_frame_info.initialized ? sparc_flat_compute_frame_size (size) : current_frame_info.total_size); ! if (tsize == 0 && epilogue_delay == 0) { rtx insn = get_last_insn (); --- 4597,4605 ---- size = SPARC_STACK_ALIGN (size); ! size = (!current_frame_info.initialized ? sparc_flat_compute_frame_size (size) : current_frame_info.total_size); ! if (size == 0 && epilogue_delay == 0) { rtx insn = get_last_insn (); *************** *** 4543,4546 **** --- 4615,4624 ---- if (!noepilogue) { + unsigned int reg_offset = current_frame_info.reg_offset; + unsigned int size1; + char *sp_str = reg_names[STACK_POINTER_REGNUM]; + char *fp_str = reg_names[FRAME_POINTER_REGNUM]; + char *t1_str = "%g1"; + /* In the reload sequence, we don't need to fill the load delay slots for most of the loads, also see if we can fill the final *************** *** 4547,4565 **** delay slot if not otherwise filled by the reload sequence. */ ! if (tsize > 4095) ! fprintf (file, "\tset %d,%s\n", tsize, t1_str); if (frame_pointer_needed) { ! char *fp_str = reg_names[FRAME_POINTER_REGNUM]; ! if (tsize > 4095) ! fprintf (file,"\tsub %s,%s,%s\t\t!# sp not trusted here\n", fp_str, t1_str, sp_str); else ! fprintf (file,"\tsub %s,%d,%s\t\t!# sp not trusted here\n", ! fp_str, tsize, sp_str); } ! sparc_flat_save_restore (file, "ld", "ldd"); if (current_function_returns_struct) --- 4625,4689 ---- delay slot if not otherwise filled by the reload sequence. */ ! if (size > 4095) ! fprintf (file, "\tset %d,%s\n", size, t1_str); if (frame_pointer_needed) { ! if (size > 4095) ! fprintf (file,"\tsub %s,%s,%s\t\t!# sp not trusted here\n", fp_str, t1_str, sp_str); else ! fprintf (file,"\tsub %s,%d,%s\t\t!# sp not trusted here\n", ! fp_str, size, sp_str); } ! /* Is the entire register save area offsetable from %sp? */ ! if (reg_offset < 4096 - 64 * UNITS_PER_WORD) ! { ! size1 = 0; ! } ! else ! { ! /* Restore %sp in two steps, but make sure there is always a ! 64 byte register save area, and %sp is properly aligned. */ ! /* Amount to increment %sp by, the first time. */ ! size1 = ((reg_offset - 64 - 16) + 15) & -16; ! /* Offset to register save area from %sp. */ ! reg_offset = size1 - reg_offset; ! ! fprintf (file, "\tset %d,%s\n\tadd %s,%s,%s\n", ! size1, t1_str, sp_str, t1_str, sp_str); ! } ! ! /* We must restore the frame pointer and return address reg first ! because they are treated specially by the prologue output code. */ ! if (current_frame_info.gmask & FRAME_POINTER_MASK) ! { ! fprintf (file, "\tld [%s+%d],%s\n", ! sp_str, reg_offset, fp_str); ! reg_offset += 4; ! } ! if (current_frame_info.gmask & RETURN_ADDR_MASK) ! { ! fprintf (file, "\tld [%s+%d],%s\n", ! sp_str, reg_offset, reg_names[RETURN_ADDR_REGNUM]); ! reg_offset += 4; ! } ! ! /* Restore any remaining saved registers. */ ! sparc_flat_save_restore (file, sp_str, reg_offset, ! current_frame_info.gmask & ~(FRAME_POINTER_MASK | RETURN_ADDR_MASK), ! current_frame_info.fmask, ! "ld", "ldd"); ! ! /* If we had to increment %sp in two steps, record it so the second ! restoration in the epilogue finishes up. */ ! if (size1 > 0) ! { ! size -= size1; ! if (size > 4095) ! fprintf (file, "\tset %d,%s\n", ! size, t1_str); ! } if (current_function_returns_struct) *************** *** 4575,4579 **** if (epilogue_delay) { ! if (tsize) abort (); final_scan_insn (XEXP (epilogue_delay, 0), file, 1, -2, 1); --- 4699,4703 ---- if (epilogue_delay) { ! if (size) abort (); final_scan_insn (XEXP (epilogue_delay, 0), file, 1, -2, 1); *************** *** 4580,4588 **** } ! else if (tsize > 4095) fprintf (file, "\tadd %s,%s,%s\n", sp_str, t1_str, sp_str); ! else if (tsize > 0) ! fprintf (file, "\tadd %s,%d,%s\n", sp_str, tsize, sp_str); else --- 4704,4712 ---- } ! else if (size > 4095) fprintf (file, "\tadd %s,%s,%s\n", sp_str, t1_str, sp_str); ! else if (size > 0) ! fprintf (file, "\tadd %s,%d,%s\n", sp_str, size, sp_str); else diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/sparc.h gcc-2.6.1/config/sparc/sparc.h *** gcc-2.6.0/config/sparc/sparc.h Tue Jul 12 13:11:06 1994 --- gcc-2.6.1/config/sparc/sparc.h Mon Oct 31 13:22:04 1994 *************** *** 241,245 **** avoid generating %uhi and %ulo terms. Pointers are still 64 bits though! This option is for v9 only. */ ! /* ??? This option is deprecated. Try to use -mcode-model=medium-low. */ #define MASK_ENV32 0x10000 #define TARGET_ENV32 (target_flags & MASK_ENV32) --- 241,245 ---- avoid generating %uhi and %ulo terms. Pointers are still 64 bits though! This option is for v9 only. */ ! /* ??? This option is deprecated. Try to use -mmedlow. */ #define MASK_ENV32 0x10000 #define TARGET_ENV32 (target_flags & MASK_ENV32) *************** *** 328,370 **** /* {"ptr32", -MASK_PTR64}, */ \ {"stack-bias", MASK_STACK_BIAS}, \ ! {"no-stack-bias", -MASK_STACK_BIAS}, #else #define V9_SWITCHES #endif - - /* This macro is similar to `TARGET_SWITCHES' but defines names of - command options that have values. Its definition is an - initializer with a subgrouping for each command option. - - Each subgrouping contains a string constant, that defines the - fixed part of the option name, and the address of a variable. - The variable, type `char *', is set to the variable part of the - given option if the fixed part matches. The actual option name - is made by prepending `-m' to the specified name. - - Here is an example which defines `-mshort-data-NUMBER'. If the - given option is `-mshort-data-512', the variable `m88k_short_data' - will be set to the string `"512"'. - - extern char *m88k_short_data; - #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } } */ - - /* For v9, two values of "code model" are currently supported. - - medium-low - 32 bit address space starting at 0 - - medium-anywhere - 32 bit text segment starting at 0 - 32 bit data segment(s) starting anywhere (determined at link time) - MEDANY_BASE_REG points to the start - */ - - extern char *sparc_code_model; - - #define TARGET_OPTIONS \ - { \ - { "code-model=", &sparc_code_model } \ - } /* target machine storage layout */ --- 328,339 ---- /* {"ptr32", -MASK_PTR64}, */ \ {"stack-bias", MASK_STACK_BIAS}, \ ! {"no-stack-bias", -MASK_STACK_BIAS}, \ ! {"medlow", -MASK_CODE_MODEL}, \ ! {"medlow", MASK_MEDLOW}, \ ! {"medany", -MASK_CODE_MODEL}, \ ! {"medany", MASK_MEDANY}, #else #define V9_SWITCHES #endif /* target machine storage layout */ *************** *** 650,654 **** fixed_regs[2] = 0; \ fixed_regs[3] = 0; \ ! fixed_regs[4] = 0; \ } \ if (TARGET_FLAT) \ --- 619,623 ---- fixed_regs[2] = 0; \ fixed_regs[3] = 0; \ ! fixed_regs[4] = TARGET_MEDANY != 0; \ } \ if (TARGET_FLAT) \ *************** *** 742,751 **** may be accessed via the stack pointer) in functions that seem suitable. This is computed in `reload', in reload1.c. ! ! Used in flow.c, global.c, and reload1.c. */ ! extern int leaf_function; #define FRAME_POINTER_REQUIRED \ ! (TARGET_FRW ? (current_function_calls_alloca || current_function_varargs) \ : ! (leaf_function_p () && only_leaf_regs_used ())) --- 711,722 ---- may be accessed via the stack pointer) in functions that seem suitable. This is computed in `reload', in reload1.c. ! Used in flow.c, global.c, and reload1.c. + Being a non-leaf function does not mean a frame pointer is needed in the + flat window model. However, the debugger won't be able to backtrace through + us with out it. */ #define FRAME_POINTER_REQUIRED \ ! (TARGET_FRW ? (current_function_calls_alloca || current_function_varargs \ ! || !leaf_function_p ()) \ : ! (leaf_function_p () && only_leaf_regs_used ())) *************** *** 779,784 **** in memory. For v9, all aggregates are returned in memory. */ ! #define RETURN_IN_MEMORY(TYPE) \ ! (TYPE_MODE (TYPE) == BLKmode || (! TARGET_V9 && TYPE_MODE (TYPE) == TFmode)) /* Functions which return large structures get the address --- 750,757 ---- in memory. For v9, all aggregates are returned in memory. */ ! #define RETURN_IN_MEMORY(TYPE) \ ! (TYPE_MODE (TYPE) == BLKmode \ ! || (! TARGET_V9 && (TYPE_MODE (TYPE) == TFmode \ ! || TYPE_MODE (TYPE) == TCmode))) /* Functions which return large structures get the address *************** *** 824,827 **** --- 797,820 ---- /* The SPARC has two kinds of registers, general and floating point. + + For v9 we must distinguish between the upper and lower floating point + registers because the upper ones can't hold SFmode values. + HARD_REGNO_MODE_OK won't help here because reload assumes that register(s) + satisfying a group need for a class will also satisfy a single need for + that class. EXTRA_FP_REGS is a bit of a misnomer as it covers all 64 fp + regs. + + It is important that one class contains all the general and all the standard + fp regs. Otherwise find_reg() won't properly allocate int regs for moves, + because reg_class_record() will bias the selection in favor of fp regs, + because reg_class_subunion[GENERAL_REGS][FP_REGS] will yield FP_REGS, + because FP_REGS > GENERAL_REGS. + + It is also important that one class contain all the general and all the + fp regs. Otherwise when spilling a DFmode reg, it may be from EXTRA_FP_REGS + but find_reloads() may use class GENERAL_OR_FP_REGS. This will cause + allocate_reload_reg() to bypass it causing an abort because the compiler + thinks it doesn't have a spill reg when in fact it does. + v9 also has 4 floating point condition code registers. Since we don't have a class that is the union of FPCC_REGS with either of the others, *************** *** 829,836 **** trying to compile _fixunsdfsi because fix_truncdfsi2 won't match its constraints. */ - /* ??? As an experiment for v9, we treat all fp regs similarily here. */ #ifdef SPARCV9 ! enum reg_class { NO_REGS, FPCC_REGS, GENERAL_REGS, FP_REGS, GENERAL_OR_FP_REGS, ALL_REGS, LIM_REG_CLASSES }; #else --- 822,829 ---- trying to compile _fixunsdfsi because fix_truncdfsi2 won't match its constraints. */ #ifdef SPARCV9 ! enum reg_class { NO_REGS, FPCC_REGS, GENERAL_REGS, FP_REGS, EXTRA_FP_REGS, ! GENERAL_OR_FP_REGS, GENERAL_OR_EXTRA_FP_REGS, ALL_REGS, LIM_REG_CLASSES }; #else *************** *** 844,852 **** #ifdef SPARCV9 #define REG_CLASS_NAMES \ ! {"NO_REGS", "FPCC_REGS", "GENERAL_REGS", "FP_REGS", "GENERAL_OR_FP_REGS", \ ! "ALL_REGS" } #else #define REG_CLASS_NAMES \ ! {"NO_REGS", "GENERAL_REGS", "FP_REGS", "ALL_REGS" } #endif --- 837,845 ---- #ifdef SPARCV9 #define REG_CLASS_NAMES \ ! { "NO_REGS", "FPCC_REGS", "GENERAL_REGS", "FP_REGS", "EXTRA_FP_REGS", \ ! "GENERAL_OR_FP_REGS", "GENERAL_OR_EXTRA_FP_REGS", "ALL_REGS" } #else #define REG_CLASS_NAMES \ ! { "NO_REGS", "GENERAL_REGS", "FP_REGS", "ALL_REGS" } #endif *************** *** 857,862 **** #ifdef SPARCV9 #define REG_CLASS_CONTENTS \ ! {{0, 0, 0, 0}, {0, 0, 0, 0xf}, {-2, 0, 0, 0}, {0, -1, -1, 0}, \ ! {-2, -1, -1, 0}, {-2, -1, -1, 0xf}} #else #if 0 && defined (__GNUC__) --- 850,856 ---- #ifdef SPARCV9 #define REG_CLASS_CONTENTS \ ! {{0, 0, 0, 0}, {0, 0, 0, 0xf}, {-2, 0, 0, 0}, \ ! {0, -1, 0, 0}, {0, -1, -1, 0}, {-2, -1, 0, 0}, {-2, -1, -1, 0}, \ ! {-2, -1, -1, 0xf}} #else #if 0 && defined (__GNUC__) *************** *** 873,881 **** #ifdef SPARCV9 ! #define REGNO_REG_CLASS(REGNO) \ ! ((REGNO) == 0 ? NO_REGS \ ! : ((REGNO) < 32 ? GENERAL_REGS \ ! : ((REGNO) < 96 ? FP_REGS \ ! : FPCC_REGS))) #else #define REGNO_REG_CLASS(REGNO) \ --- 867,876 ---- #ifdef SPARCV9 ! #define REGNO_REG_CLASS(REGNO) \ ! ((REGNO) == 0 ? NO_REGS \ ! : (REGNO) < 32 ? GENERAL_REGS \ ! : (REGNO) < 64 ? FP_REGS \ ! : (REGNO) < 96 ? EXTRA_FP_REGS \ ! : FPCC_REGS) #else #define REGNO_REG_CLASS(REGNO) \ *************** *** 996,999 **** --- 991,1001 ---- #define BASE_REG_CLASS GENERAL_REGS + /* Local macro to handle the two v9 classes of FP regs. */ + #ifdef SPARCV9 + #define FP_REG_CLASS_P(CLASS) ((CLASS) == FP_REGS || (CLASS) == EXTRA_FP_REGS) + #else + #define FP_REG_CLASS_P(CLASS) ((CLASS) == FP_REGS) + #endif + /* Get reg_class from a letter such as appears in the machine description. */ *************** *** 1000,1007 **** #ifdef SPARCV9 #define REG_CLASS_FROM_LETTER(C) \ ! ((C) == 'f' ? FP_REGS : (C) == 'c' ? FPCC_REGS : NO_REGS) #else #define REG_CLASS_FROM_LETTER(C) \ ! ((C) == 'f' ? FP_REGS : NO_REGS) #endif --- 1002,1014 ---- #ifdef SPARCV9 #define REG_CLASS_FROM_LETTER(C) \ ! ((C) == 'f' ? FP_REGS \ ! : (C) == 'e' ? EXTRA_FP_REGS \ ! : (C) == 'c' ? FPCC_REGS \ ! : NO_REGS) #else + /* Coerce v9's 'e' class to 'f', so we can use 'e' in the .md file for + v8 and v9. */ #define REG_CLASS_FROM_LETTER(C) \ ! ((C) == 'f' ? FP_REGS : (C) == 'e' ? FP_REGS : NO_REGS) #endif *************** *** 1041,1045 **** #define PREFERRED_RELOAD_CLASS(X,CLASS) \ (CONSTANT_P (X) \ ! && ((CLASS) == FP_REGS \ || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ && (HOST_FLOAT_FORMAT != IEEE_FLOAT_FORMAT \ --- 1048,1052 ---- #define PREFERRED_RELOAD_CLASS(X,CLASS) \ (CONSTANT_P (X) \ ! && (FP_REG_CLASS_P (CLASS) \ || (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ && (HOST_FLOAT_FORMAT != IEEE_FLOAT_FORMAT \ *************** *** 1058,1075 **** #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, IN) \ ! (((CLASS) == FP_REGS && ((MODE) == HImode || (MODE) == QImode)\ ! && (GET_CODE (IN) == MEM \ ! || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG) \ ! && true_regnum (IN) == -1))) ? GENERAL_REGS : NO_REGS) #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, IN) \ ! ((CLASS) == FP_REGS && ((MODE) == HImode || (MODE) == QImode) \ ! && (GET_CODE (IN) == MEM \ ! || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG) \ ! && true_regnum (IN) == -1)) ? GENERAL_REGS : NO_REGS) /* On SPARC it is not possible to directly move data between GENERAL_REGS and FP_REGS. */ ! #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) ((CLASS1) != (CLASS2)) /* Return the stack location to use for secondary memory needed reloads. --- 1065,1083 ---- #define SECONDARY_INPUT_RELOAD_CLASS(CLASS, MODE, IN) \ ! ((FP_REG_CLASS_P (CLASS) && ((MODE) == HImode || (MODE) == QImode) \ ! && (GET_CODE (IN) == MEM \ ! || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG) \ ! && true_regnum (IN) == -1))) ? GENERAL_REGS : NO_REGS) #define SECONDARY_OUTPUT_RELOAD_CLASS(CLASS, MODE, IN) \ ! ((FP_REG_CLASS_P (CLASS) && ((MODE) == HImode || (MODE) == QImode) \ ! && (GET_CODE (IN) == MEM \ ! || ((GET_CODE (IN) == REG || GET_CODE (IN) == SUBREG) \ ! && true_regnum (IN) == -1))) ? GENERAL_REGS : NO_REGS) /* On SPARC it is not possible to directly move data between GENERAL_REGS and FP_REGS. */ ! #define SECONDARY_MEMORY_NEEDED(CLASS1, CLASS2, MODE) \ ! (FP_REG_CLASS_P (CLASS1) != FP_REG_CLASS_P (CLASS2)) /* Return the stack location to use for secondary memory needed reloads. *************** *** 1099,1103 **** /* On SPARC, this is the size of MODE in words. */ #define CLASS_MAX_NREGS(CLASS, MODE) \ ! ((CLASS) == FP_REGS ? (GET_MODE_SIZE (MODE) + 3) / 4 \ : (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) --- 1107,1111 ---- /* On SPARC, this is the size of MODE in words. */ #define CLASS_MAX_NREGS(CLASS, MODE) \ ! (FP_REG_CLASS_P (CLASS) ? (GET_MODE_SIZE (MODE) + 3) / 4 \ : (GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD) *************** *** 1510,1513 **** --- 1518,1522 ---- to do this is made in regclass.c. */ + extern int leaf_function; #define FUNCTION_PROLOGUE(FILE, SIZE) \ (TARGET_FRW ? sparc_flat_output_function_prologue (FILE, SIZE) \ *************** *** 1860,1864 **** register rtx op1 = XEXP (X, 1); \ if (RTX_OK_FOR_BASE_P (op0) \ ! && CONSTANT_P (op1)) \ goto ADDR; \ } \ --- 1869,1877 ---- register rtx op1 = XEXP (X, 1); \ if (RTX_OK_FOR_BASE_P (op0) \ ! && CONSTANT_P (op1) \ ! /* We can't allow TFmode, because an offset \ ! greater than or equal to the alignment (8) \ ! may cause the LO_SUM to overflow. */ \ ! && MODE != TFmode) \ goto ADDR; \ } \ *************** *** 2069,2073 **** #define MULTF3_LIBCALL "_Q_mul" #define DIVTF3_LIBCALL "_Q_div" - #define SQRTTF2_LIBCALL "_Q_sqrt" #define FLOATSITF2_LIBCALL "_Q_itoq" #define FIX_TRUNCTFSI2_LIBCALL "_Q_qtoi" --- 2082,2085 ---- *************** *** 2084,2087 **** --- 2096,2113 ---- #define LETF2_LIBCALL "_Q_fle" + /* We can define the TFmode sqrt optab only if TARGET_FPU. This is because + with soft-float, the SFmode and DFmode sqrt instructions will be absent, + and the compiler will notice and try to use the TFmode sqrt instruction + for calls to the builtin function sqrt, but this fails. */ + #define INIT_TARGET_OPTABS \ + do { \ + INIT_SUBTARGET_OPTABS; \ + if (TARGET_FPU) \ + sqrt_optab->handlers[(int) TFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "_Q_sqrt"); \ + } while (0) + + /* This is meant to be redefined in the host dependent files */ + #define INIT_SUBTARGET_OPTABS + /* Compute the cost of computing a constant rtl expression RTX whose rtx-code is CODE. The body of this macro is a portion *************** *** 2119,2124 **** ??? v9: We ignore FPCC_REGS on the assumption they'll never be seen. */ #define REGISTER_MOVE_COST(CLASS1, CLASS2) \ ! (((CLASS1 == FP_REGS && CLASS2 == GENERAL_REGS) \ ! || (CLASS1 == GENERAL_REGS && CLASS2 == FP_REGS)) ? 6 : 2) /* Provide the costs of a rtl expression. This is in the body of a --- 2145,2150 ---- ??? v9: We ignore FPCC_REGS on the assumption they'll never be seen. */ #define REGISTER_MOVE_COST(CLASS1, CLASS2) \ ! (((FP_REG_CLASS_P (CLASS1) && (CLASS2) == GENERAL_REGS) \ ! || ((CLASS1) == GENERAL_REGS && FP_REG_CLASS_P (CLASS2))) ? 6 : 2) /* Provide the costs of a rtl expression. This is in the body of a diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/sparc.md gcc-2.6.1/config/sparc/sparc.md *** gcc-2.6.0/config/sparc/sparc.md Tue Jun 28 15:25:23 1994 --- gcc-2.6.1/config/sparc/sparc.md Mon Oct 31 13:22:27 1994 *************** *** 21,27 **** ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. - ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al. ;; Architecture type. Arch32bit includes v7, sparclite, v8. --- 21,32 ---- ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. ;;- See file "rtl.def" for documentation on define_insn, match_*, et. al. + ;; The upper 32 fp regs on the v9 can't hold SFmode values. To deal with this + ;; a second register class, EXTRA_FP_REGS, exists for the v9 chip. The name + ;; is a bit of a misnomer as it covers all 64 fp regs. The corresponding + ;; constraint letter is 'e'. To avoid any confusion, 'e' is used instead of + ;; 'f' for all DF/TFmode values, including those that are specific to the v8. + ;; Architecture type. Arch32bit includes v7, sparclite, v8. *************** *** 702,707 **** (define_insn "" [(set (reg:CCFPE 0) ! (compare:CCFPE (match_operand:DF 0 "register_operand" "f") ! (match_operand:DF 1 "register_operand" "f")))] "! TARGET_V9 && TARGET_FPU" "fcmped %0,%1" --- 707,712 ---- (define_insn "" [(set (reg:CCFPE 0) ! (compare:CCFPE (match_operand:DF 0 "register_operand" "e") ! (match_operand:DF 1 "register_operand" "e")))] "! TARGET_V9 && TARGET_FPU" "fcmped %0,%1" *************** *** 710,715 **** (define_insn "" [(set (reg:CCFPE 0) ! (compare:CCFPE (match_operand:TF 0 "register_operand" "f") ! (match_operand:TF 1 "register_operand" "f")))] "! TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpeq %0,%1" --- 715,720 ---- (define_insn "" [(set (reg:CCFPE 0) ! (compare:CCFPE (match_operand:TF 0 "register_operand" "e") ! (match_operand:TF 1 "register_operand" "e")))] "! TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpeq %0,%1" *************** *** 726,731 **** (define_insn "" [(set (reg:CCFP 0) ! (compare:CCFP (match_operand:DF 0 "register_operand" "f") ! (match_operand:DF 1 "register_operand" "f")))] "! TARGET_V9 && TARGET_FPU" "fcmpd %0,%1" --- 731,736 ---- (define_insn "" [(set (reg:CCFP 0) ! (compare:CCFP (match_operand:DF 0 "register_operand" "e") ! (match_operand:DF 1 "register_operand" "e")))] "! TARGET_V9 && TARGET_FPU" "fcmpd %0,%1" *************** *** 734,739 **** (define_insn "" [(set (reg:CCFP 0) ! (compare:CCFP (match_operand:TF 0 "register_operand" "f") ! (match_operand:TF 1 "register_operand" "f")))] "! TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpq %0,%1" --- 739,744 ---- (define_insn "" [(set (reg:CCFP 0) ! (compare:CCFP (match_operand:TF 0 "register_operand" "e") ! (match_operand:TF 1 "register_operand" "e")))] "! TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpq %0,%1" *************** *** 758,763 **** (define_insn "" [(set (match_operand:CCFPE 0 "ccfp_reg_operand" "=c") ! (compare:CCFPE (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_V9 && TARGET_FPU" "fcmped %0,%1,%2" --- 763,768 ---- (define_insn "" [(set (match_operand:CCFPE 0 "ccfp_reg_operand" "=c") ! (compare:CCFPE (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_V9 && TARGET_FPU" "fcmped %0,%1,%2" *************** *** 766,771 **** (define_insn "" [(set (match_operand:CCFPE 0 "ccfp_reg_operand" "=c") ! (compare:CCFPE (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpeq %0,%1,%2" --- 771,776 ---- (define_insn "" [(set (match_operand:CCFPE 0 "ccfp_reg_operand" "=c") ! (compare:CCFPE (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpeq %0,%1,%2" *************** *** 782,787 **** (define_insn "" [(set (match_operand:CCFP 0 "ccfp_reg_operand" "=c") ! (compare:CCFP (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_V9 && TARGET_FPU" "fcmpd %0,%1,%2" --- 787,792 ---- (define_insn "" [(set (match_operand:CCFP 0 "ccfp_reg_operand" "=c") ! (compare:CCFP (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_V9 && TARGET_FPU" "fcmpd %0,%1,%2" *************** *** 790,795 **** (define_insn "" [(set (match_operand:CCFP 0 "ccfp_reg_operand" "=c") ! (compare:CCFP (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpq %0,%1,%2" --- 795,800 ---- (define_insn "" [(set (match_operand:CCFP 0 "ccfp_reg_operand" "=c") ! (compare:CCFP (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fcmpq %0,%1,%2" *************** *** 1970,1974 **** (define_insn "" ! [(set (match_operand:DF 0 "general_operand" "=?r,f,o") (match_operand:DF 1 "" "?E,m,G"))] "TARGET_FPU && GET_CODE (operands[1]) == CONST_DOUBLE" --- 1975,1979 ---- (define_insn "" ! [(set (match_operand:DF 0 "general_operand" "=?r,e,o") (match_operand:DF 1 "" "?E,m,G"))] "TARGET_FPU && GET_CODE (operands[1]) == CONST_DOUBLE" *************** *** 2007,2012 **** (define_insn "" ! [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand" "=T,U,f,r,Q,Q,f,r") ! (match_operand:DF 1 "reg_or_nonsymb_mem_operand" "U,T,f,r,f,r,Q,Q"))] "TARGET_FPU && (register_operand (operands[0], DFmode) --- 2012,2017 ---- (define_insn "" ! [(set (match_operand:DF 0 "reg_or_nonsymb_mem_operand" "=T,U,e,r,Q,Q,e,r") ! (match_operand:DF 1 "reg_or_nonsymb_mem_operand" "U,T,e,r,e,r,Q,Q"))] "TARGET_FPU && (register_operand (operands[0], DFmode) *************** *** 2021,2026 **** (set_attr "length" "1,1,2,2,3,3,3,3")]) ! ;; Exactly the same as above, except that all `f' cases are deleted. ! ;; This is necessary to prevent reload from ever trying to use a `f' reg ;; when -mno-fpu. --- 2026,2031 ---- (set_attr "length" "1,1,2,2,3,3,3,3")]) ! ;; Exactly the same as above, except that all `e' cases are deleted. ! ;; This is necessary to prevent reload from ever trying to use a `e' reg ;; when -mno-fpu. *************** *** 2035,2038 **** --- 2040,2045 ---- (set_attr "length" "1,1,2,3,3")]) + ;; Must handle overlapping registers here, since parameters can be unaligned + ;; in registers. ;; ??? Do we need a v9 version of this? (define_split *************** *** 2043,2054 **** (set (match_dup 4) (match_dup 5))] " ! { operands[2] = operand_subword (operands[0], 0, 0, DFmode); ! operands[3] = operand_subword (operands[1], 0, 0, DFmode); ! operands[4] = operand_subword (operands[0], 1, 0, DFmode); ! operands[5] = operand_subword (operands[1], 1, 0, DFmode); }") (define_insn "" [(set (mem:DF (match_operand:SI 0 "symbolic_operand" "i,i")) ! (match_operand:DF 1 "reg_or_0_operand" "rf,G")) (clobber (match_scratch:SI 2 "=&r,&r"))] "(reload_completed || reload_in_progress) && ! TARGET_PTR64" --- 2050,2076 ---- (set (match_dup 4) (match_dup 5))] " ! { ! rtx first_set = operand_subword (operands[0], 0, 0, DFmode); ! rtx second_use = operand_subword (operands[1], 1, 0, DFmode); ! ! if (REGNO (first_set) == REGNO (second_use)) ! { ! operands[2] = operand_subword (operands[0], 1, 0, DFmode); ! operands[3] = second_use; ! operands[4] = first_set; ! operands[5] = operand_subword (operands[1], 0, 0, DFmode); ! } ! else ! { ! operands[2] = first_set; ! operands[3] = operand_subword (operands[1], 0, 0, DFmode); ! operands[4] = operand_subword (operands[0], 1, 0, DFmode); ! operands[5] = second_use; ! } ! }") (define_insn "" [(set (mem:DF (match_operand:SI 0 "symbolic_operand" "i,i")) ! (match_operand:DF 1 "reg_or_0_operand" "re,G")) (clobber (match_scratch:SI 2 "=&r,&r"))] "(reload_completed || reload_in_progress) && ! TARGET_PTR64" *************** *** 2068,2072 **** ;; It must come before the more general movtf pattern. (define_insn "" ! [(set (match_operand:TF 0 "general_operand" "=?r,f,o") (match_operand:TF 1 "" "?E,m,G"))] "TARGET_FPU && GET_CODE (operands[1]) == CONST_DOUBLE" --- 2090,2094 ---- ;; It must come before the more general movtf pattern. (define_insn "" ! [(set (match_operand:TF 0 "general_operand" "=?r,e,o") (match_operand:TF 1 "" "?E,m,G"))] "TARGET_FPU && GET_CODE (operands[1]) == CONST_DOUBLE" *************** *** 2109,2114 **** (define_insn "" ! [(set (match_operand:TF 0 "reg_or_nonsymb_mem_operand" "=f,r,Q,Q,f,&r") ! (match_operand:TF 1 "reg_or_nonsymb_mem_operand" "f,r,f,r,Q,Q"))] "TARGET_FPU && (register_operand (operands[0], TFmode) --- 2131,2136 ---- (define_insn "" ! [(set (match_operand:TF 0 "reg_or_nonsymb_mem_operand" "=e,r,Q,Q,e,&r") ! (match_operand:TF 1 "reg_or_nonsymb_mem_operand" "e,r,e,r,Q,Q"))] "TARGET_FPU && (register_operand (operands[0], TFmode) *************** *** 2123,2128 **** (set_attr "length" "4,4,5,5,5,5")]) ! ;; Exactly the same as above, except that all `f' cases are deleted. ! ;; This is necessary to prevent reload from ever trying to use a `f' reg ;; when -mno-fpu. --- 2145,2150 ---- (set_attr "length" "4,4,5,5,5,5")]) ! ;; Exactly the same as above, except that all `e' cases are deleted. ! ;; This is necessary to prevent reload from ever trying to use a `e' reg ;; when -mno-fpu. *************** *** 2142,2150 **** (set_attr "length" "4,5,5")]) (define_insn "" [(set (mem:TF (match_operand:SI 0 "symbolic_operand" "i,i")) ! (match_operand:TF 1 "reg_or_0_operand" "rf,G")) (clobber (match_scratch:SI 2 "=&r,&r"))] ! "(reload_completed || reload_in_progress) && ! TARGET_PTR64" "* { --- 2164,2175 ---- (set_attr "length" "4,5,5")]) + ;; This is disabled because it does not work. Long doubles have only 8 + ;; byte alignment. Adding an offset of 8 or 12 to an 8 byte aligned %lo may + ;; cause it to overflow. See also GO_IF_LEGITIMATE_ADDRESS. (define_insn "" [(set (mem:TF (match_operand:SI 0 "symbolic_operand" "i,i")) ! (match_operand:TF 1 "reg_or_0_operand" "re,G")) (clobber (match_scratch:SI 2 "=&r,&r"))] ! "0 && (reload_completed || reload_in_progress) && ! TARGET_PTR64" "* { *************** *** 2283,2291 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (if_then_else (match_operator 1 "v9_regcmp_op" [(match_operand:DI 2 "register_operand" "r") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "f") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2308,2316 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (if_then_else (match_operator 1 "v9_regcmp_op" [(match_operand:DI 2 "register_operand" "r") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "e") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2294,2302 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") (if_then_else (match_operator 1 "v9_regcmp_op" [(match_operand:DI 2 "register_operand" "r") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "f") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2319,2327 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") (if_then_else (match_operator 1 "v9_regcmp_op" [(match_operand:DI 2 "register_operand" "r") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "e") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2327,2335 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFP 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "f") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2352,2360 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFP 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "e") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2338,2346 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFPE 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "f") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2363,2371 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFPE 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:DF 3 "register_operand" "e") (match_operand:DF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2349,2357 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFP 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "f") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2374,2382 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFP 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "e") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2360,2368 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFPE 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "f") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2385,2393 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(match_operand:CCFPE 2 "ccfp_reg_operand" "c") (const_int 0)]) ! (match_operand:TF 3 "register_operand" "e") (match_operand:TF 4 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2381,2388 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(reg:CC 0) (const_int 0)]) ! (match_operand:DF 2 "register_operand" "f") (match_operand:DF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2406,2413 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(reg:CC 0) (const_int 0)]) ! (match_operand:DF 2 "register_operand" "e") (match_operand:DF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2391,2398 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(reg:CC 0) (const_int 0)]) ! (match_operand:TF 2 "register_operand" "f") (match_operand:TF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2416,2423 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(reg:CC 0) (const_int 0)]) ! (match_operand:TF 2 "register_operand" "e") (match_operand:TF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2411,2418 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(reg:CCX 0) (const_int 0)]) ! (match_operand:DF 2 "register_operand" "f") (match_operand:DF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2436,2443 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(reg:CCX 0) (const_int 0)]) ! (match_operand:DF 2 "register_operand" "e") (match_operand:DF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2421,2428 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") (if_then_else (match_operator 1 "comparison_operator" [(reg:CCX 0) (const_int 0)]) ! (match_operand:TF 2 "register_operand" "f") (match_operand:TF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" --- 2446,2453 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") (if_then_else (match_operator 1 "comparison_operator" [(reg:CCX 0) (const_int 0)]) ! (match_operand:TF 2 "register_operand" "e") (match_operand:TF 3 "register_operand" "0")))] "TARGET_V9 && TARGET_FPU" *************** *** 2823,2827 **** (define_insn "extendsfdf2" ! [(set (match_operand:DF 0 "register_operand" "=f") (float_extend:DF (match_operand:SF 1 "register_operand" "f")))] --- 2848,2852 ---- (define_insn "extendsfdf2" ! [(set (match_operand:DF 0 "register_operand" "=e") (float_extend:DF (match_operand:SF 1 "register_operand" "f")))] *************** *** 2831,2835 **** (define_insn "extendsftf2" ! [(set (match_operand:TF 0 "register_operand" "=f") (float_extend:TF (match_operand:SF 1 "register_operand" "f")))] --- 2856,2860 ---- (define_insn "extendsftf2" ! [(set (match_operand:TF 0 "register_operand" "=e") (float_extend:TF (match_operand:SF 1 "register_operand" "f")))] *************** *** 2839,2845 **** (define_insn "extenddftf2" ! [(set (match_operand:TF 0 "register_operand" "=f") (float_extend:TF ! (match_operand:DF 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fdtoq %1,%0" --- 2864,2870 ---- (define_insn "extenddftf2" ! [(set (match_operand:TF 0 "register_operand" "=e") (float_extend:TF ! (match_operand:DF 1 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fdtoq %1,%0" *************** *** 2849,2853 **** [(set (match_operand:SF 0 "register_operand" "=f") (float_truncate:SF ! (match_operand:DF 1 "register_operand" "f")))] "TARGET_FPU" "fdtos %1,%0" --- 2874,2878 ---- [(set (match_operand:SF 0 "register_operand" "=f") (float_truncate:SF ! (match_operand:DF 1 "register_operand" "e")))] "TARGET_FPU" "fdtos %1,%0" *************** *** 2857,2861 **** [(set (match_operand:SF 0 "register_operand" "=f") (float_truncate:SF ! (match_operand:TF 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtos %1,%0" --- 2882,2886 ---- [(set (match_operand:SF 0 "register_operand" "=f") (float_truncate:SF ! (match_operand:TF 1 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtos %1,%0" *************** *** 2863,2869 **** (define_insn "trunctfdf2" ! [(set (match_operand:DF 0 "register_operand" "=f") (float_truncate:DF ! (match_operand:TF 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtod %1,%0" --- 2888,2894 ---- (define_insn "trunctfdf2" ! [(set (match_operand:DF 0 "register_operand" "=e") (float_truncate:DF ! (match_operand:TF 1 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtod %1,%0" *************** *** 2880,2884 **** (define_insn "floatsidf2" ! [(set (match_operand:DF 0 "register_operand" "=f") (float:DF (match_operand:SI 1 "register_operand" "f")))] "TARGET_FPU" --- 2905,2909 ---- (define_insn "floatsidf2" ! [(set (match_operand:DF 0 "register_operand" "=e") (float:DF (match_operand:SI 1 "register_operand" "f")))] "TARGET_FPU" *************** *** 2887,2891 **** (define_insn "floatsitf2" ! [(set (match_operand:TF 0 "register_operand" "=f") (float:TF (match_operand:SI 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" --- 2912,2916 ---- (define_insn "floatsitf2" ! [(set (match_operand:TF 0 "register_operand" "=e") (float:TF (match_operand:SI 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" *************** *** 2935,2939 **** [(parallel [(set (match_operand:SF 0 "register_operand" "=f") (float:SF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" --- 2960,2964 ---- [(parallel [(set (match_operand:SF 0 "register_operand" "=f") (float:SF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" *************** *** 2950,2956 **** (define_insn "" ! [(parallel [(set (match_operand:DF 0 "register_operand" "=f") (float:DF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" --- 2975,2981 ---- (define_insn "" ! [(parallel [(set (match_operand:DF 0 "register_operand" "=e") (float:DF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" *************** *** 2967,2973 **** (define_insn "" ! [(parallel [(set (match_operand:TF 0 "register_operand" "=f") (float:TF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" --- 2992,2998 ---- (define_insn "" ! [(parallel [(set (match_operand:TF 0 "register_operand" "=e") (float:TF (match_operand:DI 1 "general_operand" "rm"))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" *************** *** 2987,2991 **** (define_insn "floatdisf2_v9" [(set (match_operand:SF 0 "register_operand" "=f") ! (float:SF (match_operand:DI 1 "register_operand" "f")))] "0 && TARGET_V9 && TARGET_FPU" "fxtos %1,%0" --- 3012,3016 ---- (define_insn "floatdisf2_v9" [(set (match_operand:SF 0 "register_operand" "=f") ! (float:SF (match_operand:DI 1 "register_operand" "e")))] "0 && TARGET_V9 && TARGET_FPU" "fxtos %1,%0" *************** *** 2993,2998 **** (define_insn "floatdidf2_v9" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (float:DF (match_operand:DI 1 "register_operand" "f")))] "0 && TARGET_V9 && TARGET_FPU" "fxtod %1,%0" --- 3018,3023 ---- (define_insn "floatdidf2_v9" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (float:DF (match_operand:DI 1 "register_operand" "e")))] "0 && TARGET_V9 && TARGET_FPU" "fxtod %1,%0" *************** *** 3000,3005 **** (define_insn "floatditf2_v9" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (float:TF (match_operand:DI 1 "register_operand" "f")))] "0 && TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fxtoq %1,%0" --- 3025,3030 ---- (define_insn "floatditf2_v9" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (float:TF (match_operand:DI 1 "register_operand" "e")))] "0 && TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fxtoq %1,%0" *************** *** 3018,3022 **** (define_insn "fix_truncdfsi2" [(set (match_operand:SI 0 "register_operand" "=f") ! (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "f"))))] "TARGET_FPU" "fdtoi %1,%0" --- 3043,3047 ---- (define_insn "fix_truncdfsi2" [(set (match_operand:SI 0 "register_operand" "=f") ! (fix:SI (fix:DF (match_operand:DF 1 "register_operand" "e"))))] "TARGET_FPU" "fdtoi %1,%0" *************** *** 3025,3029 **** (define_insn "fix_trunctfsi2" [(set (match_operand:SI 0 "register_operand" "=f") ! (fix:SI (fix:TF (match_operand:TF 1 "register_operand" "f"))))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtoi %1,%0" --- 3050,3054 ---- (define_insn "fix_trunctfsi2" [(set (match_operand:SI 0 "register_operand" "=f") ! (fix:SI (fix:TF (match_operand:TF 1 "register_operand" "e"))))] "TARGET_FPU && TARGET_HARD_QUAD" "fqtoi %1,%0" *************** *** 3077,3081 **** [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") (fix:DI (fix:SF (match_operand:SF 1 "register_operand" "f")))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" --- 3102,3106 ---- [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") (fix:DI (fix:SF (match_operand:SF 1 "register_operand" "f")))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" *************** *** 3093,3098 **** (define_insn "" [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") ! (fix:DI (fix:DF (match_operand:DF 1 "register_operand" "f")))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" --- 3118,3123 ---- (define_insn "" [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") ! (fix:DI (fix:DF (match_operand:DF 1 "register_operand" "e")))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU" *************** *** 3110,3115 **** (define_insn "" [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") ! (fix:DI (fix:TF (match_operand:TF 1 "register_operand" "f")))) ! (clobber (match_operand:DF 2 "register_operand" "=&f")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" --- 3135,3140 ---- (define_insn "" [(parallel [(set (match_operand:DI 0 "general_operand" "=rm") ! (fix:DI (fix:TF (match_operand:TF 1 "register_operand" "e")))) ! (clobber (match_operand:DF 2 "register_operand" "=&e")) (clobber (match_operand:DI 3 "memory_operand" "m"))])] "TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" *************** *** 3128,3132 **** (define_insn "fix_truncsfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=f") (fix:DI (fix:SF (match_operand:SF 1 "register_operand" "f"))))] "0 && TARGET_V9 && TARGET_FPU" --- 3153,3157 ---- (define_insn "fix_truncsfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=e") (fix:DI (fix:SF (match_operand:SF 1 "register_operand" "f"))))] "0 && TARGET_V9 && TARGET_FPU" *************** *** 3135,3140 **** (define_insn "fix_truncdfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=f") ! (fix:DI (fix:DF (match_operand:DF 1 "register_operand" "f"))))] "0 && TARGET_V9 && TARGET_FPU" "fdtox %1,%0" --- 3160,3165 ---- (define_insn "fix_truncdfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=e") ! (fix:DI (fix:DF (match_operand:DF 1 "register_operand" "e"))))] "0 && TARGET_V9 && TARGET_FPU" "fdtox %1,%0" *************** *** 3142,3147 **** (define_insn "fix_trunctfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=f") ! (fix:DI (fix:TF (match_operand:TF 1 "register_operand" "f"))))] "0 && TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fqtox %1,%0" --- 3167,3172 ---- (define_insn "fix_trunctfdi2_v9" ! [(set (match_operand:DI 0 "register_operand" "=e") ! (fix:DI (fix:TF (match_operand:TF 1 "register_operand" "e"))))] "0 && TARGET_V9 && TARGET_FPU && TARGET_HARD_QUAD" "fqtox %1,%0" *************** *** 4069,4073 **** (define_insn "negsi2" ! [(set (match_operand:SI 0 "general_operand" "=r") (neg:SI (match_operand:SI 1 "arith_operand" "rI")))] "" --- 4094,4098 ---- (define_insn "negsi2" ! [(set (match_operand:SI 0 "register_operand" "=r") (neg:SI (match_operand:SI 1 "arith_operand" "rI")))] "" *************** *** 4180,4186 **** (define_insn "addtf3" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (plus:TF (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "faddq %1,%2,%0" --- 4205,4211 ---- (define_insn "addtf3" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (plus:TF (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "faddq %1,%2,%0" *************** *** 4188,4194 **** (define_insn "adddf3" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (plus:DF (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_FPU" "faddd %1,%2,%0" --- 4213,4219 ---- (define_insn "adddf3" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (plus:DF (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_FPU" "faddd %1,%2,%0" *************** *** 4204,4210 **** (define_insn "subtf3" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (minus:TF (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fsubq %1,%2,%0" --- 4229,4235 ---- (define_insn "subtf3" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (minus:TF (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fsubq %1,%2,%0" *************** *** 4212,4218 **** (define_insn "subdf3" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (minus:DF (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_FPU" "fsubd %1,%2,%0" --- 4237,4243 ---- (define_insn "subdf3" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (minus:DF (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_FPU" "fsubd %1,%2,%0" *************** *** 4228,4234 **** (define_insn "multf3" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (mult:TF (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fmulq %1,%2,%0" --- 4253,4259 ---- (define_insn "multf3" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (mult:TF (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fmulq %1,%2,%0" *************** *** 4236,4242 **** (define_insn "muldf3" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (mult:DF (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_FPU" "fmuld %1,%2,%0" --- 4261,4267 ---- (define_insn "muldf3" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (mult:DF (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_FPU" "fmuld %1,%2,%0" *************** *** 4252,4256 **** (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=f") (mult:DF (float_extend:DF (match_operand:SF 1 "register_operand" "f")) (float_extend:DF (match_operand:SF 2 "register_operand" "f"))))] --- 4277,4281 ---- (define_insn "" ! [(set (match_operand:DF 0 "register_operand" "=e") (mult:DF (float_extend:DF (match_operand:SF 1 "register_operand" "f")) (float_extend:DF (match_operand:SF 2 "register_operand" "f"))))] *************** *** 4260,4266 **** (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (mult:TF (float_extend:TF (match_operand:DF 1 "register_operand" "f")) ! (float_extend:TF (match_operand:DF 2 "register_operand" "f"))))] "(TARGET_V8 || TARGET_V9) && TARGET_FPU" "fdmulq %1,%2,%0" --- 4285,4291 ---- (define_insn "" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (mult:TF (float_extend:TF (match_operand:DF 1 "register_operand" "e")) ! (float_extend:TF (match_operand:DF 2 "register_operand" "e"))))] "(TARGET_V8 || TARGET_V9) && TARGET_FPU" "fdmulq %1,%2,%0" *************** *** 4269,4275 **** ;; don't have timing for quad-prec. divide. (define_insn "divtf3" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (div:TF (match_operand:TF 1 "register_operand" "f") ! (match_operand:TF 2 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fdivq %1,%2,%0" --- 4294,4300 ---- ;; don't have timing for quad-prec. divide. (define_insn "divtf3" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (div:TF (match_operand:TF 1 "register_operand" "e") ! (match_operand:TF 2 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fdivq %1,%2,%0" *************** *** 4277,4283 **** (define_insn "divdf3" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (div:DF (match_operand:DF 1 "register_operand" "f") ! (match_operand:DF 2 "register_operand" "f")))] "TARGET_FPU" "fdivd %1,%2,%0" --- 4302,4308 ---- (define_insn "divdf3" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (div:DF (match_operand:DF 1 "register_operand" "e") ! (match_operand:DF 2 "register_operand" "e")))] "TARGET_FPU" "fdivd %1,%2,%0" *************** *** 4293,4298 **** (define_insn "negtf2" ! [(set (match_operand:TF 0 "register_operand" "=f,f") ! (neg:TF (match_operand:TF 1 "register_operand" "0,f")))] "TARGET_FPU" "* --- 4318,4323 ---- (define_insn "negtf2" ! [(set (match_operand:TF 0 "register_operand" "=e,e") ! (neg:TF (match_operand:TF 1 "register_operand" "0,e")))] "TARGET_FPU" "* *************** *** 4311,4316 **** (define_insn "negdf2" ! [(set (match_operand:DF 0 "register_operand" "=f,f") ! (neg:DF (match_operand:DF 1 "register_operand" "0,f")))] "TARGET_FPU" "* --- 4336,4341 ---- (define_insn "negdf2" ! [(set (match_operand:DF 0 "register_operand" "=e,e") ! (neg:DF (match_operand:DF 1 "register_operand" "0,e")))] "TARGET_FPU" "* *************** *** 4336,4341 **** (define_insn "abstf2" ! [(set (match_operand:TF 0 "register_operand" "=f,f") ! (abs:TF (match_operand:TF 1 "register_operand" "0,f")))] "TARGET_FPU" "* --- 4361,4366 ---- (define_insn "abstf2" ! [(set (match_operand:TF 0 "register_operand" "=e,e") ! (abs:TF (match_operand:TF 1 "register_operand" "0,e")))] "TARGET_FPU" "* *************** *** 4354,4359 **** (define_insn "absdf2" ! [(set (match_operand:DF 0 "register_operand" "=f,f") ! (abs:DF (match_operand:DF 1 "register_operand" "0,f")))] "TARGET_FPU" "* --- 4379,4384 ---- (define_insn "absdf2" ! [(set (match_operand:DF 0 "register_operand" "=e,e") ! (abs:DF (match_operand:DF 1 "register_operand" "0,e")))] "TARGET_FPU" "* *************** *** 4379,4384 **** (define_insn "sqrttf2" ! [(set (match_operand:TF 0 "register_operand" "=f") ! (sqrt:TF (match_operand:TF 1 "register_operand" "f")))] "TARGET_FPU && TARGET_HARD_QUAD" "fsqrtq %1,%0" --- 4404,4409 ---- (define_insn "sqrttf2" ! [(set (match_operand:TF 0 "register_operand" "=e") ! (sqrt:TF (match_operand:TF 1 "register_operand" "e")))] "TARGET_FPU && TARGET_HARD_QUAD" "fsqrtq %1,%0" *************** *** 4386,4391 **** (define_insn "sqrtdf2" ! [(set (match_operand:DF 0 "register_operand" "=f") ! (sqrt:DF (match_operand:DF 1 "register_operand" "f")))] "TARGET_FPU" "fsqrtd %1,%0" --- 4411,4416 ---- (define_insn "sqrtdf2" ! [(set (match_operand:DF 0 "register_operand" "=e") ! (sqrt:DF (match_operand:DF 1 "register_operand" "e")))] "TARGET_FPU" "fsqrtd %1,%0" *************** *** 4616,4620 **** Why cannot we have delay slots filled if it were a CALL? */ ! if (! TARGET_V9 && INTVAL (operands[3]) > 0) emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3, gen_rtx (SET, VOIDmode, pc_rtx, --- 4641,4645 ---- Why cannot we have delay slots filled if it were a CALL? */ ! if (! TARGET_V9 && INTVAL (operands[3]) != 0) emit_jump_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3, gen_rtx (SET, VOIDmode, pc_rtx, *************** *** 4646,4650 **** #endif ! if (! TARGET_V9 && INTVAL (operands[3]) > 0) emit_call_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3, gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx), --- 4671,4675 ---- #endif ! if (! TARGET_V9 && INTVAL (operands[3]) != 0) emit_call_insn (gen_rtx (PARALLEL, VOIDmode, gen_rtvec (3, gen_rtx (CALL, VOIDmode, fn_rtx, nregs_rtx), *************** *** 4688,4692 **** (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "immediate_operand" "i")) (match_operand 1 "" "")) (clobber (reg:SI 15))] --- 4713,4717 ---- (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "symbolic_operand" "s")) (match_operand 1 "" "")) (clobber (reg:SI 15))] *************** *** 4712,4716 **** (define_insn "" ! [(call (mem:SI (match_operand:DI 0 "immediate_operand" "i")) (match_operand 1 "" "")) (clobber (reg:DI 15))] --- 4737,4741 ---- (define_insn "" ! [(call (mem:SI (match_operand:DI 0 "symbolic_operand" "s")) (match_operand 1 "" "")) (clobber (reg:DI 15))] *************** *** 4741,4745 **** ;; There is no such critter for v9 (??? we may need one anyway). (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "immediate_operand" "i")) (match_operand 1 "" "")) (match_operand 2 "immediate_operand" "") --- 4766,4770 ---- ;; There is no such critter for v9 (??? we may need one anyway). (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "symbolic_operand" "s")) (match_operand 1 "" "")) (match_operand 2 "immediate_operand" "") *************** *** 4753,4756 **** --- 4778,4810 ---- [(set_attr "type" "call_no_delay_slot")]) + ;; This is a call that may want a structure value. This is used for + ;; untyped_calls. + (define_insn "" + [(call (mem:SI (match_operand:SI 0 "address_operand" "p")) + (match_operand 1 "" "")) + (match_operand 2 "immediate_operand" "") + (clobber (reg:SI 15))] + ;;- Do not use operand 1 for most machines. + "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 0" + "* + { + return \"call %a0,%1\;nop\;nop\"; + }" + [(set_attr "type" "call_no_delay_slot")]) + + ;; This is a call that wants a structure value. + (define_insn "" + [(call (mem:SI (match_operand:SI 0 "symbolic_operand" "s")) + (match_operand 1 "" "")) + (match_operand 2 "immediate_operand" "") + (clobber (reg:SI 15))] + ;;- Do not use operand 1 for most machines. + "! TARGET_V9 && GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) < 0" + "* + { + return \"call %a0,%1\;nop\;nop\"; + }" + [(set_attr "type" "call_no_delay_slot")]) + (define_expand "call_value" ;; Note that this expression is not used for generating RTL. *************** *** 4806,4810 **** (define_insn "" [(set (match_operand 0 "" "=rf") ! (call (mem:SI (match_operand:SI 1 "immediate_operand" "i")) (match_operand 2 "" ""))) (clobber (reg:SI 15))] --- 4860,4864 ---- (define_insn "" [(set (match_operand 0 "" "=rf") ! (call (mem:SI (match_operand:SI 1 "symbolic_operand" "s")) (match_operand 2 "" ""))) (clobber (reg:SI 15))] *************** *** 4832,4836 **** (define_insn "" [(set (match_operand 0 "" "=rf") ! (call (mem:SI (match_operand:DI 1 "immediate_operand" "i")) (match_operand 2 "" ""))) (clobber (reg:DI 15))] --- 4886,4890 ---- (define_insn "" [(set (match_operand 0 "" "=rf") ! (call (mem:SI (match_operand:DI 1 "symbolic_operand" "s")) (match_operand 2 "" ""))) (clobber (reg:DI 15))] *************** *** 4844,4924 **** (define_expand "untyped_call" ! [(parallel [(call (match_operand:SI 0 "call_operand" "") (const_int 0)) ! (match_operand:BLK 1 "memory_operand" "") ! (match_operand 2 "" "") ! ;; ??? v9: mode is wrong here. ! (clobber (reg:SI 15))])] "" " { ! operands[1] = change_address (operands[1], DImode, XEXP (operands[1], 0)); ! }") ! ! ;; Make a call followed by two nops in case the function being called ! ;; returns a structure value and expects to skip an unimp instruction. ! (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "address_operand" "p")) ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "") ! (clobber (reg:SI 15))] ! "! TARGET_V9" ! "* ! { ! operands[2] = adj_offsettable_operand (operands[1], 8); ! return \"call %a0,0\;nop\;nop\;std %%o0,%1\;std %%f0,%2\"; ! }" ! [(set_attr "type" "multi")]) ! ;; Make a call followed by two nops in case the function being called ! ;; returns a structure value and expects to skip an unimp instruction. ! (define_insn "" ! [(call (mem:SI (match_operand:SI 0 "immediate_operand" "i")) ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "") ! (clobber (reg:SI 15))] ! "" ! "* ! { ! operands[2] = adj_offsettable_operand (operands[1], 8); ! return \"call %a0,0\;nop\;nop\;std %%o0,%1\;std %%f0,%2\"; ! }" ! [(set_attr "type" "multi")]) ! ;; V9 version of untyped_call. ! (define_insn "" ! [(call (mem:SI (match_operand:DI 0 "address_operand" "p")) ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "") ! ;; ??? Mode is wrong here, but it must match the define_expand. ! (clobber (reg:SI 15))] ! "TARGET_V9" ! "* ! { ! operands[2] = adj_offsettable_operand (operands[1], 8); ! return \"call %a0,0\;nop\;stx %%o0,%1\;stq %%f0,%2\"; ! }" ! [(set_attr "type" "multi")]) ! (define_insn "" ! [(call (mem:SI (match_operand:DI 0 "immediate_operand" "i")) ! (const_int 0)) ! (match_operand:DI 1 "memory_operand" "o") ! (match_operand 2 "" "") ! ;; ??? Mode is wrong here, but it must match the define_expand. ! (clobber (reg:SI 15))] ! "TARGET_V9" ! "* ! { ! operands[2] = adj_offsettable_operand (operands[1], 8); ! return \"call %a0,0\;nop\;stx %%o0,%1\;stq %%f0,%2\"; ! }" ! [(set_attr "type" "multi")]) ;; Prepare to return any type including a structure value. --- 4898,4936 ---- (define_expand "untyped_call" ! [(parallel [(call (match_operand 0 "" "") (const_int 0)) ! (match_operand 1 "" "") ! (match_operand 2 "" "")])] "" " { ! int i; ! /* Pass constm1 to indicate that it may expect a structure value, but ! we don't know what size it is. */ ! emit_call_insn (gen_call (operands[0], const0_rtx, NULL, constm1_rtx)); ! for (i = 0; i < XVECLEN (operands[2], 0); i++) ! { ! rtx set = XVECEXP (operands[2], 0, i); ! emit_move_insn (SET_DEST (set), SET_SRC (set)); ! } ! /* The optimizer does not know that the call sets the function value ! registers we stored in the result block. We avoid problems by ! claiming that all hard registers are used and clobbered at this ! point. */ ! emit_insn (gen_blockage ()); ! DONE; ! }") ! ;; UNSPEC_VOLATILE is considered to use and clobber all hard registers and ! ;; all of memory. This blocks insns from being moved across this point. ! (define_insn "blockage" ! [(unspec_volatile [(const_int 0)] 0)] ! "" ! "") ;; Prepare to return any type including a structure value. *************** *** 5011,5015 **** " { ! /* Trap instruction to flush all the registers window. */ emit_insn (gen_flush_register_windows ()); /* Load the fp value for the containing fn into %fp. --- 5023,5027 ---- " { ! /* Trap instruction to flush all the register windows. */ emit_insn (gen_flush_register_windows ()); /* Load the fp value for the containing fn into %fp. *************** *** 5043,5047 **** ;; Special trap insn to flush register windows. (define_insn "flush_register_windows" ! [(unspec_volatile [(const_int 0)] 0)] "" "* return TARGET_V9 ? \"flushw\" : \"ta 3\";" --- 5055,5059 ---- ;; Special trap insn to flush register windows. (define_insn "flush_register_windows" ! [(unspec_volatile [(const_int 0)] 1)] "" "* return TARGET_V9 ? \"flushw\" : \"ta 3\";" *************** *** 5049,5053 **** (define_insn "goto_handler_and_restore" ! [(unspec_volatile [(const_int 0)] 1)] "" "jmp %%o0+0\;restore" --- 5061,5065 ---- (define_insn "goto_handler_and_restore" ! [(unspec_volatile [(const_int 0)] 2)] "" "jmp %%o0+0\;restore" *************** *** 5058,5062 **** (define_insn "flush" ! [(unspec_volatile [(match_operand 0 "" "")] 2)] "" "* return TARGET_V9 ? \"flush %a0\" : \"iflush %a0\";" --- 5070,5074 ---- (define_insn "flush" ! [(unspec_volatile [(match_operand 0 "" "")] 3)] "" "* return TARGET_V9 ? \"flush %a0\" : \"iflush %a0\";" *************** *** 5479,5483 **** (lo_sum:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "i"))) ! (set (match_operand:DF 2 "register_operand" "=fr") (mem:DF (match_dup 0)))] "RTX_UNCHANGING_P (operands[1]) && reg_unused_after (operands[0], insn)" --- 5491,5495 ---- (lo_sum:SI (match_dup 0) (match_operand:SI 1 "immediate_operand" "i"))) ! (set (match_operand:DF 2 "register_operand" "=er") (mem:DF (match_dup 0)))] "RTX_UNCHANGING_P (operands[1]) && reg_unused_after (operands[0], insn)" *************** *** 5623,5627 **** (define_peephole [(parallel [(set (match_operand 0 "" "") ! (call (mem:SI (match_operand:SI 1 "call_operand_address" "pi")) (match_operand 2 "" ""))) (clobber (reg:SI 15))]) --- 5635,5639 ---- (define_peephole [(parallel [(set (match_operand 0 "" "") ! (call (mem:SI (match_operand:SI 1 "call_operand_address" "ps")) (match_operand 2 "" ""))) (clobber (reg:SI 15))]) *************** *** 5634,5638 **** (define_peephole ! [(parallel [(call (mem:SI (match_operand:SI 0 "call_operand_address" "pi")) (match_operand 1 "" "")) (clobber (reg:SI 15))]) --- 5646,5650 ---- (define_peephole ! [(parallel [(call (mem:SI (match_operand:SI 0 "call_operand_address" "ps")) (match_operand 1 "" "")) (clobber (reg:SI 15))]) *************** *** 5646,5650 **** (define_peephole [(parallel [(set (match_operand 0 "" "") ! (call (mem:SI (match_operand:DI 1 "call_operand_address" "pi")) (match_operand 2 "" ""))) (clobber (reg:DI 15))]) --- 5658,5662 ---- (define_peephole [(parallel [(set (match_operand 0 "" "") ! (call (mem:SI (match_operand:DI 1 "call_operand_address" "ps")) (match_operand 2 "" ""))) (clobber (reg:DI 15))]) *************** *** 5657,5661 **** (define_peephole ! [(parallel [(call (mem:SI (match_operand:DI 0 "call_operand_address" "pi")) (match_operand 1 "" "")) (clobber (reg:DI 15))]) --- 5669,5673 ---- (define_peephole ! [(parallel [(call (mem:SI (match_operand:DI 0 "call_operand_address" "ps")) (match_operand 1 "" "")) (clobber (reg:DI 15))]) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/sysv4.h gcc-2.6.1/config/sparc/sysv4.h *** gcc-2.6.0/config/sparc/sysv4.h Tue Jul 12 13:11:11 1994 --- gcc-2.6.1/config/sparc/sysv4.h Fri Sep 2 14:23:46 1994 *************** *** 25,30 **** appropriate only for SunOS 4.x, and not for svr4. */ - #undef DBX_DEBUGGING_INFO #undef WORD_SWITCH_TAKES_ARG #undef SELECT_SECTION #undef ASM_DECLARE_FUNCTION_NAME --- 25,30 ---- appropriate only for SunOS 4.x, and not for svr4. */ #undef WORD_SWITCH_TAKES_ARG + #undef ASM_OUTPUT_SOURCE_LINE #undef SELECT_SECTION #undef ASM_DECLARE_FUNCTION_NAME *************** *** 180,184 **** #define ASM_OUTPUT_SECTION_NAME(FILE, NAME) \ ! fprintf (FILE, ".section\t\"%s\"\n", NAME) /* If the host and target formats match, output the floats as hex. */ --- 180,184 ---- #define ASM_OUTPUT_SECTION_NAME(FILE, NAME) \ ! fprintf (FILE, ".section\t\"%s\",#alloc\n", NAME) /* If the host and target formats match, output the floats as hex. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/t-sp64 gcc-2.6.1/config/sparc/t-sp64 *** gcc-2.6.0/config/sparc/t-sp64 Wed Jun 15 03:37:14 1994 --- gcc-2.6.1/config/sparc/t-sp64 Thu Jul 28 14:38:24 1994 *************** *** 1,3 **** LIBGCC1 = libgcc1.null CROSS_LIBGCC1 = libgcc1.null ! --- 1,3 ---- LIBGCC1 = libgcc1.null CROSS_LIBGCC1 = libgcc1.null ! LIBGCC2_CFLAGS = -O2 $(LIBGCC2_INCLUDES) $(GCC_CFLAGS) -g1 Only in gcc-2.6.0/config/sparc: t-sunos4 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/t-sunos40 gcc-2.6.1/config/sparc/t-sunos40 *** gcc-2.6.0/config/sparc/t-sunos40 --- gcc-2.6.1/config/sparc/t-sunos40 Sat Aug 13 17:11:04 1994 *************** *** 0 **** --- 1,6 ---- + # SunOS 4.0.* + # /bin/as doesn't recognize the v8 instructions, so we can't do a v8 + # multilib build. + + LIBGCC1 = libgcc1.null + CROSS_LIBGCC1 = libgcc1.null diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/sparc/t-sunos41 gcc-2.6.1/config/sparc/t-sunos41 *** gcc-2.6.0/config/sparc/t-sunos41 --- gcc-2.6.1/config/sparc/t-sunos41 Sat Aug 13 17:11:55 1994 *************** *** 0 **** --- 1,11 ---- + # SunOS 4.1.* + + LIBGCC1 = libgcc1.null + CROSS_LIBGCC1 = libgcc1.null + + MULTILIB_OPTIONS=mv8 + MULTILIB_DIRNAMES=v8 + MULTILIB_MATCHES= + + LIBGCC = stmp-multilib + INSTALL_LIBGCC = install-multilib diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/svr3.h gcc-2.6.1/config/svr3.h *** gcc-2.6.0/config/svr3.h Wed Mar 23 16:31:45 1994 --- gcc-2.6.1/config/svr3.h Fri Jul 29 14:59:09 1994 *************** *** 222,226 **** because they push on the stack. */ ! #ifdef STACK_GROWS_DOWNWARD /* Constructor list on stack is in reverse order. Go to the end of the --- 222,226 ---- because they push on the stack. */ ! #ifndef STACK_GROWS_DOWNWARD /* Constructor list on stack is in reverse order. Go to the end of the diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/svr4.h gcc-2.6.1/config/svr4.h *** gcc-2.6.0/config/svr4.h Wed Mar 23 16:56:06 1994 --- gcc-2.6.1/config/svr4.h Wed Sep 28 18:33:38 1994 *************** *** 245,248 **** --- 245,308 ---- #undef DBX_REGISTER_NUMBER + /* gas on SVR4 supports the use of .stabs. Permit -gstabs to be used + in general, although it will only work when using gas. */ + + #define DBX_DEBUGGING_INFO + + /* Use DWARF debugging info by default. */ + + #ifndef PREFERRED_DEBUGGING_TYPE + #define PREFERRED_DEBUGGING_TYPE DWARF_DEBUG + #endif + + /* Make LBRAC and RBRAC addresses relative to the start of the + function. The native Solaris stabs debugging format works this + way, gdb expects it, and it reduces the number of relocation + entries. */ + + #define DBX_BLOCKS_FUNCTION_RELATIVE 1 + + /* When using stabs, gcc2_compiled must be a stabs entry, not an + ordinary symbol, or gdb won't see it. Furthermore, since gdb reads + the input piecemeal, starting with each N_SO, it's a lot easier if + the gcc2 flag symbol is *after* the N_SO rather than before it. So + we emit an N_OPT stab there. */ + + #define ASM_IDENTIFY_GCC(FILE) \ + do \ + { \ + if (write_symbols != DBX_DEBUG) \ + fputs ("gcc2_compiled.:\n", FILE); \ + } \ + while (0) + + #define ASM_IDENTIFY_GCC_AFTER_SOURCE(FILE) \ + do \ + { \ + if (write_symbols == DBX_DEBUG) \ + fputs ("\t.stabs\t\"gcc2_compiled.\", 0x3c, 0, 0, 0\n", FILE); \ + } \ + while (0) + + /* Like block addresses, stabs line numbers are relative to the + current function. */ + + #define ASM_OUTPUT_SOURCE_LINE(file, line) \ + do \ + { \ + static int sym_lineno = 1; \ + fprintf (file, ".stabn 68,0,%d,.LM%d-%s\n.LM%d:\n", \ + line, sym_lineno, \ + XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0), \ + sym_lineno); \ + sym_lineno += 1; \ + } \ + while (0) + + /* In order for relative line numbers to work, we must output the + stabs entry for the function name first. */ + + #define DBX_FUNCTION_FIRST + /* Define the actual types of some ANSI-mandated types. (These definitions should work for most SVR4 systems). */ *************** *** 477,480 **** --- 537,546 ---- } + /* Switch into a generic section. + This is currently only used to support section attributes. */ + + #define ASM_OUTPUT_SECTION(FILE, NAME) \ + fprintf (FILE, ".section\t%s,\"a\",@progbits\n", NAME) + /* A C statement (sans semicolon) to output an element in the table of global constructors. */ *************** *** 654,661 **** sequences for many control characters, but we don't use \a to represent BEL because some svr4 assemblers (e.g. on ! the i386) don't know about that. */ #define ESCAPES \ ! "\1\1\1\1\1\1\1\1btnvfr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\ --- 720,728 ---- sequences for many control characters, but we don't use \a to represent BEL because some svr4 assemblers (e.g. on ! the i386) don't know about that. Also, we don't use \v ! since some versions of gas, such as 2.2 did not accept it. */ #define ESCAPES \ ! "\1\1\1\1\1\1\1\1btn\1fr\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\ \0\0\"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\ \0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\\\0\0\0\ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/vax/vax.c gcc-2.6.1/config/vax/vax.c *** gcc-2.6.0/config/vax/vax.c Wed Apr 20 12:15:06 1994 --- gcc-2.6.1/config/vax/vax.c Tue Nov 1 18:33:15 1994 *************** *** 29,33 **** #include "output.h" #include "insn-attr.h" ! /* This is like nonimmediate_operand with a restriction on the type of MEM. */ --- 29,35 ---- #include "output.h" #include "insn-attr.h" ! #ifdef VMS ! #include "tree.h" ! #endif /* This is like nonimmediate_operand with a restriction on the type of MEM. */ *************** *** 651,681 **** the program with an appropriate .comm or initialization. */ struct extern_list { struct extern_list *next; /* next external */ char *name; /* name of the external */ ! } *extern_head = 0; ! /* Return 1 if NAME has already had an external definition; ! 0 if it has not (so caller should output one). */ ! int ! vms_check_external (name) char *name; { ! register struct extern_list *p; for (p = extern_head; p; p = p->next) if (!strcmp (p->name, name)) ! return 1; p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list)); - p->next = extern_head; p->name = name; ! extern_head = p; ! return 0; } #ifdef VMS ! /* Additional support code for VMS. */ #ifdef QSORT_WORKAROUND --- 653,748 ---- the program with an appropriate .comm or initialization. */ + static struct extern_list { struct extern_list *next; /* next external */ char *name; /* name of the external */ ! int size; /* external's actual size */ ! int in_const; /* section type flag */ ! } *extern_head = 0, *pending_head = 0; ! /* Check whether NAME is already on the external definition list. If not, ! add it to either that list or the pending definition list. */ ! void ! vms_check_external (decl, name, pending) ! tree decl; char *name; + int pending; { ! register struct extern_list *p, *p0; for (p = extern_head; p; p = p->next) if (!strcmp (p->name, name)) ! return; + for (p = pending_head, p0 = 0; p; p0 = p, p = p->next) + if (!strcmp (p->name, name)) + { + if (pending) + return; + + /* Was pending, but may now be defined; move it to other list. */ + if (p == pending_head) + pending_head = 0; + else + p0->next = p->next; + p->next = extern_head; + extern_head = p; + return; + } + + /* Not previously seen; create a new list entry. */ p = (struct extern_list *)permalloc ((long) sizeof (struct extern_list)); p->name = name; ! ! if (pending) ! { ! /* Save the size and section type and link to `pending' list. */ ! p->size = (DECL_SIZE (decl) == 0) ? 0 : ! TREE_INT_CST_LOW (size_binop (CEIL_DIV_EXPR, DECL_SIZE (decl), ! size_int (BITS_PER_UNIT))); ! p->in_const = (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)); ! ! p->next = pending_head; ! pending_head = p; ! } ! else ! { ! /* Size and section type don't matter; link to `declared' list. */ ! p->size = p->in_const = 0; /* arbitrary init */ ! ! p->next = extern_head; ! extern_head = p; ! } ! return; ! } ! ! void ! vms_flush_pending_externals (file) ! FILE *file; ! { ! register struct extern_list *p; ! ! while (pending_head) ! { ! /* Move next pending declaration to the "done" list. */ ! p = pending_head; ! pending_head = p->next; ! p->next = extern_head; ! extern_head = p; ! ! /* Now output the actual declaration. */ ! if (p->in_const) ! const_section (); ! else ! data_section (); ! fputs (".comm ", file); ! assemble_name (file, p->name); ! fprintf (file, ",%d\n", p->size); ! } } #ifdef VMS ! /* Additional support code for VMS host. */ #ifdef QSORT_WORKAROUND *************** *** 686,690 **** is either not a multiple of 4 in size or not longword aligned. A static "move-by-longword" optimization flag inside qsort() is ! never reset. This is known of affect VMS V4.6 through VMS V5.5-1. In this work-around an insertion sort is used for simplicity. --- 753,758 ---- is either not a multiple of 4 in size or not longword aligned. A static "move-by-longword" optimization flag inside qsort() is ! never reset. This is known of affect VMS V4.6 through VMS V5.5-1, ! and was finally fixed in VMS V5.5-2. In this work-around an insertion sort is used for simplicity. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/vax/vax.md gcc-2.6.1/config/vax/vax.md *** gcc-2.6.0/config/vax/vax.md Fri Jun 24 18:29:39 1994 --- gcc-2.6.1/config/vax/vax.md Mon Aug 29 17:50:03 1994 *************** *** 1496,1499 **** --- 1496,1500 ---- || GET_CODE (operands[3]) != CONST_INT || (INTVAL (operands[2]) != 8 && INTVAL (operands[2]) != 16) + || INTVAL (operands[2]) + INTVAL (operands[3]) > 32 || side_effects_p (operands[1]) || (GET_CODE (operands[1]) == MEM *************** *** 1515,1518 **** --- 1516,1520 ---- if (GET_CODE (operands[0]) != REG || GET_CODE (operands[2]) != CONST_INT || GET_CODE (operands[3]) != CONST_INT + || INTVAL (operands[2]) + INTVAL (operands[3]) > 32 || side_effects_p (operands[1]) || (GET_CODE (operands[1]) == MEM diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/vax/vms.h gcc-2.6.1/config/vax/vms.h *** gcc-2.6.0/config/vax/vms.h Thu Jun 23 18:07:36 1994 --- gcc-2.6.1/config/vax/vms.h Mon Oct 31 08:06:34 1994 *************** *** 1,4 **** /* Output variables, constants and external declarations, for GNU compiler. ! Copyright (C) 1988 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Output variables, constants and external declarations, for GNU compiler. ! Copyright (C) 1988, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 141,145 **** assemble_name (FILE, NAME); \ fputs ("\n", FILE); \ ! vms_check_external (NAME); \ } while (0) --- 141,145 ---- assemble_name (FILE, NAME); \ fputs ("\n", FILE); \ ! vms_check_external (NULL_TREE, NAME, 0); \ } while (0) *************** *** 166,190 **** since the size of its definition was not likewise rounded up. */ #define ASM_OUTPUT_EXTERNAL(FILE,DECL,NAME) \ ! { if (DECL_INITIAL (DECL) == 0 && TREE_CODE (DECL) != FUNCTION_DECL \ ! && ! vms_check_external (NAME)) \ ! { \ ! if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl)) \ ! const_section (); \ ! else \ ! data_section (); \ ! fputs (".comm ", (FILE)); \ ! assemble_name ((FILE), (NAME)); \ ! if (DECL_SIZE (DECL) == 0) \ ! fprintf ((FILE), ",0\n"); \ ! else \ ! { \ ! tree size_tree; \ ! size_tree = size_binop (CEIL_DIV_EXPR, \ ! DECL_SIZE (DECL), size_int (BITS_PER_UNIT)); \ ! fprintf ((FILE), ",%d\n", TREE_INT_CST_LOW (size_tree)); \ ! } \ ! } \ } /* Here we redefine ASM_OUTPUT_COMMON to select the data_section or the --- 166,201 ---- since the size of its definition was not likewise rounded up. */ + /* Note: the original ASM_OUTPUT_EXTERNAL code has been moved into + vms_check_external and vms_flush_pending_externals. */ + #define ASM_OUTPUT_EXTERNAL(FILE,DECL,NAME) \ ! { if (DECL_INITIAL (DECL) == 0 && TREE_CODE (DECL) != FUNCTION_DECL) \ ! vms_check_external ((DECL), (NAME), 1); \ ! } ! ! /* ASM_OUTPUT_EXTERNAL will have wait until after an initializer is ! completed in order to switch sections for an external object, so ! use the DECLARE_OBJECT hooks to manage deferred declarations. */ ! ! /* This is the default action for ASM_DECLARE_OBJECT_NAME, but if it ! is explicitly defined, then ASM_FINISH_DECLARE_OBJECT will be used. */ ! ! #define ASM_DECLARE_OBJECT_NAME(ASM_OUT_FILE,NAME,DECL) \ ! { if (output_bytecode) \ ! BC_OUTPUT_LABEL ((ASM_OUT_FILE), (NAME)); \ ! else \ ! ASM_OUTPUT_LABEL ((ASM_OUT_FILE), (NAME)); \ } + + /* We don't need to do anything special to finish the current object, but it + should now be safe to output any deferred external global declarations. */ + + #define ASM_FINISH_DECLARE_OBJECT(FILE,DECL,TOPLVL,ATEND) \ + vms_flush_pending_externals(FILE) + + /* Anything still pending must be flushed at the very end. */ + + #define ASM_FILE_END(STREAM) \ + vms_flush_pending_externals(STREAM) /* Here we redefine ASM_OUTPUT_COMMON to select the data_section or the diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/we32k/we32k.h gcc-2.6.1/config/we32k/we32k.h *** gcc-2.6.0/config/we32k/we32k.h Mon Dec 13 19:09:24 1993 --- gcc-2.6.1/config/we32k/we32k.h Tue Oct 25 16:16:12 1994 *************** *** 1,4 **** /* Definitions of target machine for GNU compiler. AT&T we32000 version. ! Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. Contributed by John Wehle (john@feith1.uucp) --- 1,4 ---- /* Definitions of target machine for GNU compiler. AT&T we32000 version. ! Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc. Contributed by John Wehle (john@feith1.uucp) *************** *** 22,26 **** /* Names to predefine in the preprocessor for this target machine. */ ! #define CPP_PREDEFINES "-Dwe32000 -Du3b -Dunix -Asystem(unix) -Acpu(we32000) -Amachine(we32000)" /* Print subsidiary information on the compiler version in use. */ --- 22,26 ---- /* Names to predefine in the preprocessor for this target machine. */ ! #define CPP_PREDEFINES "-Dwe32000 -Du3b2 -Dunix -Asystem(unix) -Acpu(we32000) -Amachine(we32000)" /* Print subsidiary information on the compiler version in use. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/winnt/ld.c gcc-2.6.1/config/winnt/ld.c *** gcc-2.6.0/config/winnt/ld.c --- gcc-2.6.1/config/winnt/ld.c Wed Oct 26 18:05:16 1994 *************** *** 0 **** --- 1,260 ---- + /* Call Windows NT 3.x linker. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Douglas B. Rupp (drupp@cs.washington.edu). + + 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 + #include + #include + #include + #include + #include + + /* These can be set by command line arguments */ + char *linker_path = 0; + int verbose = 0; + + int link_arg_max = -1; + char **link_args = (char **) 0; + int link_arg_index = -1; + + char *search_dirs = "."; + + static int is_regular_file (char *name); + + static void + addarg (str) + char *str; + { + int i; + + if (++link_arg_index >= link_arg_max) + { + char **new_link_args + = (char **) calloc (link_arg_max + 1000, sizeof (char *)); + + for (i = 0; i <= link_arg_max; i++) + new_link_args [i] = link_args [i]; + + if (link_args) + free (link_args); + + link_arg_max += 1000; + link_args = new_link_args; + } + + link_args [link_arg_index] = str; + } + + static char * + locate_file (file_name, path_val) + char *file_name; + char *path_val; + { + char buf [1000]; + int file_len = strlen (file_name); + char *end_path = path_val + strlen (path_val); + char *ptr; + + /* Handle absolute pathnames */ + if (file_name [0] == '/' || file_name [0] == DIR_SEPARATOR + || isalpha (file_name [0]) && file_name [1] == ':') + { + strncpy (buf, file_name, sizeof buf); + buf[sizeof buf - 1] = '\0'; + if (is_regular_file (buf)) + return strdup (buf); + else + return 0; + } + + if (! path_val) + return 0; + + for (;;) + { + for (; *path_val == PATH_SEPARATOR ; path_val++) + ; + if (! *path_val) + return 0; + + for (ptr = buf; *path_val && *path_val != PATH_SEPARATOR; ) + *ptr++ = *path_val++; + + ptr--; + if (*ptr != '/' && *ptr != DIR_SEPARATOR) + *++ptr = DIR_SEPARATOR; + + strcpy (++ptr, file_name); + + if (is_regular_file (buf)) + return strdup (buf); + } + + return 0; + } + + static char * + expand_lib (name) + char *name; + { + char *lib, *lib_path; + + lib = malloc (strlen (name) + 6); + strcpy (lib, "lib"); + strcat (lib, name); + strcat (lib, ".a"); + lib_path = locate_file (lib, search_dirs); + if (!lib_path) + { + fprintf (stderr, "Couldn't locate library: %s\n", lib); + exit (1); + } + + return lib_path; + } + + static int + is_regular_file (name) + char *name; + { + int ret; + struct stat statbuf; + + ret = stat(name, &statbuf); + return !ret && S_ISREG (statbuf.st_mode); + } + + static void + process_args (p_argc, argv) + int *p_argc; + char *argv[]; + { + int i, j; + + for (i = 1; i < *p_argc; i++) + { + /* -v turns on verbose option here and is passed on to gcc */ + if (! strcmp (argv [i], "-v")) + verbose = 1; + } + } + + main (argc, argv) + int argc; + char *argv[]; + { + int i; + int done_an_ali = 0; + int file_name_index; + char *pathval = getenv ("PATH"); + char *spawn_args [5]; + char *tmppathval = malloc (strlen (pathval) + 3); + + strcpy (tmppathval, ".;"); + pathval = strcat (tmppathval, pathval); + + process_args (&argc , argv); + + linker_path = locate_file ("link32.exe", pathval); + if (!linker_path) + { + linker_path = locate_file ("link.exe", pathval); + if (!linker_path) + { + fprintf (stderr, "Couldn't locate link32 or link\n"); + exit (1); + } + } + + addarg (linker_path); + + for (i = 1; i < argc; i++) + { + int arg_len = strlen (argv [i]); + + if (!strcmp (argv [i], "-o")) + { + char *buff, *ptr; + int out_len; + + i++; + out_len = strlen (argv[i]) + 10; + buff = malloc (out_len); + strcpy (buff, "-out:"); + strcat (buff, argv[i]); + ptr = strstr (buff, ".exe"); + if (ptr == NULL || strlen (ptr) != 4) + strcat (buff, ".exe"); + addarg (buff); + addarg ("-debug:full -debugtype:coff"); + } + else if (arg_len > 2 && !strncmp (argv [i], "-L", 2)) + { + char *nbuff, *sdbuff; + int j, new_len, search_dirs_len; + + new_len = strlen (&argv[i][2]); + search_dirs_len = strlen (search_dirs); + + nbuff = malloc (new_len + 1); + strcpy (nbuff, &argv[i][2]); + + for (j = 0; j < new_len; j++) + if (nbuff[j] == '/') nbuff[j] = DIR_SEPARATOR; + + sdbuff = malloc (search_dirs_len + new_len + 1); + strcpy (sdbuff, search_dirs); + sdbuff[search_dirs_len] = PATH_SEPARATOR; + sdbuff[search_dirs_len+1] = 0; + strcat (sdbuff, nbuff); + + if (search_dirs) + free (search_dirs); + + search_dirs = sdbuff; + } + + else if (arg_len > 2 && !strncmp (argv [i], "-l", 2)) + addarg (expand_lib (&argv[i][2])); + else if (!strcmp (argv [i], "-v")) + ; + else + addarg (argv [i]); + } + + addarg (NULL); + + if (verbose) + { + int i; + + for (i = 0; i < link_arg_index; i++) + printf ("%s ", link_args [i]); + putchar ('\n'); + } + + if (spawnvp (P_WAIT, linker_path, (const char * const *)link_args) != 0) + { + fprintf (stderr, "Error executing %s\n", link_args[0]); + exit (1); + } + + exit (0); + } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/winnt/winnt.h gcc-2.6.1/config/winnt/winnt.h *** gcc-2.6.0/config/winnt/winnt.h --- gcc-2.6.1/config/winnt/winnt.h Fri Sep 30 17:21:01 1994 *************** *** 0 **** --- 1,66 ---- + /* winnt.h -- operating system specific defines to be used when + targeting GCC for Windows NT 3.x. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Douglas B. Rupp (drupp@cs.washington.edu). + + 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. + + To use this file, put in your tm.h file something like: + + #include "?????.h" + #include "svr4.h" + + followed by any really system-specific defines (or overrides of + defines) which you find that you need. For example, CPP_PREDEFINES + is defined here with only the defined -Dunix and -DSVR4. You should + probably override that in your target-specific ?????svr4.h file + with a set of defines that includes these, but also contains an + appropriate define for the type of hardware that you are targeting. */ + + #undef LIB_SPEC + #define LIB_SPEC "libc.lib kernel32.lib" + + #undef STARTFILE_SPEC + #define STARTFILE_SPEC "" + + #undef LINK_SPEC + #define LINK_SPEC "-align:0x1000 -subsystem:console -entry:mainCRTStartup \ + -stack:1000000,1000000" + + #undef STANDARD_EXEC_PREFIX + #define STANDARD_EXEC_PREFIX "" + + #undef STANDARD_STARTFILE_PREFIX + #define STANDARD_STARTFILE_PREFIX "" + + #undef TOOLDIR_BASE_PREFIX + #define TOOLDIR_BASE_PREFIX "" + + #ifdef STANDARD_INCLUDE_DIR + #undef STANDARD_INCLUDE_DIR + #endif + #define STANDARD_INCLUDE_DIR "" + + #undef LOCAL_INCLUDE_DIR + #define LOCAL_INCLUDE_DIR "" + + #undef INCLUDE_DEFAULTS + #define INCLUDE_DEFAULTS \ + { \ + { 0, 0, 0 } \ + } + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/winnt/xm-winnt.h gcc-2.6.1/config/winnt/xm-winnt.h *** gcc-2.6.0/config/winnt/xm-winnt.h --- gcc-2.6.1/config/winnt/xm-winnt.h Fri Sep 30 17:21:03 1994 *************** *** 0 **** --- 1,59 ---- + /* Configuration for GNU compiler + for processor running Windows NT 3.x. + Copyright (C) 1994 Free Software Foundation, Inc. + Contributed by Douglas B. Rupp (drupp@cs.washington.edu) + + 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 + #define USG + #define ONLY_INT_FIELDS + #define USE_PROTOTYPES 1 + #define bcmp(a,b,c) memcmp (a,b,c) + #define bcopy(a,b,c) memcpy (b,a,c) + #define bzero(a,b) memset (a,0,b) + #define index strchr + #define rindex strrchr + #define kill(a,b) raise(b) + + #define EXECUTABLE_SUFFIX ".exe" + #define PATH_SEPARATOR ';' + #define DIR_SEPARATOR '\\' + #define HAVE_PUTENV 1 + + #define S_IRUSR 0000400 + #define S_IWUSR 0000200 + #define S_IXUSR 0000100 + #define S_IRGRP 0000040 + #define S_IWGRP 0000020 + #define S_IXGRP 0000010 + #define S_IROTH 0000004 + #define S_IWOTH 0000002 + #define S_IXOTH 0000001 + #define S_IRWXU S_IRUSR | S_IWUSR | S_IXUSR + #define S_ISREG(m) (((m)&S_IFMT) == S_IFREG) + #define S_ISDIR(m) (((m)&S_IFMT) == S_IFDIR) + + #define access _access + #define close _close + #define dup _dup + #define mktemp _mktemp + #define open _open + #define read _read + #define write _write + #define chmod _chmod + #define setjmp _setjmp diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config/xm-gnu.h gcc-2.6.1/config/xm-gnu.h *** gcc-2.6.0/config/xm-gnu.h --- gcc-2.6.1/config/xm-gnu.h Fri Oct 7 19:08:19 1994 *************** *** 0 **** --- 1,30 ---- + /* Configuration for GNU C-compiler for hosts running GNU. + Copyright (C) 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. */ + + /* This file defines machine-independent things specific to a host + running GNU. This file should not be specified as $xm_file itself; + instead $xm_file should be CPU/xm-gnu.h, which should include both + CPU/xm-CPU.h and this file xm-gnu.h. */ + + /* GNU has strerror. */ + #define HAVE_STRERROR + + /* Get a definition of O_RDONLY; some of the GCC files don't include this + properly and will define it themselves to be zero. */ + #include diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config.guess gcc-2.6.1/config.guess *** gcc-2.6.0/config.guess Thu Jul 14 22:17:00 1994 --- gcc-2.6.1/config.guess Tue Nov 1 21:34:55 1994 *************** *** 1,4 **** #!/bin/sh ! # This script attempts to guess a canonical system name. # Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. # --- 1,4 ---- #!/bin/sh ! # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. # *************** *** 15,20 **** # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software ! # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ # # This script attempts to guess a canonical system name similar to --- 15,27 ---- # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software ! # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. ! # ! # As a special exception to the GNU General Public License, if you ! # distribute this file as part of a program that contains a ! # configuration script generated by Autoconf, you may include it under ! # the same distribution terms that you use for the rest of that program. + # Written by Per Bothner . + # The master version of this file is at the FSF in /home/gd/gnu/lib. # # This script attempts to guess a canonical system name similar to *************** *** 29,32 **** --- 36,45 ---- # + # This is needed to find uname on a Pyramid OSx when run in the BSD universe. + # (ghazi@noc.rutgers.edu 8/24/94.) + if (test -f /.attbin/uname) >/dev/null 2>&1 ; then + PATH=$PATH:/.attbin ; export PATH + fi + UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown *************** *** 39,53 **** case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in ! alpha:OSF1:1.*:*) # 1.2 uses "1.2" for uname -r. echo alpha-dec-osf${UNAME_RELEASE} exit 0 ;; - alpha:OSF1:V1.*:* | alpha:OSF1:V[2-9].*:*) - # 1.3 and later use "V1.3", etc. for uname -r. - echo alpha-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^V//'` - exit 0 ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit 0;; sun4*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` --- 52,73 ---- case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in ! alpha:OSF1:V*:*) ! # After 1.2, OSF1 uses "V1.3" for uname -r. ! echo alpha-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^V//'` ! exit 0 ;; ! alpha:OSF1:*:*) # 1.2 uses "1.2" for uname -r. echo alpha-dec-osf${UNAME_RELEASE} exit 0 ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} exit 0;; + Pyramid*:OSx*:*:*) + if test "`(/bin/universe) 2>/dev/null`" = att ; then + echo pyramid-pyramid-sysv3 + else + echo pyramid-pyramid-bsd + fi + exit 0 ;; sun4*:SunOS:5.*:*) echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/[^.]*//'` *************** *** 60,64 **** exit 0 ;; sun4*:SunOS:*:*) ! echo sparc-sun-sunos${UNAME_RELEASE} exit 0 ;; sun3*:SunOS:*:*) --- 80,85 ---- exit 0 ;; sun4*:SunOS:*:*) ! # Japanese Language versions have a version number like `4.1.3-JL'. ! echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'` exit 0 ;; sun3*:SunOS:*:*) *************** *** 74,77 **** --- 95,101 ---- echo mips-mips-riscos${UNAME_RELEASE} exit 0 ;; + m88k:CX/UX:7*:*) + echo m88k-harris-cxux7 + exit 0 ;; m88k:*:4*:R4*) echo m88k-motorola-sysv4 *************** *** 81,86 **** exit 0 ;; AViiON:dgux:*:*) ! echo m88k-dg-dgux${UNAME_RELEASE} exit 0 ;; M88*:*:R3*:*) # Delta 88k system running SVR3 --- 105,118 ---- exit 0 ;; AViiON:dgux:*:*) ! if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx \ ! -o ${TARGET_BINARY_INTERFACE}x = x ] ; then ! echo m88k-dg-dgux${UNAME_RELEASE} ! else ! echo m88k-dg-dguxbcs${UNAME_RELEASE} ! fi exit 0 ;; + M88*:DolphinOS:*:*) # DolphinOS (SVR3) + echo m88k-dolphin-sysv3 + exit 0 ;; M88*:*:R3*:*) # Delta 88k system running SVR3 *************** *** 101,104 **** --- 133,149 ---- *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then + sed 's/^ //' << EOF >dummy.c + #include + + main() + { + if (!__power_pc()) + exit(1); + puts("powerpc-ibm-aix3.2.5"); + exit(0); + } + EOF + ${CC-cc} dummy.c -o dummy && ./dummy && rm dummy.c dummy && exit 0 + rm -f dummy.c dummy echo rs6000-ibm-aix3.2.5 elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then *************** *** 108,111 **** --- 153,171 ---- fi exit 0 ;; + *:AIX:*:4) + if /usr/sbin/lsattr -EHl proc0 | grep POWER >/dev/null 2>&1; then + IBM_ARCH=rs6000 + else + IBM_ARCH=powerpc + fi + if grep bos410 /usr/include/stdio.h >/dev/null 2>&1; then + IBM_REV=4.1 + elif grep bos411 /usr/include/stdio.h >/dev/null 2>&1; then + IBM_REV=4.1.1 + else + IBM_REV=4.${UNAME_RELEASE} + fi + echo ${IBM_ARCH}-ibm-aix${IBM_REV} + exit 0 ;; *:AIX:*:*) echo rs6000-ibm-aix *************** *** 123,127 **** echo m68k-hp-bsd4.4 exit 0 ;; ! 9000/[3478]??:HP-UX:*:* | 9000/8?7:HP-UX:*:* ) case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; --- 183,187 ---- echo m68k-hp-bsd4.4 exit 0 ;; ! 9000/[3478]??:HP-UX:*:*) case "${UNAME_MACHINE}" in 9000/31? ) HP_ARCH=m68000 ;; *************** *** 130,138 **** 9000/8?? ) HP_ARCH=hppa1.0 ;; esac ! case ${UNAME_RELEASE} in ! *.B7.* ) HPUX_REV=7 ;; ! *.B8.* | *.08.* ) HPUX_REV=8 ;; ! *.09.* ) HPUX_REV=9 ;; ! esac echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit 0 ;; --- 190,194 ---- 9000/8?? ) HP_ARCH=hppa1.0 ;; esac ! HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/[^.]*.[0B]*//'` echo ${HP_ARCH}-hp-hpux${HPUX_REV} exit 0 ;; *************** *** 144,150 **** { long cpu = sysconf (_SC_CPU_VERSION); ! if (CPU_IS_HP_MC68K (cpu)) ! puts ("m68k-hitachi-hiuxwe2"); ! else if (CPU_IS_PA_RISC (cpu)) { switch (cpu) --- 200,207 ---- { long cpu = sysconf (_SC_CPU_VERSION); ! /* The order matters, because CPU_IS_HP_MC68K erroneously returns ! true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct ! results, however. */ ! if (CPU_IS_PA_RISC (cpu)) { switch (cpu) *************** *** 156,159 **** --- 213,218 ---- } } + else if (CPU_IS_HP_MC68K (cpu)) + puts ("m68k-hitachi-hiuxwe2"); else puts ("unknown-hitachi-hiuxwe2"); exit (0); *************** *** 170,179 **** echo hppa1.0-hp-bsd exit 0 ;; ! C1*:ConvexOS:*:* | convex:ConvexOS:C1:*) echo c1-convex-bsd exit 0 ;; ! C2*:ConvexOS:*:* | convex:ConvexOS:C2:*) ! echo c2-convex-bsd exit 0 ;; CRAY*X-MP:UNICOS:*:*) echo xmp-cray-unicos --- 229,256 ---- echo hppa1.0-hp-bsd exit 0 ;; ! hp7??:OSF1:*:* | hp8?7:OSF1:*:* ) ! echo hppa1.1-hp-osf ! exit 0 ;; ! hp8??:OSF1:*:*) ! echo hppa1.0-hp-osf ! exit 0 ;; ! C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd exit 0 ;; ! C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) ! if getsysinfo -f scalar_acc ! then echo c32-convex-bsd ! else echo c2-convex-bsd ! fi ! exit 0 ;; ! C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) ! echo c34-convex-bsd ! exit 0 ;; ! C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) ! echo c38-convex-bsd exit 0 ;; + C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) + echo c4-convex-bsd + exit 0 ;; CRAY*X-MP:UNICOS:*:*) echo xmp-cray-unicos *************** *** 191,204 **** echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit 0 ;; ! i[34]86:FreeBSD:*:*) ! echo ${UNAME_MACHINE}-unknown-freebsd exit 0 ;; ! i[34]86:NetBSD:*:*) ! echo ${UNAME_MACHINE}-unknown-netbsd${UNAME_RELEASE} exit 0 ;; ! i[34]86:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux exit 0 ;; ! i[34]86:UNIX_SV:4.*:* | i[34]86:SYSTEM_V:4.*:*) if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE} --- 268,289 ---- echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE} exit 0 ;; ! *:FreeBSD:*:*) ! echo ${UNAME_MACHINE}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` ! exit 0 ;; ! *:NetBSD:*:*) ! echo ${UNAME_MACHINE}-unknown-netbsd`echo ${UNAME_RELEASE}|sed -e 's/[-_].*/\./'` exit 0 ;; ! *:GNU:*:*) ! echo `echo ${UNAME_MACHINE}|sed -e 's,/.*$,,'`-unknown-gnu`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'` exit 0 ;; ! *:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux exit 0 ;; ! # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. earlier versions ! # are messed up and put the nodename in both sysname and nodename. ! i[34]86:DYNIX/ptx:4*:*) ! echo i386-sequent-sysv4 ! exit 0 ;; ! i[34]86:*:4.*:* | i[34]86:SYSTEM_V:4.*:*) if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then echo ${UNAME_MACHINE}-univel-sysv${UNAME_RELEASE} *************** *** 212,215 **** --- 297,303 ---- (/bin/uname -X|egrep i80486 >/dev/null) && UNAME_MACHINE=i486 echo ${UNAME_MACHINE}-unknown-sco$UNAME_REL + elif test -f /usr/options/cb.name; then + UNAME_REL=`sed -n 's/.*Version //p' /dev/null 2>&1 ; then + echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4 + else # Add other i860-SVR4 vendors below as they are discovered. + echo i860-unknown-sysv${UNAME_RELEASE} # Unknown i860-SVR4 + fi + exit 0 ;; mini*:CTIX:SYS*5:*) # "miniframe" *************** *** 222,231 **** M680[234]0:*:R3V[567]*:*) test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; ! 3[34]??:*:4.0:* | 3[34]??,3[34]??:*:4.0:*) ! uname -p 2>/dev/null | grep 86 >/dev/null \ ! && echo i486-ncr-sysv4 && exit 0 ;; m680[234]0:LynxOS:2.2*:*) echo m68k-lynx-lynxos${UNAME_RELEASE} exit 0 ;; i[34]86:LynxOS:2.2*:*) echo i386-lynx-lynxos${UNAME_RELEASE} --- 320,335 ---- M680[234]0:*:R3V[567]*:*) test -r /sysV68 && echo 'm68k-motorola-sysv' && exit 0 ;; ! 3[34]??:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0) ! uname -p 2>/dev/null | grep 86 >/dev/null \ ! && echo i486-ncr-sysv4.3 && exit 0 ;; ! 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) ! uname -p 2>/dev/null | grep 86 >/dev/null \ ! && echo i486-ncr-sysv4 && exit 0 ;; m680[234]0:LynxOS:2.2*:*) echo m68k-lynx-lynxos${UNAME_RELEASE} exit 0 ;; + mc68030:UNIX_System_V:4.*:*) + echo m68k-atari-sysv4 + exit 0 ;; i[34]86:LynxOS:2.2*:*) echo i386-lynx-lynxos${UNAME_RELEASE} *************** *** 234,237 **** --- 338,355 ---- echo sparc-lynx-lynxos${UNAME_RELEASE} exit 0 ;; + rs6000:LynxOS:2.2*:*) + echo rs6000-lynx-lynxos${UNAME_RELEASE} + exit 0 ;; + RM*:SINIX-*:*:*) + echo mips-sni-sysv4 + exit 0 ;; + *:SINIX-*:*:*) + if uname -p 2>/dev/null >/dev/null ; then + UNAME_MACHINE=`(uname -p) 2>/dev/null` + echo ${UNAME_MACHINE}-sni-sysv4 + else + echo ns32k-sni-sysv + fi + exit 0 ;; esac *************** *** 240,244 **** cat >dummy.c <dummy.c </dev/null`; ! if (version==2) ! { ! printf("%s-next-ns2\n", __ARCHITECTURE__); ! exit(0); ! } ! else ! { ! printf("%s-next-ns3\n", __ARCHITECTURE__); ! exit(0); ! } #endif --- 384,389 ---- int version; version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; ! printf ("%s-next-nextstep%s\n", __ARCHITECTURE__, version==2 ? "2" : "3"); ! exit (0); #endif *************** *** 280,289 **** #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) ! printf("ns32k-encore-sysv\n"); exit(0); #else #if defined (CMU) ! printf("ns32k-encore-mach\n"); exit(0); #else ! printf("ns32k-encore-bsd\n"); exit(0); #endif #endif --- 390,399 ---- #if defined (MULTIMAX) || defined (n16) #if defined (UMAXV) ! printf ("ns32k-encore-sysv\n"); exit (0); #else #if defined (CMU) ! printf ("ns32k-encore-mach\n"); exit (0); #else ! printf ("ns32k-encore-bsd\n"); exit (0); #endif #endif *************** *** 290,316 **** #endif ! #if defined(__386BSD__) || (defined(__bsdi__) && defined(__i386__)) ! printf("i386-unknown-bsd\n"); exit(0); #endif ! #if defined(sequent) ! #if defined(i386) ! printf("i386-sequent-dynix\n"); exit(0); #endif #if defined (ns32000) ! printf("ns32k-sequent-dynix\n"); exit(0); #endif #endif ! #if defined(_SEQUENT_) ! printf("i386-sequent-ptx\n"); exit(0); #endif ! #if defined(vax) ! #if !defined(ultrix) ! printf("vax-dec-bsd\n"); exit(0); #else ! printf("vax-dec-ultrix\n"); exit(0); #endif #endif --- 400,430 ---- #endif ! #if defined (__386BSD__) ! printf ("i386-unknown-bsd\n"); exit (0); #endif ! #if defined (sequent) ! #if defined (i386) ! printf ("i386-sequent-dynix\n"); exit (0); #endif #if defined (ns32000) ! printf ("ns32k-sequent-dynix\n"); exit (0); #endif #endif ! #if defined (_SEQUENT_) ! printf ("i386-sequent-ptx\n"); exit (0); #endif ! #if defined (vax) ! #if !defined (ultrix) ! printf ("vax-dec-bsd\n"); exit (0); #else ! printf ("vax-dec-ultrix\n"); exit (0); ! #endif #endif + + #if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); #endif *************** *** 325,328 **** --- 439,468 ---- test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit 0; } + + # Convex versions that predate uname can use getsysinfo(1) + + if [ -x /usr/convex/getsysinfo ] + then + case `getsysinfo -f cpu_type` in + c1*) + echo c1-convex-bsd + exit 0 ;; + c2*) + if getsysinfo -f scalar_acc + then echo c32-convex-bsd + else echo c2-convex-bsd + fi + exit 0 ;; + c34*) + echo c34-convex-bsd + exit 0 ;; + c38*) + echo c38-convex-bsd + exit 0 ;; + c4*) + echo c4-convex-bsd + exit 0 ;; + esac + fi #echo '(Unable to guess system type)' 1>&2 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/config.sub gcc-2.6.1/config.sub *** gcc-2.6.0/config.sub Mon Jul 11 19:25:45 1994 --- gcc-2.6.1/config.sub Wed Oct 26 14:23:05 1994 *************** *** 5,24 **** # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. - #This file 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 of the License, or - #(at your option) any later version. - - #This program 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 this program; if not, write to the Free Software - #Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - - # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. --- 5,28 ---- # The presence of a machine in this file suggests that SOME GNU software # can handle that machine. It does not imply ALL GNU software can. + # + # This file 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 of the License, or + # (at your option) any later version. + # + # This program 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 this program; if not, write to the Free Software + # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + # As a special exception to the GNU General Public License, if you + # distribute this file as part of a program that contains a + # configuration script generated by Autoconf, you may include it under + # the same distribution terms that you use for the rest of that program. # Configuration subroutine to validate and canonicalize a configuration type. # Supply the specified configuration type as an argument. *************** *** 65,69 **** -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ ! -unicom* | -ibm* | -next* | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ --- 69,73 ---- -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ ! -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ *************** *** 104,107 **** --- 108,117 ---- os=-lynxos ;; + -ptx*) + basic_machine=`echo $1 | sed -e 's/86-.*/86-sequent/'` + ;; + -windowsnt*) + os=`echo $os | sed -e 's/windowsnt/winnt/'` + ;; esac *************** *** 110,117 **** # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. ! tahoe | i[34]86 | i860 | m68k | m68000 | m88k | ns32k | arm | pyramid \ | tron | a29k | 580 | i960 | h8300 | hppa1.0 | hppa1.1 \ | alpha | we32k | ns16k | clipper | sparclite | i370 | sh \ ! | powerpc | sparc64 | 1750a) basic_machine=$basic_machine-unknown ;; --- 120,128 ---- # Recognize the basic CPU types without company name. # Some are omitted here because they have special meanings below. ! tahoe | i[345]86 | i860 | m68k | m68000 | m88k | ns32k | arm | pyramid \ | tron | a29k | 580 | i960 | h8300 | hppa1.0 | hppa1.1 \ | alpha | we32k | ns16k | clipper | sparclite | i370 | sh \ ! | powerpc | sparc64 | 1750a | dsp16xx | mips64 | mipsel \ ! | pdp11 | mips64el | mips64orion | mips64orionel ) basic_machine=$basic_machine-unknown ;; *************** *** 122,126 **** ;; # Recognize the basic CPU types with company name. ! vax-* | tahoe-* | i[34]86-* | i860-* | m68k-* | m68000-* | m88k-* \ | sparc-* | ns32k-* | fx80-* | arm-* | c[123]* \ | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \ --- 133,137 ---- ;; # Recognize the basic CPU types with company name. ! vax-* | tahoe-* | i[345]86-* | i860-* | m68k-* | m68000-* | m88k-* \ | sparc-* | ns32k-* | fx80-* | arm-* | c[123]* \ | mips-* | pyramid-* | tron-* | a29k-* | romp-* | rs6000-* \ *************** *** 128,132 **** | hppa1.0-* | hppa1.1-* | alpha-* | we32k-* | cydra-* | ns16k-* \ | pn-* | np1-* | xps100-* | clipper-* | orion-* | sparclite-* \ ! | sh-* | powerpc-* | sparc64-*) ;; # Recognize the various machine names and aliases which stand --- 139,144 ---- | hppa1.0-* | hppa1.1-* | alpha-* | we32k-* | cydra-* | ns16k-* \ | pn-* | np1-* | xps100-* | clipper-* | orion-* | sparclite-* \ ! | pdp11-* | sh-* | powerpc-* | sparc64-* | mips64-* | mipsel-* \ ! | mips64el-* | mips64orion-* | mips64orionel-* ) ;; # Recognize the various machine names and aliases which stand *************** *** 152,156 **** os=-sysv ;; ! amiga) basic_machine=m68k-cbm ;; --- 164,168 ---- os=-sysv ;; ! amiga | amiga-*) basic_machine=m68k-cbm ;; *************** *** 171,178 **** os=-dynix ;; - m68k-ccur) - basic_machine=m68k-ccur - os=-rtu - ;; convex-c1) basic_machine=c1-convex --- 183,186 ---- *************** *** 206,210 **** basic_machine=m68k-crds ;; ! decstation | decstation-3100 | pmax | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; --- 214,221 ---- basic_machine=m68k-crds ;; ! da30 | da30-*) ! basic_machine=m68k-da30 ! ;; ! decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) basic_machine=mips-dec ;; *************** *** 258,261 **** --- 269,275 ---- os=-sysv3 ;; + hp300-*) + basic_machine=m68k-hp + ;; hp300bsd) basic_machine=m68k-hp *************** *** 283,299 **** ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? ! i[34]86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv32 ;; ! i[34]86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv4 ;; ! i[34]86v) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv ;; ! i[34]86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-solaris2 --- 297,313 ---- ;; # I'm not sure what "Sysv32" means. Should this be sysv3.2? ! i[345]86v32) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv32 ;; ! i[345]86v4*) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv4 ;; ! i[345]86v) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-sysv ;; ! i[345]86sol2) basic_machine=`echo $1 | sed -e 's/86.*/86-unknown/'` os=-solaris2 *************** *** 327,330 **** --- 341,350 ---- basic_machine=m68000-convergent ;; + mips3*-*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'` + ;; + mips3*) + basic_machine=`echo $basic_machine | sed -e 's/mips3/mips64/'`-unknown + ;; ncr3000) basic_machine=i486-ncr *************** *** 343,353 **** os=-newsos ;; ! next) basic_machine=m68k-next case $os in -ns2*) ;; *) ! os=-ns3 ;; esac --- 363,376 ---- os=-newsos ;; ! next | m*-next ) basic_machine=m68k-next case $os in + -nextstep* ) + ;; -ns2*) + os=-nextstep2 ;; *) ! os=-nextstep3 ;; esac *************** *** 382,388 **** basic_machine=m68k-tti ;; ! pc532) basic_machine=ns32k-pc532 ;; pn) basic_machine=pn-gould --- 405,416 ---- basic_machine=m68k-tti ;; ! pc532 | pc532-*) basic_machine=ns32k-pc532 ;; + pentium-*) + # We will change tis to say i586 once there has been + # time for various packages to start to recognize that. + basic_machine=i486-`echo $basic_machine | sed 's/^[^-]*-//'` + ;; pn) basic_machine=pn-gould *************** *** 394,397 **** --- 422,428 ---- basic_machine=romp-ibm ;; + sequent) + basic_machine=i386-sequent + ;; sh) basic_machine=sh-hitachi *************** *** 432,436 **** os=-sunos4 ;; ! sun3) basic_machine=m68k-sun ;; --- 463,467 ---- os=-sunos4 ;; ! sun3 | sun3-*) basic_machine=m68k-sun ;; *************** *** 494,497 **** --- 525,531 ---- basic_machine=vax-dec ;; + pdp11) + basic_machine=pdp11-dec + ;; we32k) basic_machine=we32k-att *************** *** 539,542 **** --- 573,579 ---- os=-solaris2 ;; + -gnu/linux*) + os=`echo $os | sed -e 's|gnu/linux|linux|'` + ;; # First accept the basic system types. # The portable systems comes first. *************** *** 544,548 **** # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ ! | -vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[34]* \ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ | -amigados* | -msdos* | -newsos* | -unicos* | -aos* \ --- 581,585 ---- # -sysv* is not here because it comes later, after sysvr4. -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ ! | -vms* | -sco* | -esix* | -isc* | -aix* | -sunos | -sunos[345]* \ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -solaris* | -sym* \ | -amigados* | -msdos* | -newsos* | -unicos* | -aos* \ *************** *** 550,554 **** | -riscos* | -linux* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -netbsd* | -freebsd* | -riscix* \ ! | -lynxos* | -bosx* | -ns* | -cxux* | -aout* | -elf*) ;; -sunos5*) --- 587,592 ---- | -riscos* | -linux* | -uniplus* | -iris* | -rtu* | -xenix* \ | -hiux* | -386bsd* | -netbsd* | -freebsd* | -riscix* \ ! | -lynxos* | -bosx* | -nextstep* | -cxux* | -aout* | -elf* \ ! | -ptx* | -coff* | -winnt*) ;; -sunos5*) *************** *** 622,625 **** --- 660,666 ---- os=-riscix1.2 ;; + pdp11-*) + os=-none + ;; *-dec | vax-*) os=-ultrix4.2 *************** *** 661,664 **** --- 702,708 ---- os=-sysv3 ;; + m68k-ccur) + os=-rtu + ;; m88k-omron*) os=-luna *************** *** 665,669 **** ;; *-sequent) ! os=-bsd ;; *-crds) --- 709,713 ---- ;; *-sequent) ! os=-ptx ;; *-crds) *************** *** 677,685 **** ;; *-next) ! os=-bsd ;; - i[34]86-*) - os=-sco3.2v2 - ;; *-gould) os=-sysv --- 721,726 ---- ;; *-next) ! os=-nextstep3 ;; *-gould) os=-sysv *************** *** 741,744 **** --- 782,788 ---- -mvs*) vendor=ibm + ;; + -ptx*) + vendor=sequent ;; esac diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/configure gcc-2.6.1/configure *** gcc-2.6.0/configure Mon Jul 11 19:25:53 1994 --- gcc-2.6.1/configure Thu Oct 27 13:15:04 1994 *************** *** 88,91 **** --- 88,93 ---- host= build= + name1= + name2= for arg in $*; *************** *** 126,139 **** *) case $arg in ! -srcdir | --srcdir | --srcdi | --srcd | --src | --sr | --s) next_arg=--srcdir ;; ! -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=* | --s=*) srcdir=`echo $arg | sed 's/-*s[a-z]*=//'` ;; ! -host | --host | --hos | --ho | --h) next_arg=--host ;; ! -host=* | --host=* | --hos=* | --ho=* | --h=*) host=`echo $arg | sed 's/-*h[a-z]*=//'` ;; --- 128,151 ---- *) case $arg in ! -*) ! if [ x$name1 != x ] ! then ! echo "Positional arguments must be last." 1>&2 ! exit 1 ! fi ! ;; ! esac ! ! case $arg in ! -srcdir | --srcdir | --srcdi | --srcd | --src | --sr) next_arg=--srcdir ;; ! -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*) srcdir=`echo $arg | sed 's/-*s[a-z]*=//'` ;; ! -host | --host | --hos | --ho) next_arg=--host ;; ! -host=* | --host=* | --hos=* | --ho=*) host=`echo $arg | sed 's/-*h[a-z]*=//'` ;; *************** *** 209,213 **** -enable-* | --enable-*) ;; #ignored -x | --x) ;; # ignored ! --verbose) ;; # ignored for now -*) echo "Invalid option \`$arg'" 1>&2 --- 221,231 ---- -enable-* | --enable-*) ;; #ignored -x | --x) ;; # ignored ! --he*) ;; # ignored for now (--help) ! --vers*) ;; # ignored for now (--version) ! --verb*) ;; # ignored for now (--verbose) ! --program-*) ;; #ignored (--program-prefix, --program-suffix) ! --c*) ;; #ignored (--cache-file) ! --q*) ;; #ignored (--quiet) ! --si*) ;; #ignored (--silent) -*) echo "Invalid option \`$arg'" 1>&2 *************** *** 215,224 **** ;; *) ! # Allow configure HOST TARGET ! if [ x$host = x ] then ! host=$target fi - target=$arg ;; esac --- 233,255 ---- ;; *) ! # Allow configure HOST TARGET. If just one name is given, it is used ! # as both unless a host was previously given, in which case it is ! # just the target. ! if [ x$name1 != x ] ! then ! if [ x$name2 != x ] ! then ! echo "More than two configuration names." 1>&2 ! exit 1 ! fi ! name2=$arg ! elif [ x$host != x ] then ! name1=$host ! name2=$arg ! host= ! else ! name1=$arg fi ;; esac *************** *** 226,229 **** --- 257,284 ---- done + if [ x$name1 != x ] + then + if [ x$name2 = x ] + then + name2=$name1 + fi + + if [ x$host != x ] + then + echo "Duplicate specification of host." 1>&2 + exit 1 + fi + + if [ x$target != x ] + then + echo "Duplicate specification of target." 1>&2 + exit 1 + fi + + host=$name1 + build=$name1 + target=$name2 + fi + # Find the source files, if location was not specified. if [ x$srcdir = x ] *************** *** 255,264 **** # Complain if an arg is missing ! if [ x$target = x ] then # This way of testing the result of a command substitution is # defined by Posix.2 (section 3.9.1) as well as traditional shells. ! if target=`${srcdir}/config.guess` ; then ! echo "Configuring for a ${target} host." 1>&2 else echo 'Config.guess failed to determine the host type. You need to specify one.' 1>&2 --- 310,333 ---- # Complain if an arg is missing ! if [ x$build = x ] then + # If host was specified, always use it for build also to avoid + # confusion. If someone wants a cross compiler where build != host, + # then they must specify build explicitly. Since this case is + # extremely rare, it does not matter that it is slightly inconvenient. + if [ x$host != x ] + then + build=$host + # This way of testing the result of a command substitution is # defined by Posix.2 (section 3.9.1) as well as traditional shells. ! elif build=`${srcdir}/config.guess` ! then ! echo "This appears to be a ${build} system." 1>&2 ! ! elif [ x$target != x ] ! then ! echo 'Config.guess failed to determine the host type. Defaulting to target.' ! build=$target else echo 'Config.guess failed to determine the host type. You need to specify one.' 1>&2 *************** *** 276,288 **** fi ! # Default other arg if [ x$host = x ] then ! host=$target fi ! # If $build was not specified, use $host. ! if [ x$build = x ] then ! build=$host fi --- 345,358 ---- fi ! # If $host was not specified, use $build. if [ x$host = x ] then ! host=$build fi ! ! # If $target was not specified, use $host. ! if [ x$target = x ] then ! target=$host fi *************** *** 314,317 **** --- 384,388 ---- extra_passes= extra_parts= + extra_programs= extra_objs= # Set this to force installation and use of collect2. *************** *** 407,410 **** --- 478,483 ---- tm_file=arm/riscix.h fi + xmake_file=arm/x-riscix + tmake_file=arm/t-riscix use_collect2=yes ;; *************** *** 415,418 **** --- 488,492 ---- tm_file=convex/convex1.h use_collect2=yes + fixincludes=Makefile.in ;; c2-convex-*) # Convex C2 *************** *** 420,423 **** --- 494,498 ---- tm_file=convex/convex2.h use_collect2=yes + fixincludes=Makefile.in ;; c32-convex-*) *************** *** 425,428 **** --- 500,504 ---- tm_file=convex/convex32.h # Convex C32xx use_collect2=yes + fixincludes=Makefile.in ;; c34-convex-*) *************** *** 430,433 **** --- 506,510 ---- tm_file=convex/convex34.h # Convex C34xx use_collect2=yes + fixincludes=Makefile.in ;; c38-convex-*) *************** *** 435,438 **** --- 512,516 ---- tm_file=convex/convex38.h # Convex C38xx use_collect2=yes + fixincludes=Makefile.in ;; clipper-intergraph-clix*) *************** *** 446,449 **** --- 524,529 ---- install_headers_dir=install-headers-cpio ;; + dsp16xx-*) + ;; elxsi-elxsi-*) use_collect2=yes *************** *** 478,482 **** xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 558,562 ---- xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 493,497 **** xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 573,577 ---- xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 508,512 **** xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 588,592 ---- xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 523,527 **** xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 603,607 ---- xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 538,542 **** xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 618,622 ---- xm_file=pa/xm-pahpux.h xmake_file=pa/x-pa-hpux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 553,557 **** xm_file=pa/xm-pahiux.h xmake_file=pa/x-pa-hiux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 633,637 ---- xm_file=pa/xm-pahiux.h xmake_file=pa/x-pa-hiux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 568,572 **** xm_file=pa/xm-pahiux.h xmake_file=pa/x-pa-hiux ! tmake_file=t-libc-ok if [ x$gas = xyes ] then --- 648,652 ---- xm_file=pa/xm-pahiux.h xmake_file=pa/x-pa-hiux ! tmake_file=pa/t-pa-hpux if [ x$gas = xyes ] then *************** *** 585,589 **** out_file=i370/mvs370.c ;; ! i[34]86-ibm-aix*) # IBM PS/2 running AIX cpu_type=i386 if [ x$gas = xyes ] --- 665,669 ---- out_file=i370/mvs370.c ;; ! i[345]86-ibm-aix*) # IBM PS/2 running AIX cpu_type=i386 if [ x$gas = xyes ] *************** *** 599,603 **** broken_install=yes ;; ! i[34]86-*-bsd*) cpu_type=i386 tm_file=i386/386bsd.h --- 679,740 ---- broken_install=yes ;; ! i486-ncr-sysv4*) # NCR 3000 - i486 running system V.4 ! cpu_type=i386 ! xm_file=i386/xm-sysv4.h ! xmake_file=i386/x-ncr3000 ! tm_file=i386/sysv4.h ! tmake_file=t-svr4 ! ;; ! i[345]86-next-*) ! cpu_type=i386 ! tm_file=i386/next.h ! out_file=i386/next.c ! xm_file=i386/xm-next.h ! tmake_file=i386/t-next ! xmake_file=i386/x-next ! ;; ! i[345]86-sequent-bsd*) # 80386 from Sequent ! cpu_type=i386 ! use_collect2=yes ! if [ x$gas = xyes ] ! then ! tm_file=i386/seq-gas.h ! else ! tm_file=i386/sequent.h ! fi ! ;; ! i[345]86-sequent-ptx1*) ! cpu_type=i386 ! xm_file=i386/xm-sysv3.h ! xmake_file=i386/x-sysv3 ! tm_file=i386/seq-sysv3.h ! tmake_file=t-svr3 ! fixincludes=fixinc.ptx ! extra_parts="crtbegin.o crtend.o" ! install_headers_dir=install-headers-cpio ! broken_install=yes ! ;; ! i[345]86-sequent-ptx2* | i[345]86-sequent-sysv*) ! cpu_type=i386 ! xm_file=i386/xm-sysv3.h ! xmake_file=i386/x-sysv3 ! tm_file=i386/seq2-sysv3.h ! tmake_file=t-svr3 ! extra_parts="crtbegin.o crtend.o" ! fixincludes=fixinc.ptx ! install_headers_dir=install-headers-cpio ! broken_install=yes ! ;; ! i386-sun-sunos*) # Sun i386 roadrunner ! xm_file=i386/xm-sun.h ! tm_file=i386/sun.h ! use_collect2=yes ! ;; ! i[345]86-*-bsdi* | i[345]86-*-bsd386*) ! cpu_type=i386 ! tm_file=i386/bsd386.h ! # tmake_file=t-libc-ok ! ;; ! i[345]86-*-bsd*) cpu_type=i386 tm_file=i386/386bsd.h *************** *** 606,609 **** --- 743,753 ---- # use_collect2=yes ;; + i[345]86-*-freebsd*) + cpu_type=i386 + tm_file=i386/freebsd.h + # On FreeBSD, the headers are already ok. + fixincludes=Makefile.in + xmake_file=i386/x-freebsd + ;; i[345]86-*-netbsd*) cpu_type=i386 *************** *** 613,638 **** xmake_file=x-netbsd ;; ! i[34]86-*-freebsd*) cpu_type=i386 ! tm_file=i386/freebsd.h ! # On FreeBSD, the headers are already ok. fixincludes=Makefile.in - xmake_file=i386/x-freebsd - ;; - i[34]86-sequent-bsd*) # 80386 from Sequent - cpu_type=i386 - use_collect2=yes - if [ x$gas = xyes ] - then - tm_file=i386/seq-gas.h - else - tm_file=i386/sequent.h - fi ;; ! i[34]86-*-isc*) # 80386 running ISC system cpu_type=i386 xm_file=i386/xm-isc.h case $machine in ! i[34]86-*-isc3*) xmake_file=i386/x-isc3 ;; --- 757,776 ---- xmake_file=x-netbsd ;; ! i[345]86-*-gnu*) cpu_type=i386 ! xm_file=i386/xm-gnu.h ! tm_file=i386/gnu.h ! tmake_file=t-libc-ok ! # GNU tools are the only tools. ! gnu_ld=yes ! gas=yes ! # On GNU, the headers are already okay. fixincludes=Makefile.in ;; ! i[345]86-*-isc*) # 80386 running ISC system cpu_type=i386 xm_file=i386/xm-isc.h case $machine in ! i[345]86-*-isc[34]*) xmake_file=i386/x-isc3 ;; *************** *** 642,659 **** esac echo $xmake_file ! if [ x$gas = xyes ] then ! if [ x$stabs = xyes ] ! then ! tm_file=i386/iscdbx.h ! tmake_file=i386/t-svr3dbx ! else ! # iscgas.h, a nonexistent file, was used here. ! tm_file=i386/isccoff.h ! extra_parts="crtbegin.o crtend.o" ! fi else tm_file=i386/isccoff.h ! tmake_file=i386/t-isc fi install_headers_dir=install-headers-cpio --- 780,790 ---- esac echo $xmake_file ! if [ x$gas = xyes -a x$stabs = xyes ] then ! tm_file=i386/iscdbx.h ! tmake_file=i386/t-svr3dbx else tm_file=i386/isccoff.h ! extra_parts="crtbegin.o crtend.o" fi install_headers_dir=install-headers-cpio *************** *** 660,664 **** broken_install=yes ;; ! i[34]86-*-linux*) # Intel 80386's running Linux cpu_type=i386 xm_file=i386/xm-linux.h --- 791,795 ---- broken_install=yes ;; ! i[345]86-*-linux*) # Intel 80386's running Linux cpu_type=i386 xm_file=i386/xm-linux.h *************** *** 673,677 **** broken_install=yes ;; ! i[34]86-*-lynxos*) cpu_type=i386 if [ x$gas = xyes ] --- 804,808 ---- broken_install=yes ;; ! i[345]86-*-lynxos*) cpu_type=i386 if [ x$gas = xyes ] *************** *** 684,688 **** xmake_file=x-lynx ;; ! i[34]86-*-gnu* | i[34]86-*-mach*) cpu_type=i386 tm_file=i386/mach.h --- 815,819 ---- xmake_file=x-lynx ;; ! i[345]86-*-mach*) cpu_type=i386 tm_file=i386/mach.h *************** *** 690,704 **** use_collect2=yes ;; ! i[34]86-next-*) ! cpu_type=i386 ! tm_file=i386/next.h ! out_file=i386/next.c ! xm_file=i386/xm-next.h ! tmake_file=i386/t-next ! xmake_file=i386/x-next ! ;; ! i[34]86-*-osfrose*) # 386 using OSF/rose ! # The following line (and similar below) is not redundant since this can ! # be used for i486 or i386. cpu_type=i386 if [ x$elf = xyes ] --- 821,825 ---- use_collect2=yes ;; ! i[345]86-*-osfrose*) # 386 using OSF/rose cpu_type=i386 if [ x$elf = xyes ] *************** *** 714,718 **** extra_objs=halfpic.o ;; ! i[34]86-*-sco3.2v4*) # 80386 running SCO 3.2v4 system cpu_type=i386 xm_file=i386/xm-sco.h --- 835,839 ---- extra_objs=halfpic.o ;; ! i[345]86-*-sco3.2v4*) # 80386 running SCO 3.2v4 system cpu_type=i386 xm_file=i386/xm-sco.h *************** *** 730,734 **** fi ;; ! i[34]86-*-sco*) # 80386 running SCO system cpu_type=i386 xm_file=i386/xm-sco.h --- 851,855 ---- fi ;; ! i[345]86-*-sco*) # 80386 running SCO system cpu_type=i386 xm_file=i386/xm-sco.h *************** *** 742,750 **** else tm_file=i386/sco.h ! tmake_file=i386/t-sco fi truncate_target=yes ;; ! i[34]86-*-solaris2* | i[34]86-*-sunos5*) cpu_type=i386 xm_file=i386/xm-sysv4.h --- 863,871 ---- else tm_file=i386/sco.h ! extra_parts="crtbegin.o crtend.o" fi truncate_target=yes ;; ! i[345]86-*-solaris2* | i[345]86-*-sunos5*) cpu_type=i386 xm_file=i386/xm-sysv4.h *************** *** 756,788 **** broken_install=yes ;; ! i386-sun-sunos*) # Sun i386 roadrunner ! xm_file=i386/xm-sun.h ! tm_file=i386/sun.h ! use_collect2=yes ! ;; ! i486-ncr-sysv4*) # NCR 3000 - i486 running system V.4 ! cpu_type=i386 ! xm_file=i386/xm-sysv4.h ! xmake_file=i386/x-ncr3000 ! tm_file=i386/sysv4.h ! tmake_file=t-svr4 ! ;; ! i[34]86-*-sysv4*) # Intel 80386's running system V.4 cpu_type=i386 xm_file=i386/xm-sysv4.h ! tm_file=i386/sysv4.h tmake_file=t-svr4 xmake_file=x-svr4 ;; ! i[34]86-sequent-sysv* | i[34]86-sequent-ptx) ! cpu_type=i386 ! xm_file=i386/xm-sysv3.h ! xmake_file=i386/x-sysv3 ! tm_file=i386/seq-sysv3.h ! tmake_file=t-svr3 ! fixincludes=fixinc.svr4 ! broken_install=yes ! ;; ! i[34]86-*-sysv*) # Intel 80386's running system V cpu_type=i386 xm_file=i386/xm-sysv3.h --- 877,893 ---- broken_install=yes ;; ! i[345]86-*-sysv4*) # Intel 80386's running system V.4 cpu_type=i386 xm_file=i386/xm-sysv4.h ! if [ x$stabs = xyes ] ! then ! tm_file=i386/sysv4gdb.h ! else ! tm_file=i386/sysv4.h ! fi tmake_file=t-svr4 xmake_file=x-svr4 ;; ! i[345]86-*-sysv*) # Intel 80386's running system V cpu_type=i386 xm_file=i386/xm-sysv3.h *************** *** 796,804 **** else tm_file=i386/svr3gas.h ! tmake_file=t-svr3 fi else tm_file=i386/sysv3.h ! tmake_file=t-svr3 fi ;; --- 901,920 ---- else tm_file=i386/svr3gas.h ! extra_parts="crtbegin.o crtend.o" fi else tm_file=i386/sysv3.h ! extra_parts="crtbegin.o crtend.o" ! fi ! ;; ! i[345]86-*-winnt3*) ! cpu_type=i386 ! tm_file=i386/winnt.h ! out_file=i386/i386.c ! xm_file=i386/xm-winnt.h ! xmake_file=i386/x-winnt ! if [ x$gnu_ld != xyes ] ! then ! extra_programs=ld fi ;; *************** *** 834,838 **** xmake_file=i860/x-sysv3 tm_file=i860/sysv3.h ! tmake_file=t-svr3 ;; i860-*-sysv4*) --- 950,954 ---- xmake_file=i860/x-sysv3 tm_file=i860/sysv3.h ! extra_parts="crtbegin.o crtend.o" ;; i860-*-sysv4*) *************** *** 842,845 **** --- 958,966 ---- tmake_file=t-svr4 ;; + i960-*-coff*) + tmake_file=i960/t-960bare + tm_file=i960/i960-coff.h + use_collect2=yes + ;; i960-*-*) # Default i960 environment. use_collect2=yes *************** *** 905,908 **** --- 1026,1057 ---- header_files=math-68881.h ;; + m68k-altos-sysv*) # Altos 3068 + if [ x$gas = xyes ] + then + xm_file=m68k/xm-altos3068.h + tm_file=m68k/altos3068.h + else + echo "The Altos is supported only with the GNU assembler" 1>&2 + exit 1 + fi + header_files=math-68881.h + ;; + m68k-bull-sysv*) # Bull DPX/2 + if [ x$gas = xyes ] + then + if [ x$stabs = xyes ] + then + tm_file=m68k/dpx2cdbx.h + else + tm_file=m68k/dpx2g.h + fi + else + tm_file=m68k/dpx2.h + fi + xm_file=m68k/xm-m68kv.h + xmake_file=m68k/x-dpx2 + use_collect2=yes + header_files=math-68881.h + ;; m68k-atari-sysv4*) # Atari variant of V.4. tm_file=m68k/atari.h *************** *** 911,914 **** --- 1060,1108 ---- header_files=math-68881.h ;; + m68k-motorola-sysv*) + xm_file=m68k/xm-mot3300.h + xmake_file=m68k/x-alloca-c + if [ x$gas = xyes ] + then + tm_file=m68k/mot3300g.h + else + tm_file=m68k/mot3300.h + fi + use_collect2=yes + header_files=math-68881.h + ;; + m68k-ncr-sysv*) # NCR Tower 32 SVR3 + tm_file=m68k/tower-as.h + xm_file=m68k/xm-tower.h + xmake_file=m68k/x-tower + extra_parts="crtbegin.o crtend.o" + header_files=math-68881.h + ;; + m68k-plexus-sysv*) + tm_file=m68k/plexus.h + xm_file=m68k/xm-plexus.h + use_collect2=yes + header_files=math-68881.h + ;; + m68k-tti-*) + tm_file=m68k/pbb.h + xm_file=m68k/xm-m68kv.h + header_files=math-68881.h + ;; + m68k-crds-unos*) + xm_file=m68k/xm-crds.h + xmake_file=m68k/x-crds + tm_file=m68k/crds.h + broken_install=yes + use_collect2=yes + header_files=math-68881.h + ;; + m68k-cbm-sysv4*) # Commodore variant of V.4. + tm_file=m68k/amix.h + xm_file=m68k/xm-amix.h + xmake_file=m68k/x-amix + tmake_file=t-svr4 + header_files=math-68881.h + ;; m68k-ccur-rtu) tm_file=m68k/ccur-GAS.h *************** *** 929,939 **** header_files=math-68881.h ;; - m68k-*-netbsd*) - cpu_type=m68k - tm_file=m68k/netbsd-m68k.h - # On NetBSD, the headers are already okay. - fixincludes=Makefile.in - xmake_file=x-netbsd - ;; m68k-isi-bsd*) if [ x$nfp = xyes ] --- 1123,1126 ---- *************** *** 976,990 **** header_files=math-68881.h ;; - m68k-*-lynxos*) - if [ x$gas = xyes ] - then - tm_file=m68k/lynx.h - else - tm_file=m68k/lynx-ng.h - fi - xm_file=xm-lynx.h - xmake_file=x-lynx - header_files=math-68881.h - ;; m68k-sun-mach*) tm_file=m68k/sun3mach.h --- 1163,1166 ---- *************** *** 1012,1016 **** header_files=math-68881.h ;; ! m68k-next-ns2*) tm_file=m68k/next21.h out_file=m68k/next.c --- 1188,1192 ---- header_files=math-68881.h ;; ! m68k-next-nextstep2*) tm_file=m68k/next21.h out_file=m68k/next.c *************** *** 1021,1025 **** use_collect2=yes ;; ! m68k-next-ns3*) tm_file=m68k/next.h out_file=m68k/next.c --- 1197,1201 ---- use_collect2=yes ;; ! m68k-next-nextstep3*) tm_file=m68k/next.h out_file=m68k/next.c *************** *** 1049,1135 **** header_files=math-68881.h ;; ! m68k-*-sysv3*) # Motorola m68k's running system V.3 ! xm_file=m68k/xm-m68kv.h ! xmake_file=m68k/x-m68kv ! tmake_file=t-svr3 ! header_files=math-68881.h ! ;; ! m68k-cbm-sysv4*) # Commodore variant of V.4. ! tm_file=m68k/amix.h ! xm_file=m68k/xm-amix.h ! xmake_file=m68k/x-amix ! tmake_file=t-svr4 ! header_files=math-68881.h ! ;; ! m68k-*-sysv4*) # Motorola m68k's running system V.4 ! tm_file=m68k/m68kv4.h ! xm_file=m68k/xm-m68kv.h ! tmake_file=t-svr4 ! header_files=math-68881.h ! ;; ! m68k-altos-sysv*) # Altos 3068 ! if [ x$gas = xyes ] ! then ! xm_file=m68k/xm-altos3068.h ! tm_file=m68k/altos3068.h ! else ! echo "The Altos is supported only with the GNU assembler" 1>&2 ! exit 1 ! fi ! header_files=math-68881.h ! ;; ! m68k-bull-sysv*) # Bull DPX/2 ! if [ x$gas = xyes ] ! then ! if [ x$stabs = xyes ] ! then ! tm_file=m68k/dpx2cdbx.h ! else ! tm_file=m68k/dpx2g.h ! fi ! else ! tm_file=m68k/dpx2.h ! fi ! xm_file=m68k/xm-m68kv.h ! xmake_file=m68k/x-dpx2 ! use_collect2=yes ! header_files=math-68881.h ! ;; ! m68k-motorola-sysv*) ! xm_file=m68k/xm-mot3300.h ! xmake_file=m68k/x-alloca-c if [ x$gas = xyes ] then ! tm_file=m68k/mot3300g.h else ! tm_file=m68k/mot3300.h fi ! use_collect2=yes ! header_files=math-68881.h ! ;; ! m68k-ncr-sysv*) # NCR Tower 32 SVR3 ! tm_file=m68k/tower-as.h ! xm_file=m68k/xm-tower.h ! xmake_file=m68k/x-tower ! tmake_file=t-svr3 header_files=math-68881.h ;; ! m68k-plexus-sysv*) ! tm_file=m68k/plexus.h ! xm_file=m68k/xm-plexus.h ! use_collect2=yes ! header_files=math-68881.h ;; ! m68k-tti-*) ! tm_file=m68k/pbb.h xm_file=m68k/xm-m68kv.h header_files=math-68881.h ;; ! m68k-crds-unos*) ! xm_file=m68k/xm-crds.h ! xmake_file=m68k/x-crds ! tm_file=m68k/crds.h ! broken_install=yes ! use_collect2=yes header_files=math-68881.h ;; --- 1225,1256 ---- header_files=math-68881.h ;; ! m68k-*-lynxos*) if [ x$gas = xyes ] then ! tm_file=m68k/lynx.h else ! tm_file=m68k/lynx-ng.h fi ! xm_file=xm-lynx.h ! xmake_file=x-lynx header_files=math-68881.h ;; ! m68k-*-netbsd*) ! cpu_type=m68k ! tm_file=m68k/netbsd-m68k.h ! # On NetBSD, the headers are already okay. ! fixincludes=Makefile.in ! xmake_file=x-netbsd ;; ! m68k-*-sysv3*) # Motorola m68k's running system V.3 xm_file=m68k/xm-m68kv.h + xmake_file=m68k/x-m68kv + extra_parts="crtbegin.o crtend.o" header_files=math-68881.h ;; ! m68k-*-sysv4*) # Motorola m68k's running system V.4 ! tm_file=m68k/m68kv4.h ! xm_file=m68k/xm-m68kv.h ! tmake_file=t-svr4 header_files=math-68881.h ;; *************** *** 1155,1168 **** fixincludes=fixinc.dgux ;; - m88k-*-luna*) - tm_file=m88k/luna.h - extra_parts="crtbegin.o crtend.o" - if [ x$gas = xyes ] - then - tmake_file=m88k/t-luna-gas - else - tmake_file=m88k/t-luna - fi - ;; m88k-dolphin-sysv3*) tm_file=m88k/dolph.h --- 1276,1279 ---- *************** *** 1185,1188 **** --- 1296,1315 ---- fi ;; + m88k-mot*-sysv4*) + tm_file=m88k/mot-sysv4.h + extra_parts="crtbegin.o crtend.o" + xmake_file=m88k/x-sysv4 + tmake_file=m88k/t-sysv4 + ;; + m88k-*-luna*) + tm_file=m88k/luna.h + extra_parts="crtbegin.o crtend.o" + if [ x$gas = xyes ] + then + tmake_file=m88k/t-luna-gas + else + tmake_file=m88k/t-luna + fi + ;; m88k-*-sysv3*) tm_file=m88k/sysv3.h *************** *** 1195,1204 **** fi ;; - m88k-mot*-sysv4*) - tm_file=m88k/mot-sysv4.h - extra_parts="crtbegin.o crtend.o" - xmake_file=m88k/x-sysv4 - tmake_file=m88k/t-sysv4 - ;; m88k-*-sysv4*) tm_file=m88k/sysv4.h --- 1322,1325 ---- *************** *** 1288,1310 **** fi ;; - mips-*-ultrix*) # Decstation. - if [ x$stabs = xyes ]; then - tm_file=mips/ultrix-gdb.h - else - tm_file=mips/ultrix.h - fi - xmake_file=mips/x-ultrix - if [ x$gas = xyes ] - then - tmake_file=mips/t-mips-gas - else - tmake_file=mips/t-ultrix - extra_passes="mips-tfile mips-tdump" - fi - if [ x$gnu_ld != xyes ] - then - use_collect2=yes - fi - ;; mips-dec-osfrose*) # Decstation running OSF/1 reference port with OSF/rose. tm_file=mips/osfrose.h --- 1409,1412 ---- *************** *** 1409,1413 **** broken_install=yes ;; ! mips-*-riscos[56789]bsd* | mips-*-riscos[56789]-bsd*) if [ x$stabs = xyes ]; then # MIPS BSD 4.3, RISC-OS 5.0 tm_file=mips/bsd-5-gdb.h --- 1511,1534 ---- broken_install=yes ;; ! mips-*-ultrix*) # Decstation. ! if [ x$stabs = xyes ]; then ! tm_file=mips/ultrix-gdb.h ! else ! tm_file=mips/ultrix.h ! fi ! xmake_file=mips/x-ultrix ! if [ x$gas = xyes ] ! then ! tmake_file=mips/t-mips-gas ! else ! tmake_file=mips/t-ultrix ! extra_passes="mips-tfile mips-tdump" ! fi ! if [ x$gnu_ld != xyes ] ! then ! use_collect2=yes ! fi ! ;; ! mips-*-riscos[56789]bsd*) if [ x$stabs = xyes ]; then # MIPS BSD 4.3, RISC-OS 5.0 tm_file=mips/bsd-5-gdb.h *************** *** 1428,1433 **** broken_install=yes ;; ! mips-*-bsd* | mips-*-riscosbsd* | mips-*-riscos[1234]bsd* \ ! | mips-*-riscos-bsd* | mips-*-riscos[1234]-bsd*) if [ x$stabs = xyes ]; then # MIPS BSD 4.3, RISC-OS 4.0 tm_file=mips/bsd-4-gdb.h --- 1549,1553 ---- broken_install=yes ;; ! mips-*-bsd* | mips-*-riscosbsd* | mips-*-riscos[1234]bsd*) if [ x$stabs = xyes ]; then # MIPS BSD 4.3, RISC-OS 4.0 tm_file=mips/bsd-4-gdb.h *************** *** 1448,1452 **** broken_install=yes ;; ! mips-*-riscos[56789]sysv4* | mips-*-riscos[56789]-sysv4*) if [ x$stabs = xyes ]; then # MIPS System V.4., RISC-OS 5.0 tm_file=mips/svr4-5-gdb.h --- 1568,1572 ---- broken_install=yes ;; ! mips-*-riscos[56789]sysv4*) if [ x$stabs = xyes ]; then # MIPS System V.4., RISC-OS 5.0 tm_file=mips/svr4-5-gdb.h *************** *** 1469,1474 **** broken_install=yes ;; ! mips-*-sysv4* | mips-*-riscos[1234]sysv4* | mips-*-riscossysv4* \ ! | mips-*-riscos[1234]-sysv4* | mips-*-riscos-sysv4*) if [ x$stabs = xyes ]; then # MIPS System V.4. RISC-OS 4.0 tm_file=mips/svr4-4-gdb.h --- 1589,1593 ---- broken_install=yes ;; ! mips-*-sysv4* | mips-*-riscos[1234]sysv4* | mips-*-riscossysv4*) if [ x$stabs = xyes ]; then # MIPS System V.4. RISC-OS 4.0 tm_file=mips/svr4-4-gdb.h *************** *** 1491,1495 **** broken_install=yes ;; ! mips-*-riscos[56789]sysv* | mips-*-riscos[56788]-sysv*) if [ x$stabs = xyes ]; then # MIPS System V.3, RISC-OS 5.0 tm_file=mips/svr3-5-gdb.h --- 1610,1614 ---- broken_install=yes ;; ! mips-*-riscos[56789]sysv*) if [ x$stabs = xyes ]; then # MIPS System V.3, RISC-OS 5.0 tm_file=mips/svr3-5-gdb.h *************** *** 1512,1516 **** broken_install=yes ;; ! mips-*-sysv* | mips-*riscos*sysv*) if [ x$stabs = xyes ]; then # MIPS System V.3, RISC-OS 4.0 tm_file=mips/svr3-4-gdb.h --- 1631,1635 ---- broken_install=yes ;; ! mips-*-sysv* | mips-*-riscos*sysv*) if [ x$stabs = xyes ]; then # MIPS System V.3, RISC-OS 4.0 tm_file=mips/svr3-4-gdb.h *************** *** 1533,1537 **** broken_install=yes ;; ! mips-*riscos[56789]*) # Default MIPS RISC-OS 5.0. if [ x$stabs = xyes ]; then tm_file=mips/mips-5-gdb.h --- 1652,1656 ---- broken_install=yes ;; ! mips-*-riscos[56789]*) # Default MIPS RISC-OS 5.0. if [ x$stabs = xyes ]; then tm_file=mips/mips-5-gdb.h *************** *** 1633,1636 **** --- 1752,1760 ---- use_collect2=yes ;; + rs6000-ibm-aix4.1*) + tm_file=rs6000/aix41.h + xmake_file=rs6000/x-aix31 + use_collect2=yes + ;; rs6000-ibm-aix*) use_collect2=yes *************** *** 1652,1655 **** --- 1776,1785 ---- xm_file=sparc/xm-pbd.h ;; + sparc-*-netbsd) + tm_file=sparc/netbsd.h + # On NetBSD, the headers are already okay. + fixincludes=Makefile.in + xmake_file=x-netbsd + ;; sparc-*-bsd*) tm_file=sparc/bsd.h *************** *** 1674,1680 **** broken_install=yes ;; sparc-*-sunos4*) tm_file=sparc/sparc.h ! tmake_file=sparc/t-sunos4 use_collect2=yes ;; --- 1804,1815 ---- broken_install=yes ;; + sparc-*-sunos4.0*) + tm_file=sparc/sparc.h + tmake_file=sparc/t-sunos40 + use_collect2=yes + ;; sparc-*-sunos4*) tm_file=sparc/sparc.h ! tmake_file=sparc/t-sunos41 use_collect2=yes ;; *************** *** 1730,1733 **** --- 1865,1872 ---- tm_file=vax/vms.h ;; + pdp11-*-*) + xm_file=pdp11/xm-pdp11.h + tm_file=pdp11/pdp11.h + ;; we32k-att-sysv*) cpu_type=we32k *************** *** 1753,1760 **** esac ! # Distinguish i386 from i486. # Also, do not run mips-tfile on MIPS if using gas. case $machine in ! i486-*-*) target_cpu_default=2 ;; --- 1892,1900 ---- esac ! # Distinguish i386 from i486/i586. ! # ??? For the moment we treat i586 as an i486. # Also, do not run mips-tfile on MIPS if using gas. case $machine in ! i[45]86-*-*) target_cpu_default=2 ;; *************** *** 1887,1891 **** case $lang in ..) ;; ! "${srcdir}/*/config-lang.in") ;; *) subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;; esac --- 2027,2033 ---- case $lang in ..) ;; ! # The odd quoting in the next line is an attempt to work around ! # an apparent bug in bash 1.12 on linux. ! ${srcdir}'/*/config-lang.in') ;; *) subdirs="$subdirs `echo $lang | sed -e 's,^.*/\([^/]*\)/config-lang.in$,\1,'`" ;; esac *************** *** 2018,2021 **** --- 2160,2173 ---- fi + # Set EXTRA_PROGRAMS according to extra_programs. + if [ "x$extra_programs" = x ] + then true + else + rm -f Makefile.xx + sed "s/^EXTRA_PROGRAMS =/EXTRA_PROGRAMS = $extra_programs/" Makefile.tem > Makefile.xx + rm -f Makefile.tem + mv Makefile.xx Makefile.tem + fi + # Set EXTRA_OBJS according to extra_objs. # This substitutes for lots of t-* files. *************** *** 2110,2113 **** --- 2262,2266 ---- rm -f Makefile.xx Makefile.ll + touch Makefile.ll for s in .. $subdirs do *************** *** 2124,2128 **** exit 1 fi ! all_lang_makefiles="$all_lang_makefiles ${mainsrcdir}/$s/Make-lang.in" all_languages="$all_languages $language" all_compilers="$all_compilers $compilers" --- 2277,2281 ---- exit 1 fi ! all_lang_makefiles="$all_lang_makefiles ${mainsrcdir}/$s/Make-lang.in ${mainsrcdir}/$s/Makefile.in" all_languages="$all_languages $language" all_compilers="$all_compilers $compilers" *************** *** 2200,2204 **** # modified to solve the problem there. else ! for t in stage1 stage2 stage3 stage4 do rm -f $t --- 2353,2357 ---- # modified to solve the problem there. else ! for t in stage1 stage2 stage3 stage4 include do rm -f $t *************** *** 2230,2237 **** # Define macro CROSS_COMPILE in compilation if this is a cross-compiler. # Also use all.cross instead of all.internal, and add cross-make to Makefile. ! if [ x$host = x$target ] then rm -f Makefile ! if [ x$host = x$build ] then mv Makefile.tem Makefile --- 2383,2390 ---- # Define macro CROSS_COMPILE in compilation if this is a cross-compiler. # Also use all.cross instead of all.internal, and add cross-make to Makefile. ! if [ x$canon_host = x$canon_target ] then rm -f Makefile ! if [ x$canon_host = x$canon_build ] then mv Makefile.tem Makefile *************** *** 2240,2244 **** # few things. echo "build= $build" > Makefile ! sed -e "/####build/ r ${mainsrcdir}/build-make" Makefile.tem >> Makefile rm -f Makefile.tem Makefile.xx fi --- 2393,2398 ---- # few things. echo "build= $build" > Makefile ! sed -e "s|objc-runtime$||" \ ! -e "/####build/ r ${mainsrcdir}/build-make" Makefile.tem >> Makefile rm -f Makefile.tem Makefile.xx fi *************** *** 2287,2295 **** fi if [ x$canon_host = x$canon_target ] then ! echo "Links are now set up for target $canon_target." else ! echo "Links are now set up for host $canon_host and target $canon_target." fi --- 2441,2471 ---- fi + str2= + str3= + str4=. + if [ x$canon_host = x$canon_target ] then ! str1="native " else ! str1="cross-" ! str2=" from $canon_host" ! fi ! ! if [ x$canon_host != x$canon_build ] ! then ! str3=" on a $canon_build system" ! fi ! ! if [ "x$str2" != x ] || [ "x$str3" != x ] ! then ! str4= ! fi ! ! echo "Links are now set up to build a ${str1}compiler for ${canon_target}$str4" 1>&2 ! ! if [ "x$str2" != x ] || [ "x$str3" != x ] ! then ! echo " ${str2}${str3}." 1>&2 fi diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/configure.bat gcc-2.6.1/configure.bat *** gcc-2.6.0/configure.bat Sun Dec 12 06:11:55 1993 --- gcc-2.6.1/configure.bat Fri Jul 22 09:57:07 1994 *************** *** 1,54 **** ! @echo off ! echo Configuring GCC for go32 ! rem This batch file assumes a unix-type "sed" program ! ! update config\i386\xm-dos.h config.h ! update config\i386\xm-dos.h hconfig.h ! update config\i386\xm-dos.h tconfig.h ! update config\i386\go32.h tm.h ! update config\i386\i386.md md ! update config\i386\i386.c aux-output.c ! ! echo # Makefile generated by "configure.bat"> Makefile ! echo all.dos: cccp cc1 cc1plus cc1obj xgcc>> Makefile ! ! if exist config.sed del config.sed ! ! echo "/\.o[ ]*:/ s/config.status// ">> config.sed ! echo "/^target=/ c\ ">> config.sed ! echo "target=go32 ">> config.sed ! echo "/^version=/ c\ ">> config.sed ! sed -e "s/.*\"\([^ \"]*\)[ \"].*/version=\1/" version.c >> config.sed ! echo "s/CC = cc/CC = gcc/ ">> config.sed ! echo "s/:\$/: \$/g ">> config.sed ! echo "s/^ \ *\.\// go32 / ">> config.sed ! echo "s/<\ *\$(srcdir)\//< $(srcdir)\\/g ">> config.sed ! echo "s/^ \$(srcdir)\/move-if-change/ update/ ">> config.sed ! echo "s/^USE_/# USE_/ ">> config.sed ! echo "s/`echo \$(srcdir)\///g ">> config.sed ! echo "s/ | sed 's,\^\\\.\/,,'`//g ">> config.sed ! echo "s/^ cd \$(srcdir)[ ]*;/ / ">> config.sed ! ! echo "/^# USE_HOST_OBSTACK/ i\ ">> config.sed ! echo "USE_HOST_OBSTACK=obstack.o ">> config.sed ! ! echo "/^stamp-attrtab/,/update/ { ">> config.sed ! echo " /\\/d ">> config.sed ! echo " /fi/d ">> config.sed ! echo " /update/ i\ ">> config.sed ! echo " go32 genattrtab md > t-attrtab.c ">> config.sed ! echo "} ">> config.sed ! ! echo "/^enquire[ ]*:/ s/\$(GCC_PARTS)//g ">> config.sed ! echo "/^enquire.o[ ]*:/ s/\$(GCC_PASSES)//g ">> config.sed ! echo "/^GCC_FOR_TARGET =/ c\ ">> config.sed ! echo "GCC_FOR_TARGET = gcc ">> config.sed ! ! echo "s/; *@true// ">> config.sed ! echo "s/stamp-/s-/g ">> config.sed ! echo "s/tmp-/t-/g ">> config.sed ! ! sed -e "s/^\"//" -e "s/\"$//" -e "s/[ ]*$//" config.sed > config2.sed ! sed -f config2.sed Makefile.in >> Makefile ! del config.sed ! del config2.sed --- 1,2 ---- ! @echo off ! config\msdos\configure %1 %2 %3 %4 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/ChangeLog gcc-2.6.1/cp/ChangeLog *** gcc-2.6.0/cp/ChangeLog Wed Jul 13 07:51:52 1994 --- gcc-2.6.1/cp/ChangeLog Sat Oct 29 07:19:43 1994 *************** *** 1,17 **** Wed Jul 13 03:57:54 1994 Jason Merrill (jason@deneb.cygnus.com) ! * method.c (hack_identifier): Put back old code so lists of ! non-functions will be handled properly. ! * cp-tree.h (TYPE_NEEDS_CONSTRUCTING): #if 0 out; this macro is now ! defined in the language-independent tree.h. ! * tree.c (count_functions): Avoid bogus warning when compiling this ! function. Mon Jul 11 18:37:20 1994 Jason Merrill (jason@deneb.cygnus.com) ! * decl.c (grok_reference_init): Always save the initializer of a ! reference. Fri Jul 8 17:41:46 1994 Mike Stump (mrs@cygnus.com) --- 1,829 ---- + Sat Oct 29 07:18:52 1994 Richard Kenner (kenner@vlsi1.ultra.nyu.edu) + + * g++.c (main): Cast arg to bzero to avoid warning. + + Sun Oct 23 13:19:55 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * decl2.c: Declare flag_access_control. + (struct lang_f_options): Add access-control. + * expr.c (cplus_expand_expr, NEW_EXPR): Unset flag_access_control + for the call to expand_aggr_init to copy the object out of the + pcc_struct_return slot. + * search.c (compute_access): if (!flag_access_control) return + access_public. + + Fri Oct 21 00:32:54 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * decl.c (init_decl_processing): Use __pure_virtual for abort_fndecl + instead of abort, since the OSF/1 dynamic linker doesn't like to see + relocation entries for abort. + + * tree.c (array_type_nelts_total): Use sizetype, not + integer_type_node. + (array_type_nelts_top): Ditto. + + Mon Oct 17 18:03:15 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * decl.c (init_decl_processing): Make alloca a builtin. + + Mon Oct 17 15:56:11 1994 Mike Stump + + * except.c (expand_start_catch_block): Make sure the false label + gets onto the permanent obstack, as it is used for the exception + table. + + Fri Oct 14 18:54:48 1994 Mike Stump + + * class.c (modify_one_vtable): Since the DECL_CONTEXT of fndecl can + be set just below, use current_fndecl instead. + + Thu Oct 13 17:44:55 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * method.c (build_decl_overload): Set numeric_outputed_need_bar to 0. + + Wed Oct 12 13:27:57 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * lex.c (real_yylex): Use HOST_BITS_PER_WIDE_INT to determine the + bitmask for lexing character constants. + + * call.c (build_method_call): Disable code that tries to do tricky + stuff with a default parameter that is a constructor call, but + actually does other tricky stuff that breaks things. + + Wed Oct 12 16:14:01 1994 Benoit Belley + + * decl.c (finish_enum): Disable code which forces enums to be signed, + since this conflicts with their use as bitfields. type_promotes_to + handles promotion of enums of underlying unsigned types to signed + integer types. + + Wed Oct 12 13:24:03 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * cvt.c (type_promotes_to): Also promote enums to long if + appropriate. + + * typeck.c (default_conversion): Don't expect type_promotes_to to + return a main variant. + + Wed Oct 12 12:19:45 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * call.c (build_scoped_method_call): Don't lose side effects in the + object expression when calling a non-existent destructor. + + Fri Sep 2 19:05:21 1994 Rohan Lenard (rjl@iassf.easams.com.au) + + * call.c (build_scoped_method_call): Remove erroneous error message + when destructor call is written as a scoped call. + + Tue Oct 11 23:48:31 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * various: Cast pointer arguments to bzero and bcopy to char *. + + Tue Oct 11 19:34:32 1994 Mike Stump + + * class.c (get_derived_offset): Added a type parameter to limit how + far up the CLASSTYPE_VFIELD_PARENT chain we search. + * class.c (modify_one_vtable, fixup_vtable_deltas): When forming the + offset to put into the vtable for the this parameter, make sure we + don't offset from a parent of the DECL_CONTEXT of the function. + + Mon Oct 10 00:56:53 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * lex.c (cons_up_default_function): Mark methods in a template class + as template instances. Store the values of interface_unknown and + interface_only for do_pending_inlines. + (do_pending_inlines): Use them. + + Sun Oct 9 02:42:29 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * method.c (do_build_copy_constructor): Handle anonymous unions. + (do_build_assign_ref): Ditto. + (largest_union_member): Move from lex.c. + + Wed Oct 5 13:44:41 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * call.c (build_overload_call_real): Don't immediately do + array->pointer conversion. + + * pt.c (type_unification): If not passing to a reference, strip + cv-quals. Also handle array->pointer conversion. + + Tue Oct 4 17:45:37 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * decl.c (grokdeclarator): Don't warn about applying const to a + const typedef or template type parameter. + + Mon Oct 3 15:02:41 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * decl.c (shadow_tag): Remove obsolete code for pushing tags and + dealing with exceptions. + + Sun Oct 2 00:21:56 1994 Jason Merrill (jason@phydeaux.cygnus.com) + + * parse.y (expr_or_declarator): Add '(' expr_or_declarator ')' rule. + (direct_notype_declarator): Ditto. + (complex_direct_notype_declarator): Remove it here. + + Sat Oct 1 21:42:18 1994 Jason Merrill (jason@deneb.cygnus.com) + + * init.c (resolve_offset_ref): Fix types used in resolving .* + expressions. + + Thu Sep 29 16:15:36 1994 Michael I Bushnell + + * g++.c: Rework last change so it's done like collect.c (and + gcc.c). + + Wed Sep 28 19:19:01 1994 Brendan Kehoe (brendan@mole.gnu.ai.mit.edu) + + * except.c (register_exception_table): Use Pmode, not PTRmode. + + Wed Sep 14 10:17:27 1994 Michael I Bushnell + + * g++.c: Include in case `errno' is a macro + as permitted by ANSI C. + + Thu Sep 29 16:58:52 1994 Mike Stump + + * typeck.c (c_expand_return): Use magic so the backend can fixup the + assignment into the return register, so cleanups won't clobber it. + + Thu Sep 29 13:08:50 1994 Jason Merrill (jason@deneb.cygnus.com) + + * method.c (hack_identifier): Don't call assemble_external for + template decls. + + * decl.c (finish_decl): Also end temporary allocation if the decl in + question has a type of error_mark_node. + + Wed Sep 28 21:45:00 1994 Mike Stump (mrs@cygnus.com) + + * typeck.c (build_modify_expr): When optimizing ?: on lhs, make sure + that if the ?: was a reference type, that the subparts will be also. + + Wed Sep 28 16:14:04 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * except.c (register_exception_table): Use Pmode, not PTRmode. + + Fri Sep 23 13:54:27 1994 Jason Merrill (jason@deneb.cygnus.com) + + * lex.c (do_pending_inlines): Do method synthesis after the + pending_inlines have been reversed. + + Thu Sep 22 12:53:03 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * decl2.c (finish_file): Fix Brendan's fix: Only call + register_exception_table if there is a non-empty exception table. + + Thu Sep 22 12:03:46 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * decl2.c (finish_file): Only do register_exception_table if + -fhandle-exceptions is being used. + + Wed Sep 21 19:01:51 1994 Per Bothner (bothner@kalessin.cygnus.com) + + * except.c (output_exception_table_entry): Simplify + by using assemble_integer. + (build_exception_table): Change to return a count. + Cleanup to use standard macros, instead of hard-wired + sparc asm format. Don't make __EXCEPTION_TABLE__ global. + (register_exception_table): New function. Generate call to builtin. + * decl2.c (finish_file): Call register_exception_table. + * cp-tree.h (build_exception_table): Fix prototype. + + Wed Sep 21 13:20:42 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * tree.c (break_out_calls): Don't try to duplicate the DECL_INITIAL. + + * decl2.c (delete_sanity): Give an error at trying to delete a + function. + + Wed Sep 21 11:47:10 1994 Jason Merrill (jason@deneb.cygnus.com) + + * lex.c (cons_up_default_function): Mark synthesized destructors + inline. + + * decl.c (duplicate_decls): Ignore redeclarations of wchar_t as + something other than __wchar_t, complaining if -pedantic and not in + a system header. + + Tue Sep 20 09:43:28 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (xref_tag): Set up BINFO_INHERITANCE_CHAIN on base binfos + here. + + * typeck.c (build_modify_expr): Require complete type after checking + for error_mark_node. + + * call.c (build_method_call): Print parmtypes when complaining of + ambiguous call. + + * typeck.c (build_modify_expr): Handle assignment to array from + non-array. + + * decl.c (lookup_name_real): Deal with got_scope == error_mark_node. + + * call.c (build_method_call): Don't bother with the exact match. + + Mon Sep 19 00:51:39 1994 Jason Merrill (jason@deneb.cygnus.com) + + * init.c (expand_aggr_init): If we munge the type of the variable, + also munge the type of the initializer. + + * decl.c (grokdeclarator): Use <= when comparing to RID_LAST_MODIFIER. + (init_decl_processing): Push artificial declaration of wchar_t so + people don't have to declare it before they can use it. + + * error.c (cp_line_of): return lineno in lieu of 0. + + * typeck.c (convert_for_assignment): Handle conversion of pmfs to + int and bool. + (build_component_ref): Fold the COMPONENT_REF in case it can be + reduced. + + * typeck2.c (store_init_value): Don't pedwarn about non-constant + bracketed initializers for automatic variables. + + Sun Sep 18 10:12:12 1994 Jason Merrill (jason@deneb.cygnus.com) + + * error.c (dump_decl): Don't say `typedef enum foo foo'. + + * decl.c (start_decl): Don't set TREE_PUBLIC on template decls just + because they're affected by #pragma i/i. We'll deal with that when + they get instantiated. + + * typeck.c (build_unary_op): Clean up cruft in ADDR_EXPR case. + + * class.c (instantiate_type): Set TREE_CONSTANT on instantiated + ADDR_EXPRs if appropriate. + + * decl.c (build_ptrmemfunc_type): Unset IS_AGGR_TYPE on pmf types. + + * typeck.c (build_ptrmemfunc): Handle &overloaded_method as an + initializer properly. + * typeck2.c (digest_init): Ditto. + + * tree.c (cp_build_type_variant): Like c_build_type_variant, except + it uses build_cplus_array_type. + * *.c: Use cp_build_type_variant instead of c_build_type_variant. + + * pt.c (do_type_instantiation): Don't try to instantiate nested + enums. + + Tue Sep 13 10:56:58 1994 Jason Merrill (jason@deneb.cygnus.com) + + * cvt.c (build_up_reference): Handle preincrement and predecrement + properly. + + Tue Sep 13 09:51:59 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * decl.c (finish_decl): Only lay out the rtl for DECL if it is, in + fact, static. + + Mon Sep 12 14:40:30 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * decl.c (finish_decl): Lay out the rtl for DECL before doing + grok_reference_init, in case it's static. + + Mon Sep 12 12:45:38 1994 Jason Merrill (jason@deneb.cygnus.com) + + * class.c (finish_struct): Don't synthesize constructors if the + class has a field with the same name as the class. Don't die on + classes with no constructors or destructors. Don't die if the head + and tail of the class are in different files. + + * decl.c (grokdeclarator): Don't treat a function pointer field + with the same name as the class as a constructor. + + Fri Sep 9 13:17:00 1994 Jason Merrill (jason@deneb.cygnus.com) + + * typeck.c (build_c_cast): Pull constant values out of their + variables here. + + * decl.c (duplicate_decls): Only propagate DECL_CHAIN in + FUNCTION_DECLs and TEMPLATE_DECLs. + + Thu Sep 8 10:07:48 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (duplicate_decls): Propagate DECL_CHAIN in all DECLs that + have it. + + * pt.c (unify): REALs and INTEGERs only unify with their own genus. + (instantiate_member_templates): Don't muck with DECL_EXTERNAL and + TREE_PUBLIC unless -fexternal-templates. + + Wed Sep 7 13:17:10 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (do_type_instantiation): Call instantiate_member_templates. + Deal with specializations. + (tsubst): Don't stick the mangled name in DECL_NAME for function + instantiations. Don't push them, either. + + * decl2.c (grokfield): Move code for generating the + DECL_ASSEMBLER_NAME for static members from here. + * method.c (build_static_name): To here. + * decl.c (grokvardecl): Call build_static_name. + (duplicate_decls): Keep old DECL_ASSEMBLER_NAME. + + Mon Sep 5 12:49:18 1994 Jason Merrill (jason@deneb.cygnus.com) + + * call.c (build_method_call): if -Wsynth, warn when selecting + synthesized op= over user-supplied one cfront would select. + * decl2.c (lang_decode_option): Handle -Wsynth. + + Fri Sep 2 15:11:59 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (finish_enum): Overhaul to fix several bugs. + (start_enum): Disable useless code. + + Thu Sep 1 16:04:54 1994 Jason Merrill (jason@deneb.cygnus.com) + + * typeck.c (c_expand_return): Warn about returning a reference to a + temporary. + (convert_arguments): Increment argument counter when using default + arguments, too. + + Wed Aug 31 14:29:22 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (finish_decl): If the type of decl is error_mark_node, + don't bother trying to do anything. + + * typeck.c (convert_for_initialization): If the rhs contains a + constructor call, pretend the lhs type needs to be constructed. + + * init.c (expand_default_init): If we stick the object inside the + initializer, mark the initializer used. + + Tue Aug 30 13:50:18 1994 Jason Merrill (jason@deneb.cygnus.com) + + * method.c (build_assign_ref): return *this; + (build_assign_ref): Fix base assignment order. + (build_copy_constructor): Fix member init order. + + Mon Aug 29 13:54:39 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * g++.c (main): Remember to clear out SAW_SPECLANG after we see + its argument. + + Sat Aug 27 09:36:03 1994 Jason Merrill (jason@deneb.cygnus.com) + + * method.c (build_copy_constructor): Also copy virtual bases. + + Fri Aug 26 17:05:15 1994 Jason Merrill (jason@deneb.cygnus.com) + + * lex.c (do_pending_inlines): Clear out pending_inlines before doing + any synthesis. Also first set deja_vu on all pending_inlines. + + * method.c (build_assign_ref): Use build_member_call to invoke base + operator=, rather than build_modify_expr. And use + build_reference_type instead of TYPE_REFERENCE_TO. + (build_copy_constructor): Use TYPE_NESTED_NAME to identify the + basetype. + + * decl2.c (grokfield): Don't complain about undefined local class + methods. + + * class.c (finish_struct): Don't try to synthesize methods here. + * lex.c (do_pending_inlines): Instead, synthesize them here. + (init_lex): Initialize synth_obstack. + (cons_up_default_function): Stick synthesis request on + pending_inlines. + + Fri Aug 26 12:24:14 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * call.c (build_method_call) [PCC_STATIC_STRUCT_RETURN]: Also + accept an RTL_EXPR in what we're about to use for the instance, + since anything which would end up with pcc_struct_return set + inside cplus_expand_expr. + + * cp-tree.h (cons_up_default_function): Note change of prototype. + + Thu Aug 25 23:05:30 1994 Gerald Baumgartner (gb@cs.purdue.edu) + + * class.c (finish_struct): Undid change from Aug 21 testing + CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING. + * parse.y (left_curly): Ditto, undid change from Aug 21. + * decl.c (xref_tag): Undid change from Aug 21, set + CLASSTYPE_INTERFACE correctly, and added comments. + + Thu Aug 25 00:36:31 1994 Jason Merrill (jason@deneb.cygnus.com) + + Rework approach to synthesized methods; don't go through the parser + anymore. + * class.c (finish_struct): Use new synthesis approach. + * lex.c (cons_up_default_function): Now just creates declaration, + not code. + (largest_union_member): #if 0 out. + (default_assign_ref_body): Ditto. + (default_copy_constructor_body): Ditto. + * method.c (build_default_constructor): New function to synthesize X(). + (build_copy_constructor): Synthesize X(X&). + (build_assign_ref): Synthesize X::operator=(X&). + (build_dtor): Synthesize ~X(). + + * error.c (cp_line_of): If we're dealing with an artificial + TYPE_DECL, look at the type instead. + + Wed Aug 24 11:11:50 1994 Jason Merrill (jason@deneb.cygnus.com) + + * init.c (sort_member_init): Check warn_reorder. + * decl2.c (lang_decode_option): Handle -W{no-,}reorder. + + * cp-tree.h (CLASSTYPE_SOURCE_LINE): New macro. + * error.c (cp_line_of): Use CLASSTYPE_SOURCE_LINE for aggregates. + * class.c (finish_struct): Set CLASSTYPE_SOURCE_LINE. + + Tue Aug 23 09:28:35 1994 Mike Stump (mrs@cygnus.com) + + * error.c (dump_decl): Improve wording, so that error messages + dont't read template<, class foo>... + + Mon Aug 22 15:30:51 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * parse.y (label_colon): Also match a TYPENAME as a label name, + since they may have declared a class by that name but have also + tried to have a local label under the same name. + + * pt.c (coerce_template_parms): Call cp_error, not cp_error_at, + for the message so they know at what point it was instantiated. + + Sun Aug 21 23:07:35 1994 Gerald Baumgartner (gb@cs.purdue.edu) + + * class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and + CLASSTYPE_VTABLE_NEEDS_WRITING for signatures up to left_curly time. + * decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and + CLASSTYPE_VTABLE_NEEDS_WRITING for signatures down to left_curly time. + * parse.y (left_curly): New final resting place for setting + CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING for signatures. + + * class.c (finish_struct): Don't test for function/field name + conflicts in signatures, since all the fields are compiler-constructed. + + Fri Aug 19 14:04:47 1994 Kung Hsu (kung@mexican.cygnus.com) + + * method.c (build_overload_nested_name): in qualified name + mangling, the template with value instantiation will have numeric + at end and may mixed with the name length of next nested level. + Add a '_' in between. + * method.c (build_overload_name): ditto. + * method.c (build_overload_identifier): ditto. + + Thu Aug 18 16:24:43 1994 Mike Stump (mrs@cygnus.com) + + * error.c (dump_decl): Handle NULL args. + + Thu Aug 18 12:48:09 1994 Mike Stump (mrs@cygnus.com) + + * class.c (finish_struct): Move setting of CLASSTYPE_INTERFACE and + CLASSTYPE_VTABLE_NEEDS_WRITING up to left_curly time. + * decl.c (xref_tag): Move setting of CLASSTYPE_INTERFACE and + CLASSTYPE_VTABLE_NEEDS_WRITING down to left_curly time. + * parse.y (left_curly): New final resting place for setting + CLASSTYPE_INTERFACE and CLASSTYPE_VTABLE_NEEDS_WRITING. + + Thu Aug 11 11:32:42 1994 H.J. Lu (hjl@nynexst.com) + + * g++.c (main): Only decrement "added" and set "library" to + NULL when "library" != NULL. + + Sat Aug 13 00:14:52 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (grokdeclarator): Don't set TREE_PUBLIC on a function decl + just because its class has a known interface. + (decls_match): Deal with new format of template parms. + + * lex.c (cons_up_default_function): Don't play with TREE_PUBLIC and + DECL_EXTERNAL here. + + Fri Aug 12 01:55:15 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (pushtag): SET_DECL_ARTIFICIAL on gratuitous typedefs. + (xref_defn_tag): Ditto. + (pushdecl): Only allow artificial typedefs to be shadowed. + + * init.c (emit_base_init): Pass the right binfos to + expand_aggr_init_1. + + * class.c (delete_duplicate_fields_1): Make it work right. + (finish_struct): Catch function/field name conflict. + + * decl2.c (check_classfn): Pass the function to cp_error, not just + the name. + + * init.c (sort_member_init): Warn when order of member initializers + does not match order of member declarations. + (emit_base_init): Call expand_aggr_init_1 with LOOKUP_PROTECT. + + * error.c (dump_expr): Handle lists of functions. + + * decl.c (start_function): #pragma interface only affects functions + that would otherwise be static. + (finish_decl): Don't warn about an unused variable if it has both + constructor and destructor, since the 'resource allocation is + initialization' idiom is relatively common. + + * typeck.c (comp_target_types): Don't handle TEMPLATE_TYPE_PARMs. + (comp_target_parms): Ditto. + (compparms): Never consider default parms. + (common_base_type): Don't choose a virtual baseclass if there is a + more derived class in common. + (build_conditional_expr): If pedantic, pedwarn about conversion to + common base in conditional expr. + + * class.c (instantiate_type): Handle template instantiation better. + + * typeck.c (convert_arguments): Don't try to get tricky and convert + to int directly when PROMOTE_PROTOTYPES is set, as it breaks + user-defined conversions. + + * lex.c (check_for_missing_semicolon): Also give error at end of + file. + + * call.c (build_method_call): Don't promote arrays to pointers here. + + * typeck.c (convert_arguments): Don't require the actual parameter + to be of a complete type if the formal parameter is a reference. + + Thu Aug 11 15:21:40 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl.c (grokdeclarator): Soften 'static' on member function error + to pedwarn. + + * init.c (build_new): Don't automatically save rval. + (build_offset_ref): Do field lookup with proper basetype_path. + + Thu Aug 11 12:46:54 1994 Brendan Kehoe (brendan@lisa.cygnus.com) + + * errfn.c (cp_silent): Declare to mark when we should avoid + emitting warnings and errors. + (cp_error): Check it. + (cp_warning): Likewise. + (cp_pedwarn): Likewise. + (cp_compiler_error): Likewise. + (cp_error_at): Likewise. + (cp_warning_at): Likewise. + (cp_pedwarn_at): Likewise. + * call.c (compute_conversion_costs): Set CP_SILENT when we start + out, and make sure we turn it off before we leave. + + Thu Aug 11 00:02:54 1994 Jason Merrill (jason@deneb.cygnus.com) + + * decl2.c (grok_array_decl): Try computing *(A+B) if neither + argument is obviously an array. + + Wed Aug 10 15:32:04 1994 Jason Merrill (jason@deneb.cygnus.com) + + * typeck.c (c_expand_start_case): Do cleanups here. + + * parse.y (xcond): Do bool conversion here, too. + (simple_stmt, SWITCH case): Don't do cleanups here. + + * decl.c (duplicate_decls): Don't treat builtins that have been + explicitly declared specially. + + Tue Aug 9 01:16:09 1994 Jason Merrill (jason@deneb.cygnus.com) + + * tree.c (make_deep_copy): Support copying pointer, reference, + function, array, offset and method types. + + * decl.c (init_decl_processing): Mark exit and abort as + BUILT_IN_NONANSI so that duplicate_decls is kinder about + redeclaration. + (duplicate_decls): Don't give two errors for redeclaring a C + function with the same parms but a different return type. + + * parse.y (paren_cond_or_null): Do cleanup and bool conversion here. + (condition): Instead of here. + (simple_stmt, SWITCH case): Also do cleanup here. + + * decl2.c (finish_anon_union): Only break out FIELD_DECLs. + + * call.c (build_method_call): Don't throw away the side effects of + the object in a call to a non-existent constructor. + * parse.y (primary): Ditto. + + * method.c (build_decl_overload): Oop. + + * decl2.c (lang_decode_option): Deal with flag_no_nonansi_builtin, + warn about uselessness of specifying -fansi-overloading. + + * method.c (build_decl_overload): Treat any non-member new with one + parameter as __builtin_new. + + * decl.c (init_decl_processing): Setup built-in meanings of exit, + _exit and abort. + + Mon Aug 8 15:03:30 1994 Jason Merrill (jason@deneb.cygnus.com) + + * error.c (dump_readonly_or_volatile): Put a space between const and + volatile if both apply. + + * init.c (perform_member_init): Clean up after this initialization. + (emit_base_init): Clean up after each base init, not after all have + been done. + (expand_aggr_vbase_init_1): Clean up after this init. + + Sun Aug 7 14:55:05 1994 Jason Merrill (jason@deneb.cygnus.com) + + * call.c (build_method_call): Deal with destroying references. + + * parse.y (condition): Do bool_truthvalue_conversion here. + (paren_expr_or_null): And here. + (simple_if): Not here. + (simple_stmt): Or here. + + Sat Aug 6 22:29:45 1994 Jason Merrill (jason@deneb.cygnus.com) + + * parse.y (paren_expr_or_null): Wrap the expression in a + CLEANUP_POINT_EXPR. + (condition): Ditto. + + Sat Aug 6 19:46:37 1994 Rohan Lenard (rjl@easams.com.au) + + * call.c (build_scoped_method_call): Fix error message when + destructor call refers to a nonexistent type. + + Sat Apr 16 22:43:30 1993 Gerald Baumgartner (gb@cs.purdue.edu) + + * lex.h (rid): Deleted RID_RAISES, it's never used. + Moved RID_PUBLIC, RID_PRIVATE, RID_PROTECTED, RID_EXCEPTION, + RID_TEMPLATE and RID_SIGNATURE to the end of the enumeration, + they don't need to be touched in `grokdeclarator.' + (RID_LAST_MODIFIER): Defined macro to be RID_MUTABLE. + + * decl.c (grokdeclarator): Use RID_LAST_MODIFIER instead of + RID_MAX as loop limit for finding declaration specifiers. + + Sat Apr 3 21:59:07 1993 Gerald Baumgartner (gb@cs.purdue.edu) + + * lex.c (debug_yytranslate): Moved to parse.y since it needs to + access `yytname,' which is static in parse.c. + + Fri Apr 2 23:36:57 1993 Gerald Baumgarnter (gb@cs.purdue.edu) + + * cp-tree.h (GNU_xref_ref): Fixed typo in extern declaration, it + was `GNU_xref_def' instead of `GNU_xref_ref.' + + Fri Aug 5 14:20:16 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (do_function_instantiation): Don't set TREE_PUBLIC and + DECL_EXTERNAL on 'extern' instantiations; wait until EOF to do that. + (do_type_instantiation): Ditto. + + * decl2.c (import_export_inline): Decides at EOF what an inline's + linkage should be. + (finish_file): Call it. + + * decl.c (start_function): Don't rely on the settings of TREE_PUBLIC + and DECL_EXTERNAL from do_*_instantiation. Only set + DECL_DEFER_OUTPUT on inlines whose linkage might actually change. + (finish_function): Use DECL_DEFER_OUTPUT to decide which inlines to + mark for later consideration, rather than DECL_FUNCTION_MEMBER_P. + + Fri Aug 5 01:12:20 1994 Mike Stump (mrs@cygnus.com) + + * class.c (get_class_offset_1, get_class_offset): New routine to + find the offset of the class where a virtual function is defined, + from the complete type. + * class.c (modify_one_vtable, fixup_vtable_deltas): Use + get_class_offset instead of virtual_offset as get_class_offset will + always provide the right answer. + * tree.c (virtual_offset): Remove. It only ever worked some of the + time. + + Tue Aug 2 12:44:21 1994 Jason Merrill (jason@deneb.cygnus.com) + + * call.c (build_method_call): Put back unary_complex_lvalue call + that I thought was redundant. + + * typeck.c (c_expand_return): Fix a case I missed before. + + Sun Jul 31 17:54:02 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (unify): Strip cv-quals from template type arguments (when + 'const T*' is matched to 'const char*', that does not mean that T is + 'const char'). + + Fri Jul 29 01:03:06 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (do_type_instantiation): Instantiate nested TAGS, not + typedefs. Third time's the charm? + + * parse.y (template_parm): Support default template parms. + * pt.c (process_template_parm): Ditto. + (end_template_parm_list): Ditto. + (coerce_template_parms): Ditto. + (mangle_class_name_for_template): Ditto. + (push_template_decls): Ditto. + (unify): Ditto. + * method.c (build_overload_identifier): Ditto. + * error.c (dump_decl): Ditto. + + Wed Jul 27 17:47:00 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (do_type_instantiation): Only instantiate nested *classes*. + + Tue Jul 26 13:22:40 1994 Jason Merrill (jason@deneb.cygnus.com) + + * search.c (note_debug_info_needed): Also emit debugging information + for the types of fields. + + Mon Jul 25 00:34:44 1994 Jason Merrill (jason@deneb.cygnus.com) + + * pt.c (lookup_template_class): Pass 'template' to + coerce_template_parms instead of 'in_decl', since it's a more + meaningful context. + + * typeck.c (c_expand_return): Make sure any cleanups for the return + expression get run. + (build_c_cast): Use CONVERT_EXPR for conversion to void. + + * pt.c (do_type_instantiation): Also instantiate nested types. + + * typeck.c (convert_for_assignment): Don't die when comparing + pointers with different levels of indirection. + + * decl.c (grokdeclarator): The sub-call to grokdeclarator for + class-local typedefs sets DECL_ARGUMENTS, so we need to clear it + out. + + * decl2.c (finish_anon_union): Don't die if the union has no + members. + + * decl.c (grokdeclarator): Undo changes to declspecs when we're done + so that 'typedef int foo, bar;' will work. + + * decl2.c (finish_file): Don't call expand_aggr_init for + non-aggregates. + + Mon Jul 25 00:03:10 1994 Teemu Torma (tot@trema.fi) + + * decl.c (finish_function): We can't inline constructors and + destructors under some conditions with -fpic, but don't unset + DECL_INLINE. + + Mon Jul 25 00:03:10 1994 Jason Merrill (jason@deneb.cygnus.com) + + * typeck.c (build_object_ref): Make sure 'datum' is a valid object. + + Sun Jul 24 14:19:31 1994 Jason Merrill (jason@deneb.cygnus.com) + + * class.c (finish_struct): Don't set DECL_FIELD_BITPOS on + non-fields. + (finish_struct_methods): Use copy_assignment_arg_p. + + * cvt.c (cp_convert): If expr is an OFFSET_REF, resolve it instead + of giving an error. + + * typeck.c (build_binary_op_nodefault): Don't set result_type if we + don't know how to compare the operands. + + * decl.c (grokdeclarator): Avoid seg fault when someone uses '__op' + as a declarator-id in their program. Like the Linux headers do. + Arrgh. + + * tree.c (lvalue_p): Treat calls to functions returning objects by + value as lvalues again. + + * typeck.c (build_component_addr): Use convert_force to convert the + pointer in case the component type is also a private base class. + + * search.c (get_matching_virtual): Fix bogus warning of overloaded + virtual. + + * pt.c (overload_template_name): Set DECL_ARTIFICIAL on the created + TYPE_DECL to fix bogus shadowing warnings. + + Fri Jul 22 01:15:32 1994 Jason Merrill (jason@deneb.cygnus.com) + + * init.c (expand_aggr_init_1): const and volatile mismatches do not + prevent a TARGET_EXPR from initializing an object directly. + + Tue Jul 19 17:55:37 1994 Jason Merrill (jason@deneb.cygnus.com) + + * cvt.c (build_up_reference): Allow building up references to + `this', don't warn about making references to artificial variables + (like `this'). + + * tree.c (lvalue_p): `this' is not an lvalue. + + * call.c (build_method_call): Accept using a typedef name (or + template type parameter) for explicit destructor calls. + Wed Jul 13 03:57:54 1994 Jason Merrill (jason@deneb.cygnus.com) ! * method.c (hack_identifier): Put back old code so lists of ! non-functions will be handled properly. ! * cp-tree.h (TYPE_NEEDS_CONSTRUCTING): #if 0 out; this macro is now ! defined in the language-independent tree.h. ! * tree.c (count_functions): Avoid bogus warning when compiling this ! function. Mon Jul 11 18:37:20 1994 Jason Merrill (jason@deneb.cygnus.com) ! * decl.c (grok_reference_init): Always save the initializer of a ! reference. Fri Jul 8 17:41:46 1994 Mike Stump (mrs@cygnus.com) *************** *** 37,41 **** * decl.c (push_overloaded_decl): Don't create overloads of one when shadowing a class type. ! * typeck.c (build_x_function_call): Complain about overloads of one * decl.c (grokdeclarator): Don't try to treat a char* as a tree. --- 849,853 ---- * decl.c (push_overloaded_decl): Don't create overloads of one when shadowing a class type. ! * typeck.c (build_x_function_call): Complain about overloads of one. * decl.c (grokdeclarator): Don't try to treat a char* as a tree. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/Makefile.in gcc-2.6.1/cp/Makefile.in *** gcc-2.6.0/cp/Makefile.in Fri Jun 3 17:34:37 1994 --- gcc-2.6.1/cp/Makefile.in Fri Aug 5 16:18:47 1994 *************** *** 194,198 **** $(srcdir)/parse.c $(srcdir)/parse.h : $(srcdir)/parse.y ! @echo expect 1 shift/reduce confict and 33 reduce/reduce conflicts. cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y cd $(srcdir); grep '^#define[ ]*YYEMPTY' parse.c >>parse.h --- 194,198 ---- $(srcdir)/parse.c $(srcdir)/parse.h : $(srcdir)/parse.y ! @echo expect 1 shift/reduce confict and 34 reduce/reduce conflicts. cd $(srcdir); $(BISON) $(BISONFLAGS) -d -o parse.c parse.y cd $(srcdir); grep '^#define[ ]*YYEMPTY' parse.c >>parse.h diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/call.c gcc-2.6.1/cp/call.c *** gcc-2.6.0/cp/call.c Sat Jul 9 03:10:06 1994 --- gcc-2.6.1/cp/call.c Fri Oct 14 20:30:55 1994 *************** *** 701,704 **** --- 701,705 ---- int strike_index = 0, win; struct harshness_code lose; + extern int cp_silent; #ifdef GATHER_STATISTICS *************** *** 706,709 **** --- 707,715 ---- #endif + #ifndef DEBUG_MATCHING + /* We don't emit any warnings or errors while trying out each candidate. */ + cp_silent = 1; + #endif + cp->function = function; cp->arg = tta ? TREE_VALUE (tta) : NULL_TREE; *************** *** 713,717 **** cp->h.distance = 0; cp->h.int_penalty = 0; ! bzero (cp->harshness, (cp->h_len + 1) * sizeof (struct harshness_code)); --- 719,723 ---- cp->h.distance = 0; cp->h.int_penalty = 0; ! bzero ((char *) cp->harshness, (cp->h_len + 1) * sizeof (struct harshness_code)); *************** *** 813,816 **** --- 819,823 ---- cp->h.code = EVIL_CODE; cp->u.bad_arg = -1; + cp_silent = 0; return; } *************** *** 834,837 **** --- 841,845 ---- cp->h.code = EVIL_CODE; cp->u.bad_arg = -2; + cp_silent = 0; return; } *************** *** 856,859 **** --- 864,868 ---- { cp->h.code = EVIL_CODE; + cp_silent = 0; return; } *************** *** 1003,1006 **** --- 1012,1016 ---- if (user_strikes) cp->h.code |= USER_CODE; + cp_silent = 0; #ifdef DEBUG_MATCHING cp_error ("final eval %s", print_harshness (&cp->h)); *************** *** 1429,1437 **** cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')", exp, basetype, type); ! name = IDENTIFIER_TYPE_VALUE (TREE_OPERAND (name, 0)); ! if (basetype != name) ! cp_error ("qualified type `%T' does not match destructor type `%T'", basetype, name); ! return void_zero_node; } --- 1439,1447 ---- cp_error ("type of `%E' does not match destructor type `%T' (type was `%T')", exp, basetype, type); ! name = TREE_OPERAND (name, 0); ! if (basetype != get_type_value (name)) ! cp_error ("qualified type `%T' does not match destructor name `~%T'", basetype, name); ! return convert (void_type_node, exp); } *************** *** 1461,1468 **** /* Explicit call to destructor. */ name = TREE_OPERAND (name, 0); ! if (name != constructor_name (TREE_TYPE (decl))) { cp_error ! ("qualified type `%T' does not match destructor type `%T'", TREE_TYPE (decl), name); return error_mark_node; --- 1471,1479 ---- /* Explicit call to destructor. */ name = TREE_OPERAND (name, 0); ! if (! (name == constructor_name (TREE_TYPE (decl)) ! || TREE_TYPE (decl) == get_type_value (name))) { cp_error ! ("qualified type `%T' does not match destructor name `~%T'", TREE_TYPE (decl), name); return error_mark_node; *************** *** 1469,1473 **** } if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl))) ! return void_zero_node; return build_delete (TREE_TYPE (decl), decl, integer_two_node, --- 1480,1484 ---- } if (! TYPE_HAS_DESTRUCTOR (TREE_TYPE (decl))) ! return convert (void_type_node, exp); return build_delete (TREE_TYPE (decl), decl, integer_two_node, *************** *** 1605,1625 **** error ("destructors take no parameters"); basetype = TREE_TYPE (instance); ! if (IS_AGGR_TYPE (basetype)) ! { ! if (name == constructor_name (basetype)) ! goto huzzah; ! } ! else ! { ! if (basetype == get_type_value (name)) ! goto huzzah; } - cp_error ("destructor name `~%D' does not match type `%T' of expression", - name, basetype); - return void_zero_node; - huzzah: if (! TYPE_HAS_DESTRUCTOR (basetype)) ! return void_zero_node; instance = default_conversion (instance); instance_ptr = build_unary_op (ADDR_EXPR, instance, 0); --- 1616,1632 ---- error ("destructors take no parameters"); basetype = TREE_TYPE (instance); ! if (TREE_CODE (basetype) == REFERENCE_TYPE) ! basetype = TREE_TYPE (basetype); ! if (! ((IS_AGGR_TYPE (basetype) ! && name == constructor_name (basetype)) ! || basetype == get_type_value (name))) ! { ! cp_error ("destructor name `~%D' does not match type `%T' of expression", ! name, basetype); ! return convert (void_type_node, instance); } if (! TYPE_HAS_DESTRUCTOR (basetype)) ! return convert (void_type_node, instance); instance = default_conversion (instance); instance_ptr = build_unary_op (ADDR_EXPR, instance, 0); *************** *** 1807,1811 **** else { ! if (TREE_CODE (instance) != CALL_EXPR) my_friendly_abort (125); if (TYPE_NEEDS_CONSTRUCTING (basetype)) --- 1814,1822 ---- else { ! if (TREE_CODE (instance) != CALL_EXPR ! #ifdef PCC_STATIC_STRUCT_RETURN ! && TREE_CODE (instance) != RTL_EXPR ! #endif ! ) my_friendly_abort (125); if (TYPE_NEEDS_CONSTRUCTING (basetype)) *************** *** 1898,1901 **** --- 1909,1914 ---- TREE_VALUE (parm) = build_unary_op (ADDR_EXPR, TREE_VALUE (parm), 0); } + #if 0 + /* This breaks reference-to-array parameters. */ if (TREE_CODE (t) == ARRAY_TYPE) { *************** *** 1905,1908 **** --- 1918,1922 ---- t = TREE_TYPE (TREE_VALUE (parm)); } + #endif if (t == error_mark_node) return error_mark_node; *************** *** 1933,1937 **** constp = 0; volatilep = 0; ! parms = tree_cons (NULL_TREE, build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node), parms); } else --- 1947,1953 ---- constp = 0; volatilep = 0; ! parms = tree_cons (NULL_TREE, ! build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), ! integer_zero_node), parms); } else *************** *** 1946,1949 **** --- 1962,1969 ---- instance = build_indirect_ref (instance_ptr, NULL_PTR); + #if 0 + /* This breaks initialization of a reference from a new + expression of a different type. And it doesn't appear to + serve its original purpose any more, either. jason 10/12/94 */ /* If it's a default argument initialized from a ctor, what we get from instance_ptr will match the arglist for the FUNCTION_DECL *************** *** 1954,1957 **** --- 1974,1978 ---- parms = build_tree_list (NULL_TREE, instance_ptr); else + #endif parms = tree_cons (NULL_TREE, instance_ptr, parms); } *************** *** 2013,2016 **** --- 2034,2038 ---- + #if 0 /* Now, go look for this method name. We do not find destructors here. *************** *** 2022,2025 **** --- 2044,2048 ---- || name == constructor_name_full (save_basetype))); TREE_CHAIN (last) = NULL_TREE; + #endif for (pass = 0; pass < 2; pass++) *************** *** 2041,2045 **** = (struct candidate *) alloca ((ever_seen+1) * sizeof (struct candidate)); ! bzero (candidates, (ever_seen + 1) * sizeof (struct candidate)); cp = candidates; len = list_length (parms); --- 2064,2068 ---- = (struct candidate *) alloca ((ever_seen+1) * sizeof (struct candidate)); ! bzero ((char *) candidates, (ever_seen + 1) * sizeof (struct candidate)); cp = candidates; len = list_length (parms); *************** *** 2063,2067 **** tree new_type; parm = build_indirect_ref (parm, "friendifying parms (compiler error)"); ! new_type = c_build_type_variant (TREE_TYPE (parm), constp, volatilep); new_type = build_reference_type (new_type); --- 2086,2090 ---- tree new_type; parm = build_indirect_ref (parm, "friendifying parms (compiler error)"); ! new_type = cp_build_type_variant (TREE_TYPE (parm), constp, volatilep); new_type = build_reference_type (new_type); *************** *** 2148,2154 **** --- 2171,2179 ---- continue; + #if 0 if (pass == 0 && DECL_ASSEMBLER_NAME (function) == method_name) goto found; + #endif if (pass > 0) *************** *** 2245,2248 **** --- 2270,2274 ---- { int n_candidates = cp - candidates; + extern int warn_synth; TREE_VALUE (parms) = instance_ptr; cp = ideal_candidate (save_basetype, candidates, *************** *** 2252,2257 **** if (flags & LOOKUP_COMPLAIN) { ! cp_error ("call of overloaded %s `%D' is ambiguous", ! name_kind, name); print_n_candidates (candidates, n_candidates); } --- 2278,2284 ---- if (flags & LOOKUP_COMPLAIN) { ! TREE_CHAIN (last) = void_list_node; ! cp_error ("call of overloaded %s `%D(%A)' is ambiguous", ! name_kind, name, TREE_CHAIN (parmtypes)); print_n_candidates (candidates, n_candidates); } *************** *** 2260,2263 **** --- 2287,2300 ---- if (cp->h.code & EVIL_CODE) return error_mark_node; + if (warn_synth + && DECL_NAME (cp->function) == ansi_opname[MODIFY_EXPR] + && DECL_ARTIFICIAL (cp->function) + && n_candidates == 2) + { + cp_warning ("using synthesized `%#D' for copy assignment", + cp->function); + cp_warning_at (" where cfront would use `%#D'", + candidates->function); + } } else if (cp[-1].h.code & EVIL_CODE) *************** *** 2665,2669 **** return error_mark_node; } ! if (TREE_CODE (t) == ARRAY_TYPE || TREE_CODE (t) == OFFSET_TYPE) { /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place. --- 2702,2710 ---- return error_mark_node; } ! if (TREE_CODE (t) == OFFSET_TYPE) ! #if 0 ! /* This breaks reference-to-array parameters. */ ! || TREE_CODE (t) == ARRAY_TYPE ! #endif { /* Perform the conversion from ARRAY_TYPE to POINTER_TYPE in place. *************** *** 2739,2743 **** candidates = (struct candidate *)alloca ((length+1) * sizeof (struct candidate)); ! bzero (candidates, (length + 1) * sizeof (struct candidate)); } --- 2780,2784 ---- candidates = (struct candidate *)alloca ((length+1) * sizeof (struct candidate)); ! bzero ((char *) candidates, (length + 1) * sizeof (struct candidate)); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/class.c gcc-2.6.1/cp/class.c *** gcc-2.6.0/cp/class.c Sat Jul 9 03:10:28 1994 --- gcc-2.6.1/cp/class.c Sat Oct 15 13:05:49 1994 *************** *** 943,947 **** + len * sizeof (tree)); tmp_vec = (tree) obstack_base (ob); ! bcopy (method_vec, tmp_vec, (sizeof (struct tree_common) + tree_code_length[(int) TREE_VEC] * sizeof (char *) --- 943,947 ---- + len * sizeof (tree)); tmp_vec = (tree) obstack_base (ob); ! bcopy ((char *) method_vec, (char *) tmp_vec, (sizeof (struct tree_common) + tree_code_length[(int) TREE_VEC] * sizeof (char *) *************** *** 993,1001 **** when we have unnamed bitfields, for example. */ static tree ! delete_duplicate_fields_1 (field, field_ptr, fields) ! tree field, *field_ptr, fields; { tree x; ! tree prev = field_ptr ? *field_ptr : 0; if (DECL_NAME (field) == 0) { --- 993,1001 ---- when we have unnamed bitfields, for example. */ static tree ! delete_duplicate_fields_1 (field, fields) ! tree field, fields; { tree x; ! tree prev = 0; if (DECL_NAME (field) == 0) { *************** *** 1004,1010 **** for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x)) ! fields = delete_duplicate_fields_1 (x, field_ptr, fields); ! if (prev) ! TREE_CHAIN (prev) = fields; return fields; } --- 1004,1008 ---- for (x = TYPE_FIELDS (TREE_TYPE (field)); x; x = TREE_CHAIN (x)) ! fields = delete_duplicate_fields_1 (x, fields); return fields; } *************** *** 1018,1022 **** continue; TYPE_FIELDS (TREE_TYPE (x)) ! = delete_duplicate_fields_1 (field, (tree *)0, TYPE_FIELDS (TREE_TYPE (x))); if (TYPE_FIELDS (TREE_TYPE (x)) == 0) { --- 1016,1020 ---- continue; TYPE_FIELDS (TREE_TYPE (x)) ! = delete_duplicate_fields_1 (field, TYPE_FIELDS (TREE_TYPE (x))); if (TYPE_FIELDS (TREE_TYPE (x)) == 0) { *************** *** 1040,1044 **** else if (TREE_CODE (field) == TYPE_DECL && TREE_CODE (x) == TYPE_DECL) ! cp_error_at ("duplicate class scope type `%D'", x); else if (TREE_CODE (field) == TYPE_DECL || TREE_CODE (x) == TYPE_DECL) --- 1038,1042 ---- else if (TREE_CODE (field) == TYPE_DECL && TREE_CODE (x) == TYPE_DECL) ! cp_error_at ("duplicate nested type `%D'", x); else if (TREE_CODE (field) == TYPE_DECL || TREE_CODE (x) == TYPE_DECL) *************** *** 1064,1068 **** tree x; for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x)) ! TREE_CHAIN (x) = delete_duplicate_fields_1 (x, &x, TREE_CHAIN (x)); } --- 1062,1066 ---- tree x; for (x = fields; x && TREE_CHAIN (x); x = TREE_CHAIN (x)) ! TREE_CHAIN (x) = delete_duplicate_fields_1 (x, TREE_CHAIN (x)); } *************** *** 1122,1129 **** } ! /* Get the offset to the start of the original binfo that we derived this ! binfo from. */ ! tree get_derived_offset (binfo) ! tree binfo; { tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo))); --- 1120,1131 ---- } ! /* Get the offset to the start of the original binfo that we derived ! this binfo from. If we find TYPE first, return the offset only ! that far. The shortened search is useful because the this pointer ! on method calling is expected to point to a DECL_CONTEXT (fndecl) ! object, and not a baseclass of it. */ ! static tree ! get_derived_offset (binfo, type) ! tree binfo, type; { tree offset1 = get_vfield_offset (TYPE_BINFO (BINFO_TYPE (binfo))); *************** *** 1134,1137 **** --- 1136,1141 ---- { tree binfos = BINFO_BASETYPES (binfo); + if (BINFO_TYPE (binfo) == type) + break; binfo = TREE_VEC_ELT (binfos, i); } *************** *** 1341,1345 **** int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; int first_vfn_base_index = -1; ! bzero (b, sizeof (struct base_info)); for (i = 0; i < n_baseclasses; i++) --- 1345,1349 ---- int i, n_baseclasses = binfos ? TREE_VEC_LENGTH (binfos) : 0; int first_vfn_base_index = -1; ! bzero ((char *) b, sizeof (struct base_info)); for (i = 0; i < n_baseclasses; i++) *************** *** 1683,1688 **** int i; ! bzero (first_conversions, sizeof (first_conversions)); ! bzero (last_conversions, sizeof (last_conversions)); for (tmp = &TREE_VEC_ELT (method_vec, 1); tmp != TREE_VEC_END (method_vec); tmp += 1) --- 1687,1692 ---- int i; ! bzero ((char *) first_conversions, sizeof (first_conversions)); ! bzero ((char *) last_conversions, sizeof (last_conversions)); for (tmp = &TREE_VEC_ELT (method_vec, 1); tmp != TREE_VEC_END (method_vec); tmp += 1) *************** *** 1831,1836 **** tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields)); ! if (TREE_CODE (parmtype) == REFERENCE_TYPE ! && TYPE_MAIN_VARIANT (TREE_TYPE (parmtype)) == t) { if (TREE_PROTECTED (fn_fields)) --- 1835,1839 ---- tree parmtype = TREE_VALUE (FUNCTION_ARG_CHAIN (fn_fields)); ! if (copy_assignment_arg_p (parmtype, DECL_VIRTUAL_P (fn_fields))) { if (TREE_PROTECTED (fn_fields)) *************** *** 1939,1944 **** && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE && warn_ctor_dtor_privacy) ! warning ("class `%s' only defines a private destructor and has no friends", ! TYPE_NAME_STRING (t)); break; } --- 1942,1947 ---- && DECL_FRIENDLIST (TYPE_NAME (t)) == NULL_TREE && warn_ctor_dtor_privacy) ! cp_warning ("`%#T' only defines a private destructor and has no friends", ! t); break; } *************** *** 2061,2065 **** int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t); ! bzero (TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type)); BINFO_BASETYPES(binfo) = NULL_TREE; --- 2064,2068 ---- int interface_unknown = CLASSTYPE_INTERFACE_UNKNOWN (t); ! bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type)); BINFO_BASETYPES(binfo) = NULL_TREE; *************** *** 2152,2155 **** --- 2155,2238 ---- } + static tree + get_class_offset_1 (parent, binfo, context, t, fndecl) + tree parent, binfo, context, t, fndecl; + { + tree binfos = BINFO_BASETYPES (binfo); + int i, n_baselinks = binfos ? TREE_VEC_LENGTH (binfos) : 0; + tree rval = NULL_TREE; + + if (binfo == parent) + return error_mark_node; + + for (i = 0; i < n_baselinks; i++) + { + tree base_binfo = TREE_VEC_ELT (binfos, i); + tree nrval; + + if (TREE_VIA_VIRTUAL (base_binfo)) + base_binfo = binfo_member (BINFO_TYPE (base_binfo), + CLASSTYPE_VBASECLASSES (t)); + nrval = get_class_offset_1 (parent, base_binfo, context, t, fndecl); + /* See if we have a new value */ + if (nrval && (nrval != error_mark_node || rval==0)) + { + /* Only compare if we have two offsets */ + if (rval && rval != error_mark_node + && ! tree_int_cst_equal (nrval, rval)) + { + /* Only give error if the two offsets are different */ + error ("every virtual function must have a unique final overrider"); + cp_error (" found two (or more) `%T' class subobjects in `%T'", context, t); + cp_error (" with virtual `%D' from virtual base class", fndecl); + return rval; + } + rval = nrval; + } + + if (rval && BINFO_TYPE (binfo) == context) + { + my_friendly_assert (rval == error_mark_node + || tree_int_cst_equal (rval, BINFO_OFFSET (binfo)), 999); + rval = BINFO_OFFSET (binfo); + } + } + return rval; + } + + /* Get the offset to the CONTEXT subobject that is related to the + given BINFO. */ + static tree + get_class_offset (context, t, binfo, fndecl) + tree context, t, binfo, fndecl; + { + tree first_binfo = binfo; + tree offset; + int i; + + if (context == t) + return integer_zero_node; + + if (BINFO_TYPE (binfo) == context) + return BINFO_OFFSET (binfo); + + /* Check less derived binfos first. */ + while (BINFO_BASETYPES (binfo) + && (i=CLASSTYPE_VFIELD_PARENT (BINFO_TYPE (binfo))) != -1) + { + tree binfos = BINFO_BASETYPES (binfo); + binfo = TREE_VEC_ELT (binfos, i); + if (BINFO_TYPE (binfo) == context) + return BINFO_OFFSET (binfo); + } + + /* Ok, not found in the less derived binfos, now check the more + derived binfos. */ + offset = get_class_offset_1 (first_binfo, TYPE_BINFO (t), context, t, fndecl); + if (offset==0 || TREE_CODE (offset) != INTEGER_CST) + my_friendly_abort (999); /* we have to find it. */ + return offset; + } + static void modify_one_vtable (binfo, t, fndecl, pfn) *************** *** 2175,2188 **** tree this_offset; ! offset = integer_zero_node; ! if (context != t && TYPE_USES_COMPLEX_INHERITANCE (t)) ! { ! offset = virtual_offset (context, CLASSTYPE_VBASECLASSES (t), offset); ! if (offset == NULL_TREE) ! { ! tree binfo = get_binfo (context, t, 0); ! offset = BINFO_OFFSET (binfo); ! } ! } /* Find the right offset for the this pointer based on the --- 2258,2262 ---- tree this_offset; ! offset = get_class_offset (context, t, binfo, fndecl); /* Find the right offset for the this pointer based on the *************** *** 2194,2198 **** that we derived this vfield from and us. */ base_offset = size_binop (PLUS_EXPR, ! get_derived_offset (binfo), BINFO_OFFSET (binfo)); this_offset = size_binop (MINUS_EXPR, offset, base_offset); --- 2268,2272 ---- that we derived this vfield from and us. */ base_offset = size_binop (PLUS_EXPR, ! get_derived_offset (binfo, DECL_CONTEXT (current_fndecl)), BINFO_OFFSET (binfo)); this_offset = size_binop (MINUS_EXPR, offset, base_offset); *************** *** 2289,2302 **** tree this_offset; ! offset = integer_zero_node; ! if (context != t && TYPE_USES_COMPLEX_INHERITANCE (t)) ! { ! offset = virtual_offset (context, CLASSTYPE_VBASECLASSES (t), offset); ! if (offset == NULL_TREE) ! { ! tree binfo = get_binfo (context, t, 0); ! offset = BINFO_OFFSET (binfo); ! } ! } /* Find the right offset for the this pointer based on the --- 2363,2367 ---- tree this_offset; ! offset = get_class_offset (context, t, binfo, fndecl); /* Find the right offset for the this pointer based on the *************** *** 2308,2312 **** that we derived this vfield from and us. */ base_offset = size_binop (PLUS_EXPR, ! get_derived_offset (binfo), BINFO_OFFSET (binfo)); this_offset = size_binop (MINUS_EXPR, offset, base_offset); --- 2373,2377 ---- that we derived this vfield from and us. */ base_offset = size_binop (PLUS_EXPR, ! get_derived_offset (binfo, DECL_CONTEXT (fndecl)), BINFO_OFFSET (binfo)); this_offset = size_binop (MINUS_EXPR, offset, base_offset); *************** *** 2685,2688 **** --- 2750,2754 ---- if (DECL_SOURCE_LINE (name)) DECL_SOURCE_LINE (name) = lineno; + CLASSTYPE_SOURCE_LINE (t) = lineno; } name = DECL_NAME (name); *************** *** 2714,2729 **** CLASSTYPE_GOT_SEMICOLON (t) = 0; ! /* A signature type will contain the fields of the signature table. ! Therefore, it's not only an interface. */ ! if (IS_SIGNATURE (t)) ! { ! CLASSTYPE_INTERFACE_ONLY (t) = 0; ! SET_CLASSTYPE_INTERFACE_KNOWN (t); ! } ! else { ! CLASSTYPE_INTERFACE_ONLY (t) = interface_only; ! SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown); } if (flag_dossier) --- 2780,2792 ---- CLASSTYPE_GOT_SEMICOLON (t) = 0; ! #if 0 ! /* This is in general too late to do this. I moved the main case up to ! left_curly, what else needs to move? */ ! if (! IS_SIGNATURE (t)) { ! my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999); ! my_friendly_assert (CLASSTYPE_INTERFACE_KNOWN (t) == ! interface_unknown, 999); } + #endif if (flag_dossier) *************** *** 2788,2799 **** } if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t) && ! IS_SIGNATURE (t)) { ! CLASSTYPE_INTERFACE_ONLY (t) = interface_only; ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! interface_only; } ! else if (IS_SIGNATURE (t)) ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 0; /* The three of these are approximations which may later be --- 2851,2863 ---- } + #if 0 + /* Both of these should be done before now. */ if (write_virtuals == 3 && CLASSTYPE_INTERFACE_KNOWN (t) && ! IS_SIGNATURE (t)) { ! my_friendly_assert (CLASSTYPE_INTERFACE_ONLY (t) == interface_only, 999); ! my_friendly_assert (CLASSTYPE_VTABLE_NEEDS_WRITING (t) == ! interface_only, 999); } ! #endif /* The three of these are approximations which may later be *************** *** 2952,2955 **** --- 3016,3022 ---- } + if (DECL_NAME (x) == constructor_name (t)) + cant_have_default_ctor = cant_synth_copy_ctor = 1; + if (TREE_TYPE (x) == error_mark_node) continue; *************** *** 3218,3221 **** --- 3285,3291 ---- CLASSTYPE_ABSTRACT_VIRTUALS (t) = abstract_virtuals; + /* Synthesize any needed methods. Note that methods will be synthesized + for anonymous unions; grok_x_components undoes that. */ + if (TYPE_NEEDS_DESTRUCTOR (t) && !TYPE_HAS_DESTRUCTOR (t) && !IS_SIGNATURE (t)) *************** *** 3222,3227 **** { /* Here we must cons up a destructor on the fly. */ ! tree dtor = cons_up_default_function (t, name, fields, ! needs_virtual_dtor != 0); /* If we couldn't make it work, then pretend we didn't need it. */ --- 3292,3296 ---- { /* Here we must cons up a destructor on the fly. */ ! tree dtor = cons_up_default_function (t, name, needs_virtual_dtor != 0); /* If we couldn't make it work, then pretend we didn't need it. */ *************** *** 3252,3258 **** TYPE_NEEDS_DESTRUCTOR (t) |= TYPE_HAS_DESTRUCTOR (t); - /* Synthesize any needed methods. Note that methods will be synthesized - for anonymous unions; grok_x_components undoes that. */ - if (! fn_fields) nonprivate_method = 1; --- 3321,3324 ---- *************** *** 3272,3276 **** && ! IS_SIGNATURE (t)) { ! tree default_fn = cons_up_default_function (t, name, fields, 2); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; --- 3338,3342 ---- && ! IS_SIGNATURE (t)) { ! tree default_fn = cons_up_default_function (t, name, 2); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; *************** *** 3283,3289 **** /* ARM 12.18: You get either X(X&) or X(const X&), but not both. --Chip */ ! tree default_fn = ! cons_up_default_function (t, name, fields, ! cant_have_const_ctor ? 4 : 3); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; --- 3349,3354 ---- /* ARM 12.18: You get either X(X&) or X(const X&), but not both. --Chip */ ! tree default_fn = cons_up_default_function (t, name, ! 3 + cant_have_const_ctor); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; *************** *** 3299,3305 **** && ! IS_SIGNATURE (t)) { ! tree default_fn = ! cons_up_default_function (t, name, fields, ! no_const_asn_ref ? 6 : 5); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; --- 3364,3369 ---- && ! IS_SIGNATURE (t)) { ! tree default_fn = cons_up_default_function (t, name, ! 5 + no_const_asn_ref); TREE_CHAIN (default_fn) = fn_fields; fn_fields = default_fn; *************** *** 3352,3356 **** tree name; enum access_type access = (enum access_type)TREE_PURPOSE(access_decls); ! int i = 0; tree tmp; --- 3416,3420 ---- tree name; enum access_type access = (enum access_type)TREE_PURPOSE(access_decls); ! int i = TREE_VEC_ELT (method_vec, 0) ? 0 : 1; tree tmp; *************** *** 3460,3463 **** --- 3524,3548 ---- delete_duplicate_fields (fields); + /* Catch function/field name conflict. We don't need to do this for a + signature, since it can only contain the fields constructed in + append_signature_fields. */ + if (! IS_SIGNATURE (t)) + { + int n_methods = method_vec ? TREE_VEC_LENGTH (method_vec) : 0; + for (x = fields; x; x = TREE_CHAIN (x)) + { + tree name = DECL_NAME (x); + int i = /*TREE_VEC_ELT (method_vec, 0) ? 0 : */ 1; + for (; i < n_methods; ++i) + if (DECL_NAME (TREE_VEC_ELT (method_vec, i)) == name) + { + cp_error_at ("data member `%#D' conflicts with", x); + cp_error_at ("function member `%#D'", + TREE_VEC_ELT (method_vec, i)); + break; + } + } + } + /* Now we have the final fieldlist for the data fields. Record it, then lay out the structure or union (including the fields). */ *************** *** 3499,3502 **** --- 3584,3590 ---- for (; uelt; uelt = TREE_CHAIN (uelt)) { + if (TREE_CODE (uelt) != FIELD_DECL) + continue; + DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field); DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field); *************** *** 3553,3556 **** --- 3641,3647 ---- for (; uelt; uelt = TREE_CHAIN (uelt)) { + if (TREE_CODE (uelt) != FIELD_DECL) + continue; + DECL_FIELD_CONTEXT (uelt) = DECL_FIELD_CONTEXT (field); DECL_FIELD_BITPOS (uelt) = DECL_FIELD_BITPOS (field); *************** *** 4635,4643 **** elem = get_first_fn (rhs); while (elem) ! if (TREE_TYPE (elem) != lhstype) elem = DECL_CHAIN (elem); else return elem; ! /* No exact match found, look for a compatible function. */ elem = get_first_fn (rhs); while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 1)) --- 4726,4765 ---- elem = get_first_fn (rhs); while (elem) ! if (! comptypes (lhstype, TREE_TYPE (elem), 1)) elem = DECL_CHAIN (elem); else return elem; ! ! /* No exact match found, look for a compatible template. */ ! { ! tree save_elem = 0; ! for (elem = get_first_fn (rhs); elem; elem = DECL_CHAIN (elem)) ! if (TREE_CODE (elem) == TEMPLATE_DECL) ! { ! int n = TREE_VEC_LENGTH (DECL_TEMPLATE_PARMS (elem)); ! tree *t = (tree *) alloca (sizeof (tree) * n); ! int i, d; ! i = type_unification (DECL_TEMPLATE_PARMS (elem), t, ! TYPE_ARG_TYPES (TREE_TYPE (elem)), ! TYPE_ARG_TYPES (lhstype), &d, 0); ! if (i == 0) ! { ! if (save_elem) ! { ! cp_error ("ambiguous template instantiation converting to `%#T'", lhstype); ! return error_mark_node; ! } ! save_elem = instantiate_template (elem, t); ! /* Check the return type. */ ! if (! comptypes (TREE_TYPE (lhstype), ! TREE_TYPE (TREE_TYPE (save_elem)), 1)) ! save_elem = 0; ! } ! } ! if (save_elem) ! return save_elem; ! } ! ! /* No match found, look for a compatible function. */ elem = get_first_fn (rhs); while (elem && ! comp_target_types (lhstype, TREE_TYPE (elem), 1)) *************** *** 4661,4676 **** return error_mark_node; } - if (TREE_CODE (save_elem) == TEMPLATE_DECL) - { - int ntparms = TREE_VEC_LENGTH - (DECL_TEMPLATE_PARMS (save_elem)); - tree *targs = (tree *) alloca (sizeof (tree) * ntparms); - int i, dummy; - i = type_unification - (DECL_TEMPLATE_PARMS (save_elem), targs, - TYPE_ARG_TYPES (TREE_TYPE (save_elem)), - TYPE_ARG_TYPES (lhstype), &dummy, 0); - save_elem = instantiate_template (save_elem, targs); - } return save_elem; } --- 4783,4786 ---- *************** *** 4865,4874 **** TREE_TYPE (rhs) = lhstype; lhstype = TREE_TYPE (lhstype); ! TREE_OPERAND (rhs, 0) ! = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain); ! if (TREE_OPERAND (rhs, 0) == error_mark_node) ! return error_mark_node; ! ! mark_addressable (TREE_OPERAND (rhs, 0)); return rhs; --- 4975,4986 ---- TREE_TYPE (rhs) = lhstype; lhstype = TREE_TYPE (lhstype); ! { ! tree fn = instantiate_type (lhstype, TREE_OPERAND (rhs, 0), complain); ! if (fn == error_mark_node) ! return error_mark_node; ! mark_addressable (fn); ! TREE_OPERAND (rhs, 0) = fn; ! TREE_CONSTANT (rhs) = staticp (fn); ! } return rhs; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/cp-tree.h gcc-2.6.1/cp/cp-tree.h *** gcc-2.6.0/cp/cp-tree.h Wed Jul 13 07:04:45 1994 --- gcc-2.6.1/cp/cp-tree.h Mon Sep 26 16:09:45 1994 *************** *** 503,508 **** --- 503,512 ---- union tree_node *signature_pointer_to; union tree_node *signature_reference_to; + + int linenum; }; + #define CLASSTYPE_SOURCE_LINE(NODE) (TYPE_LANG_SPECIFIC(NODE)->linenum) + /* Indicates whether or not (and how) a template was expanded for this class. 0=no information yet/non-template class *************** *** 1356,1360 **** NOP_EXPR is used as a special case (see truthvalue_conversion). */ extern void binary_op_error PROTO((enum tree_code)); ! extern tree c_build_type_variant PROTO((tree, int, int)); extern void c_expand_expr_stmt PROTO((tree)); /* Validate the expression after `case' and apply default promotions. */ --- 1360,1364 ---- NOP_EXPR is used as a special case (see truthvalue_conversion). */ extern void binary_op_error PROTO((enum tree_code)); ! extern tree cp_build_type_variant PROTO((tree, int, int)); extern void c_expand_expr_stmt PROTO((tree)); /* Validate the expression after `case' and apply default promotions. */ *************** *** 2012,2016 **** extern void end_catch_block PROTO((void)); extern void expand_throw PROTO((tree)); ! extern void build_exception_table PROTO((void)); extern tree build_throw PROTO((tree)); extern void init_exception_processing PROTO((void)); --- 2016,2020 ---- extern void end_catch_block PROTO((void)); extern void expand_throw PROTO((tree)); ! extern int build_exception_table PROTO((void)); extern tree build_throw PROTO((tree)); extern void init_exception_processing PROTO((void)); *************** *** 2092,2096 **** extern void reinit_parse_for_block PROTO((int, struct obstack *, int)); #endif ! extern tree cons_up_default_function PROTO((tree, tree, tree, int)); extern void check_for_missing_semicolon PROTO((tree)); extern void note_got_semicolon PROTO((tree)); --- 2096,2100 ---- extern void reinit_parse_for_block PROTO((int, struct obstack *, int)); #endif ! extern tree cons_up_default_function PROTO((tree, tree, int)); extern void check_for_missing_semicolon PROTO((tree)); extern void note_got_semicolon PROTO((tree)); *************** *** 2142,2145 **** --- 2146,2150 ---- /* skip report_type_mismatch */ extern char *build_overload_name PROTO((tree, int, int)); + extern tree build_static_name PROTO((tree, tree)); extern tree cplus_exception_name PROTO((tree)); extern tree build_decl_overload PROTO((tree, tree, int)); *************** *** 2255,2259 **** extern tree reverse_path PROTO((tree)); extern tree virtual_member PROTO((tree, tree)); - extern tree virtual_offset PROTO((tree, tree, tree)); extern void debug_binfo PROTO((tree)); extern int decl_list_length PROTO((tree)); --- 2260,2263 ---- *************** *** 2361,2365 **** extern void GNU_xref_start_scope PROTO((HOST_WIDE_INT)); extern void GNU_xref_end_scope PROTO((HOST_WIDE_INT, HOST_WIDE_INT, int, int, int)); ! extern void GNU_xref_def PROTO((tree, char *)); extern void GNU_xref_decl PROTO((tree, tree)); extern void GNU_xref_call PROTO((tree, char *)); --- 2365,2369 ---- extern void GNU_xref_start_scope PROTO((HOST_WIDE_INT)); extern void GNU_xref_end_scope PROTO((HOST_WIDE_INT, HOST_WIDE_INT, int, int, int)); ! extern void GNU_xref_ref PROTO((tree, char *)); extern void GNU_xref_decl PROTO((tree, tree)); extern void GNU_xref_call PROTO((tree, char *)); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/cvt.c gcc-2.6.1/cp/cvt.c *** gcc-2.6.0/cp/cvt.c Tue Jul 5 20:26:31 1994 --- gcc-2.6.1/cp/cvt.c Fri Oct 14 20:31:20 1994 *************** *** 305,309 **** /* Pass along const and volatile down into the type. */ if (TYPE_READONLY (type) || TYPE_VOLATILE (type)) ! target_type = c_build_type_variant (target_type, TYPE_READONLY (type), TYPE_VOLATILE (type)); targ = arg; --- 305,309 ---- /* Pass along const and volatile down into the type. */ if (TYPE_READONLY (type) || TYPE_VOLATILE (type)) ! target_type = cp_build_type_variant (target_type, TYPE_READONLY (type), TYPE_VOLATILE (type)); targ = arg; *************** *** 426,433 **** case PARM_DECL: if (targ == current_class_decl) { error ("address of `this' not available"); ! #if 0 /* This code makes the following core dump the compiler on a sun4, if the code below is used. --- 426,434 ---- case PARM_DECL: + #if 0 if (targ == current_class_decl) { error ("address of `this' not available"); ! /* #if 0 */ /* This code makes the following core dump the compiler on a sun4, if the code below is used. *************** *** 466,479 **** put_var_into_stack (targ); break; ! #else return error_mark_node; ! #endif } /* Fall through. */ case VAR_DECL: case CONST_DECL: ! if (DECL_REGISTER (targ) && !TREE_ADDRESSABLE (targ)) ! warning ("address needed to build reference for `%s', which is declared `register'", ! IDENTIFIER_POINTER (DECL_NAME (targ))); else if (staticp (targ)) literal_flag = 1; --- 467,482 ---- put_var_into_stack (targ); break; ! /* #else */ return error_mark_node; ! /* #endif */ } + #endif /* Fall through. */ case VAR_DECL: case CONST_DECL: ! if (DECL_REGISTER (targ) && !TREE_ADDRESSABLE (targ) ! && !DECL_ARTIFICIAL (targ)) ! cp_warning ("address needed to build reference for `%D', which is declared `register'", ! targ); else if (staticp (targ)) literal_flag = 1; *************** *** 492,495 **** --- 495,500 ---- } + case PREINCREMENT_EXPR: + case PREDECREMENT_EXPR: case MODIFY_EXPR: case INIT_EXPR: *************** *** 632,636 **** int r = TREE_READONLY (expr); int v = TREE_THIS_VOLATILE (expr); ! ttr = c_build_type_variant (TREE_TYPE (expr), r, v); } --- 637,641 ---- int r = TREE_READONLY (expr); int v = TREE_THIS_VOLATILE (expr); ! ttr = cp_build_type_variant (TREE_TYPE (expr), r, v); } *************** *** 1207,1210 **** --- 1212,1218 ---- e = convert_from_reference (e); + if (TREE_CODE (e) == OFFSET_REF) + e = resolve_offset_ref (e); + if (TREE_READONLY_DECL_P (e)) e = decl_constant_value (e); *************** *** 1224,1239 **** return error_mark_node; } ! if (form == OFFSET_TYPE) ! cp_error_at ("pointer-to-member expression object not composed with type `%D' object", ! TYPE_NAME (TYPE_OFFSET_BASETYPE (intype))); ! else if (IS_AGGR_TYPE (intype)) { tree rval; rval = build_type_conversion (CONVERT_EXPR, type, e, 1); ! if (rval) return rval; ! if (code == BOOLEAN_TYPE) ! cp_error ("`%#T' used where a `bool' was expected", intype); ! else ! cp_error ("`%#T' used where an `int' was expected", intype); return error_mark_node; } --- 1232,1242 ---- return error_mark_node; } ! if (IS_AGGR_TYPE (intype)) { tree rval; rval = build_type_conversion (CONVERT_EXPR, type, e, 1); ! if (rval) ! return rval; ! cp_error ("`%#T' used where a `%T' was expected", intype, type); return error_mark_node; } *************** *** 2022,2030 **** else if (TREE_CODE (type) == ENUMERAL_TYPE || type == wchar_type_node) ! type = type_for_size ! (MAX (TYPE_PRECISION (type), TYPE_PRECISION (integer_type_node)), ! (flag_traditional ! || (TYPE_PRECISION (type) >= TYPE_PRECISION (integer_type_node))) ! && TREE_UNSIGNED (type)); else if (C_PROMOTING_INTEGER_TYPE_P (type)) { --- 2025,2038 ---- else if (TREE_CODE (type) == ENUMERAL_TYPE || type == wchar_type_node) ! { ! int precision = MAX (TYPE_PRECISION (type), ! TYPE_PRECISION (integer_type_node)); ! tree totype = type_for_size (precision, 0); ! if (TREE_UNSIGNED (type) ! && ! int_fits_type_p (TYPE_MAX_VALUE (type), totype)) ! type = type_for_size (precision, 1); ! else ! type = totype; ! } else if (C_PROMOTING_INTEGER_TYPE_P (type)) { *************** *** 2041,2044 **** type = double_type_node; ! return c_build_type_variant (type, constp, volatilep); } --- 2049,2052 ---- type = double_type_node; ! return cp_build_type_variant (type, constp, volatilep); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/decl.c gcc-2.6.1/cp/decl.c *** gcc-2.6.0/cp/decl.c Wed Jul 13 07:10:43 1994 --- gcc-2.6.1/cp/decl.c Wed Oct 26 21:17:47 1994 *************** *** 163,166 **** --- 163,168 ---- tree unsigned_wchar_type_node; + tree wchar_decl_node; + tree float_type_node; tree double_type_node; *************** *** 402,405 **** --- 404,412 ---- extern int flag_no_builtin; + /* Nonzero means don't recognize the non-ANSI builtin functions. + -ansi sets this. */ + + extern int flag_no_nonansi_builtin; + /* Nonzero means disable GNU extensions. */ *************** *** 1744,1747 **** --- 1751,1755 ---- d = build_decl (TYPE_DECL, name, type); #endif + SET_DECL_ARTIFICIAL (d); #ifdef DWARF_DEBUGGING_INFO if (write_symbols == DWARF_DEBUG) *************** *** 1779,1782 **** --- 1787,1791 ---- newdecl = 1; d = build_decl (TYPE_DECL, name, type); + SET_DECL_ARTIFICIAL (d); #ifdef DWARF_DEBUGGING_INFO if (write_symbols == DWARF_DEBUG) *************** *** 1982,1990 **** for (i = 0; i < len; i++) { ! tree newarg = TREE_VEC_ELT (newargs, i); ! tree oldarg = TREE_VEC_ELT (oldargs, i); if (TREE_CODE (newarg) != TREE_CODE (oldarg)) return 0; ! else if (TREE_CODE (newarg) == IDENTIFIER_NODE) /* continue */; else if (! comptypes (TREE_TYPE (newarg), TREE_TYPE (oldarg), 1)) --- 1991,1999 ---- for (i = 0; i < len; i++) { ! tree newarg = TREE_VALUE (TREE_VEC_ELT (newargs, i)); ! tree oldarg = TREE_VALUE (TREE_VEC_ELT (oldargs, i)); if (TREE_CODE (newarg) != TREE_CODE (oldarg)) return 0; ! else if (TREE_CODE (newarg) == TYPE_DECL) /* continue */; else if (! comptypes (TREE_TYPE (newarg), TREE_TYPE (oldarg), 1)) *************** *** 2105,2108 **** --- 2114,2118 ---- ; else if (TREE_CODE (olddecl) == FUNCTION_DECL + && DECL_ARTIFICIAL (olddecl) && (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl))) { *************** *** 2189,2195 **** cp_error_at ("previous declaration `%#D' here", olddecl); } ! ! if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), ! TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 2)) { cp_error ("new declaration `%#D'", newdecl); --- 2199,2204 ---- cp_error_at ("previous declaration `%#D' here", olddecl); } ! else if (compparms (TYPE_ARG_TYPES (TREE_TYPE (newdecl)), ! TYPE_ARG_TYPES (TREE_TYPE (olddecl)), 2)) { cp_error ("new declaration `%#D'", newdecl); *************** *** 2200,2203 **** --- 2209,2222 ---- } + if (olddecl == wchar_decl_node) + { + if (pedantic && ! DECL_IN_SYSTEM_HEADER (newdecl)) + cp_pedwarn ("redeclaration of wchar_t as `%T'", + TREE_TYPE (newdecl)); + + /* Throw away the redeclaration. */ + return 1; + } + /* Already complained about this, so don't do so again. */ else if (current_class_type == NULL_TREE *************** *** 2204,2213 **** || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type) { ! /* Since we're doing this before finish_struct can set the ! line number on NEWDECL, we just do a regular error here. */ ! if (DECL_SOURCE_LINE (newdecl) == 0) ! cp_error ("conflicting types for `%#D'", newdecl); ! else ! cp_error_at ("conflicting types for `%#D'", newdecl); cp_error_at ("previous declaration as `%#D'", olddecl); } --- 2223,2227 ---- || IDENTIFIER_ERROR_LOCUS (DECL_ASSEMBLER_NAME (newdecl)) != current_class_type) { ! cp_error ("conflicting types for `%#D'", newdecl); cp_error_at ("previous declaration as `%#D'", olddecl); } *************** *** 2522,2525 **** --- 2536,2541 ---- DECL_TEMPLATE_INSTANTIATIONS (newdecl) = DECL_TEMPLATE_INSTANTIATIONS (olddecl); + if (DECL_CHAIN (newdecl) == NULL_TREE) + DECL_CHAIN (newdecl) = DECL_CHAIN (olddecl); } *************** *** 2528,2531 **** --- 2544,2548 ---- TREE_ASM_WRITTEN (newdecl) = TREE_ASM_WRITTEN (olddecl); DECL_COMMON (newdecl) = DECL_COMMON (olddecl); + DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl); /* Don't really know how much of the language-specific *************** *** 2679,2683 **** else if (TREE_CODE (t) != TREE_CODE (x)) { ! if (TREE_CODE (t) == TYPE_DECL || TREE_CODE (x) == TYPE_DECL) { /* We do nothing special here, because C++ does such nasty --- 2696,2701 ---- else if (TREE_CODE (t) != TREE_CODE (x)) { ! if ((TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)) ! || (TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x))) { /* We do nothing special here, because C++ does such nasty *************** *** 3893,3897 **** if (got_scope != NULL_TREE) { ! if (got_scope == void_type_node) val = IDENTIFIER_GLOBAL_VALUE (name); else if (TREE_CODE (got_scope) == TEMPLATE_TYPE_PARM --- 3911,3917 ---- if (got_scope != NULL_TREE) { ! if (got_scope == error_mark_node) ! return error_mark_node; ! else if (got_scope == void_type_node) val = IDENTIFIER_GLOBAL_VALUE (name); else if (TREE_CODE (got_scope) == TEMPLATE_TYPE_PARM *************** *** 4541,4552 **** endlink)), BUILT_IN_ALLOCA, "alloca"); ! #if 0 ! builtin_function ("alloca", ! build_function_type (ptr_type_node, ! tree_cons (NULL_TREE, ! sizetype, ! endlink)), ! BUILT_IN_ALLOCA, NULL_PTR); ! #endif builtin_function ("__builtin_abs", int_ftype_int, --- 4561,4587 ---- endlink)), BUILT_IN_ALLOCA, "alloca"); ! /* Define alloca, ffs as builtins. ! Declare _exit just to mark it as volatile. */ ! if (! flag_no_builtin && !flag_no_nonansi_builtin) ! { ! temp = builtin_function ("alloca", ! build_function_type (ptr_type_node, ! tree_cons (NULL_TREE, ! sizetype, ! endlink)), ! BUILT_IN_ALLOCA, NULL_PTR); ! /* Suppress error if redefined as a non-function. */ ! DECL_BUILT_IN_NONANSI (temp) = 1; ! temp = builtin_function ("ffs", int_ftype_int, BUILT_IN_FFS, NULL_PTR); ! /* Suppress error if redefined as a non-function. */ ! DECL_BUILT_IN_NONANSI (temp) = 1; ! temp = builtin_function ("_exit", build_function_type (void_type_node, ! int_endlink), ! NOT_BUILT_IN, NULL_PTR); ! TREE_THIS_VOLATILE (temp) = 1; ! TREE_SIDE_EFFECTS (temp) = 1; ! /* Suppress error if redefined as a non-function. */ ! DECL_BUILT_IN_NONANSI (temp) = 1; ! } builtin_function ("__builtin_abs", int_ftype_int, *************** *** 4648,4651 **** --- 4683,4703 ---- builtin_function ("sin", double_ftype_double, BUILT_IN_SIN, NULL_PTR); builtin_function ("cos", double_ftype_double, BUILT_IN_COS, NULL_PTR); + + /* Declare these functions volatile + to avoid spurious "control drops through" warnings. */ + temp = builtin_function ("abort", + build_function_type (void_type_node, endlink), + NOT_BUILT_IN, NULL_PTR); + TREE_THIS_VOLATILE (temp) = 1; + TREE_SIDE_EFFECTS (temp) = 1; + /* Well, these are actually ANSI, but we can't set DECL_BUILT_IN on + them... */ + DECL_BUILT_IN_NONANSI (temp) = 1; + temp = builtin_function ("exit", build_function_type (void_type_node, + int_endlink), + NOT_BUILT_IN, NULL_PTR); + TREE_THIS_VOLATILE (temp) = 1; + TREE_SIDE_EFFECTS (temp) = 1; + DECL_BUILT_IN_NONANSI (temp) = 1; } *************** *** 4709,4712 **** --- 4761,4769 ---- record_builtin_type (RID_WCHAR, "__wchar_t", wchar_type_node); + /* Artificial declaration of wchar_t -- can be bashed */ + wchar_decl_node = build_decl (TYPE_DECL, get_identifier ("wchar_t"), + wchar_type_node); + pushdecl (wchar_decl_node); + /* This is for wide string constants. */ wchar_array_type_node *************** *** 4759,4763 **** = build_array_type (vtable_entry_type, NULL_TREE); layout_type (vtbl_type_node); ! vtbl_type_node = c_build_type_variant (vtbl_type_node, 1, 0); record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node); --- 4816,4820 ---- = build_array_type (vtable_entry_type, NULL_TREE); layout_type (vtbl_type_node); ! vtbl_type_node = cp_build_type_variant (vtbl_type_node, 1, 0); record_builtin_type (RID_MAX, NULL_PTR, vtbl_type_node); *************** *** 4929,4933 **** abort_fndecl ! = define_function ("abort", build_function_type (void_type_node, void_list_node), NOT_BUILT_IN, 0, 0); --- 4986,4990 ---- abort_fndecl ! = define_function ("__pure_virtual", build_function_type (void_type_node, void_list_node), NOT_BUILT_IN, 0, 0); *************** *** 5011,5015 **** { int found_tag = 0; - int warned = 0; tree ob_modifier = NULL_TREE; register tree link; --- 5068,5071 ---- *************** *** 5024,5028 **** if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE) { ! register tree name = TYPE_NAME (value); if (code == ENUMERAL_TYPE && TYPE_SIZE (value) == 0) --- 5080,5084 ---- if (IS_AGGR_TYPE_CODE (code) || code == ENUMERAL_TYPE) { ! my_friendly_assert (TYPE_NAME (value) != NULL_TREE, 261); if (code == ENUMERAL_TYPE && TYPE_SIZE (value) == 0) *************** *** 5029,5062 **** cp_error ("forward declaration of `%#T'", value); ! if (name == NULL_TREE) ! name = lookup_tag_reverse (value, NULL_TREE); ! ! if (name && TREE_CODE (name) == TYPE_DECL) ! name = DECL_NAME (name); ! ! t = lookup_tag (code, name, inner_binding_level, 1); ! ! if (t == NULL_TREE) ! { ! push_obstacks (&permanent_obstack, &permanent_obstack); ! if (IS_AGGR_TYPE_CODE (code)) ! t = make_lang_type (code); ! else ! t = make_node (code); ! pushtag (name, t, 0); ! pop_obstacks (); ! ok_code = code; ! } ! else if (name != NULL_TREE || code == ENUMERAL_TYPE) ! ok_code = code; ! ! if (ok_code != ERROR_MARK) ! found_tag++; ! else ! { ! if (!warned) ! pedwarn ("useless keyword or type name in declaration"); ! warned = 1; ! } } else if (value == ridpointers[(int) RID_STATIC] --- 5085,5091 ---- cp_error ("forward declaration of `%#T'", value); ! t = value; ! ok_code = code; ! found_tag++; } else if (value == ridpointers[(int) RID_STATIC] *************** *** 5098,5127 **** ob_modifier); ! if (ok_code == RECORD_TYPE ! && found_tag == 1 ! && TYPE_LANG_SPECIFIC (t) ! && CLASSTYPE_DECLARED_EXCEPTION (t)) ! { ! if (TYPE_SIZE (t)) ! cp_error ("redeclaration of exception `%T'", t); ! else ! { ! tree ename, decl; ! ! push_obstacks (&permanent_obstack, &permanent_obstack); ! ! pushclass (t, 0); ! ! ename = TYPE_NAME (t); ! if (TREE_CODE (ename) == TYPE_DECL) ! ename = DECL_NAME (ename); ! decl = build_lang_field_decl (VAR_DECL, ename, t); ! ! pop_obstacks (); ! } ! } ! else if (found_tag == 0) pedwarn ("abstract declarator used as declaration"); ! else if (!warned && found_tag > 1) pedwarn ("multiple types in one declaration"); } --- 5127,5133 ---- ob_modifier); ! if (found_tag == 0) pedwarn ("abstract declarator used as declaration"); ! else if (found_tag > 1) pedwarn ("multiple types in one declaration"); } *************** *** 5256,5261 **** && ! DECL_IN_SYSTEM_HEADER (decl)) warn_if_unknown_interface (); ! TREE_PUBLIC (d) = TREE_PUBLIC (decl) = ! flag_external_templates && !interface_unknown; TREE_STATIC (d) = TREE_STATIC (decl); DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl) --- 5262,5266 ---- && ! DECL_IN_SYSTEM_HEADER (decl)) warn_if_unknown_interface (); ! TREE_PUBLIC (d) = TREE_PUBLIC (decl); TREE_STATIC (d) = TREE_STATIC (decl); DECL_EXTERNAL (d) = (DECL_EXTERNAL (decl) *************** *** 5715,5718 **** --- 5720,5731 ---- type = TREE_TYPE (decl); + if (type == error_mark_node) + { + if (current_binding_level == global_binding_level && temporary) + end_temporary_allocation (); + + return; + } + was_incomplete = (DECL_SIZE (decl) == NULL_TREE); *************** *** 5809,5812 **** --- 5822,5829 ---- || (TYPE_LANG_SPECIFIC (type) && IS_SIGNATURE_REFERENCE (type))) { + if (TREE_STATIC (decl)) + make_decl_rtl (decl, NULL_PTR, + current_binding_level == global_binding_level + || pseudo_global_level_p ()); grok_reference_init (decl, type, init, &cleanup); init = NULL_TREE; *************** *** 6316,6322 **** } ! /* Set this to 0 so we can tell whether an aggregate ! which was initialized was ever used. */ ! if (TYPE_NEEDS_CONSTRUCTING (type)) TREE_USED (decl) = 0; --- 6333,6341 ---- } ! /* Set this to 0 so we can tell whether an aggregate which ! was initialized was ever used. Don't do this if it has a ! destructor, so we don't complain about the 'resource ! allocation is initialization' idiom. */ ! if (TYPE_NEEDS_CONSTRUCTING (type) && cleanup == NULL_TREE) TREE_USED (decl) = 0; *************** *** 6793,6796 **** --- 6812,6816 ---- DECL_CONTEXT (decl) = basetype; DECL_CLASS_CONTEXT (decl) = basetype; + DECL_ASSEMBLER_NAME (decl) = build_static_name (basetype, declarator); } else *************** *** 6858,6861 **** --- 6878,6883 ---- /* Let the front-end know this is a pointer to member function. */ TYPE_PTRMEMFUNC_FLAG(t) = 1; + /* and not really an aggregate. */ + IS_AGGR_TYPE (t) = 0; fields[0] = build_lang_field_decl (FIELD_DECL, delta_identifier, *************** *** 7092,7096 **** decl = NULL_TREE; ! if (IDENTIFIER_OPNAME_P (dname)) { if (IDENTIFIER_TYPENAME_P (dname)) --- 7114,7122 ---- decl = NULL_TREE; ! if (! IDENTIFIER_OPNAME_P (dname) ! /* Linux headers use '__op'. Arrgh. */ ! || IDENTIFIER_TYPENAME_P (dname) && ! TREE_TYPE (dname)) ! name = IDENTIFIER_POINTER (dname); ! else { if (IDENTIFIER_TYPENAME_P (dname)) *************** *** 7103,7108 **** name = operator_name_string (dname); } - else - name = IDENTIFIER_POINTER (dname); break; --- 7129,7132 ---- *************** *** 7282,7286 **** } ! for (i = (int) RID_FIRST_MODIFIER; i < (int) RID_MAX; i++) { if (ridpointers[i] == id) --- 7306,7310 ---- } ! for (i = (int) RID_FIRST_MODIFIER; i <= (int) RID_LAST_MODIFIER; i++) { if (ridpointers[i] == id) *************** *** 7522,7525 **** --- 7546,7551 ---- staticp = 0; inlinep = !! RIDBIT_SETP (RID_INLINE, specbits); + #if 0 + /* This sort of redundancy is blessed in a footnote to the Sep 94 WP. */ if (constp > 1) warning ("duplicate `const'"); *************** *** 7526,7529 **** --- 7552,7556 ---- if (volatilep > 1) warning ("duplicate `volatile'"); + #endif virtualp = RIDBIT_SETP (RID_VIRTUAL, specbits); *************** *** 7689,7703 **** } ! if (scanner == IDENTIFIER_AS_LIST (ridpointers [(int) RID_TYPEDEF])) ! { ! if (previous_declspec) ! TREE_CHAIN (previous_declspec) ! = IDENTIFIER_AS_LIST (ridpointers [(int) RID_STATIC]); ! else ! declspecs ! = IDENTIFIER_AS_LIST (ridpointers [(int) RID_STATIC]); ! } else ! TREE_VALUE (scanner) = ridpointers[(int) RID_STATIC]; /* In the recursive call to grokdeclarator we need to know --- 7716,7726 ---- } ! if (previous_declspec) ! TREE_CHAIN (previous_declspec) = TREE_CHAIN (scanner); else ! declspecs = TREE_CHAIN (scanner); ! ! declspecs = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], ! declspecs); /* In the recursive call to grokdeclarator we need to know *************** *** 7708,7711 **** --- 7731,7737 ---- loc_typedecl = grokdeclarator (declarator, declspecs, FIELD, 0, NULL_TREE); + + if (previous_declspec) + TREE_CHAIN (previous_declspec) = scanner; if (loc_typedecl != error_mark_node) *************** *** 7715,7718 **** --- 7741,7747 ---- TREE_SET_CODE (loc_typedecl, TYPE_DECL); + /* This is the same field as DECL_ARGUMENTS, which is set for + function typedefs by the above grokdeclarator. */ + DECL_NESTED_TYPENAME (loc_typedecl) = 0; pi = (int *) permalloc (sizeof (struct lang_decl_flags)); *************** *** 7984,7988 **** type = build_cplus_array_type (type, itype); if (constp || volatilep) ! type = c_build_type_variant (type, constp, volatilep); ctype = NULL_TREE; --- 8013,8017 ---- type = build_cplus_array_type (type, itype); if (constp || volatilep) ! type = cp_build_type_variant (type, constp, volatilep); ctype = NULL_TREE; *************** *** 7993,7996 **** --- 8022,8028 ---- { tree arg_types; + int funcdecl_p; + tree inner_parms = TREE_OPERAND (declarator, 1); + tree inner_decl = TREE_OPERAND (declarator, 0); /* Declaring a function type. *************** *** 8006,8010 **** if (constp || volatilep) { ! type = c_build_type_variant (type, constp, volatilep); if (IS_AGGR_TYPE (type)) build_pointer_type (type); --- 8038,8042 ---- if (constp || volatilep) { ! type = cp_build_type_variant (type, constp, volatilep); if (IS_AGGR_TYPE (type)) build_pointer_type (type); *************** *** 8027,8032 **** --- 8059,8073 ---- } + if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF) + inner_decl = TREE_OPERAND (inner_decl, 1); + + /* Say it's a definition only for the CALL_EXPR + closest to the identifier. */ + funcdecl_p = + inner_decl && TREE_CODE (inner_decl) == IDENTIFIER_NODE; + if (ctype == NULL_TREE && decl_context == FIELD + && funcdecl_p && (friendp == 0 || dname == current_class_name)) ctype = current_class_type; *************** *** 8142,8166 **** inner layer of declarator. */ ! { ! int funcdef_p; ! tree inner_parms = TREE_OPERAND (declarator, 1); ! tree inner_decl = TREE_OPERAND (declarator, 0); ! ! declarator = TREE_OPERAND (declarator, 0); ! ! if (inner_decl && TREE_CODE (inner_decl) == SCOPE_REF) ! inner_decl = TREE_OPERAND (inner_decl, 1); ! ! /* Say it's a definition only for the CALL_EXPR ! closest to the identifier. */ ! funcdef_p = ! (inner_decl && TREE_CODE (inner_decl) == IDENTIFIER_NODE) ! ? funcdef_flag : 0; ! /* FIXME: This is where default args should be fully ! processed. */ ! arg_types = grokparms (inner_parms, funcdef_p); ! } if (declarator) --- 8183,8192 ---- inner layer of declarator. */ ! declarator = TREE_OPERAND (declarator, 0); ! /* FIXME: This is where default args should be fully ! processed. */ ! arg_types = grokparms (inner_parms, funcdecl_p ? funcdef_flag : 0); if (declarator) *************** *** 8217,8221 **** if (! IS_SIGNATURE (type)) { ! type = c_build_type_variant (type, constp, volatilep); if (IS_AGGR_TYPE (type)) build_pointer_type (type); --- 8243,8247 ---- if (! IS_SIGNATURE (type)) { ! type = cp_build_type_variant (type, constp, volatilep); if (IS_AGGR_TYPE (type)) build_pointer_type (type); *************** *** 8512,8516 **** in typenames, fields or parameters. */ if (constp || volatilep) ! type = c_build_type_variant (type, constp, volatilep); /* If the user declares "struct {...} foo" then `foo' will have --- 8538,8542 ---- in typenames, fields or parameters. */ if (constp || volatilep) ! type = cp_build_type_variant (type, constp, volatilep); /* If the user declares "struct {...} foo" then `foo' will have *************** *** 8601,8605 **** error ("`const' or `volatile' specified with signature type"); else ! type = c_build_type_variant (type, constp, volatilep); /* Special case: "friend class foo" looks like a TYPENAME context. */ --- 8627,8631 ---- error ("`const' or `volatile' specified with signature type"); else ! type = cp_build_type_variant (type, constp, volatilep); /* Special case: "friend class foo" looks like a TYPENAME context. */ *************** *** 8683,8687 **** /* Transfer const-ness of array into that of type pointed to. */ type = build_pointer_type ! (c_build_type_variant (TREE_TYPE (type), constp, volatilep)); volatilep = constp = 0; } --- 8709,8713 ---- /* Transfer const-ness of array into that of type pointed to. */ type = build_pointer_type ! (cp_build_type_variant (TREE_TYPE (type), constp, volatilep)); volatilep = constp = 0; } *************** *** 8962,8973 **** TREE_TYPE (type), TYPE_ARG_TYPES (type)); ! /* Record presence of `static'. In C++, `inline' is like `static'. ! Methods of classes should be public, unless we're dropping them ! into some other file, so we don't clear TREE_PUBLIC for them. */ publicp ! = ((ctype ! && CLASSTYPE_INTERFACE_KNOWN (ctype)) ! || !(RIDBIT_SETP (RID_STATIC, specbits) ! || RIDBIT_SETP (RID_INLINE, specbits))); decl = grokfndecl (ctype, type, original_name, --- 8988,8995 ---- TREE_TYPE (type), TYPE_ARG_TYPES (type)); ! /* Record presence of `static'. In C++, `inline' is like `static'. */ publicp ! = !(RIDBIT_SETP (RID_STATIC, specbits) ! || RIDBIT_SETP (RID_INLINE, specbits)); decl = grokfndecl (ctype, type, original_name, *************** *** 8990,8994 **** if (TREE_CODE (type) == METHOD_TYPE) { ! cp_error_at ("cannot declare member function `%D' to have static linkage", decl); illegal_static = 1; } --- 9012,9016 ---- if (TREE_CODE (type) == METHOD_TYPE) { ! cp_pedwarn ("cannot declare member function `%D' to have static linkage", decl); illegal_static = 1; } *************** *** 9792,9795 **** --- 9814,9818 ---- { register tree type_decl = build_decl (TYPE_DECL, ncp, rv); + SET_DECL_ARTIFICIAL (type_decl); #ifdef DWARF_DEBUGGING_INFO /* Mark the TYPE_DECL node created just above as a gratuitous one *************** *** 9940,9985 **** else { - extern tree pending_vtables; struct binding_level *old_b = class_binding_level; - int needs_writing; ref = make_lang_type (code); - /* A signature type will contain the fields of the signature - table. Therefore, it's not only an interface. */ if (tag_code == signature_type) { SET_SIGNATURE (ref); CLASSTYPE_INTERFACE_ONLY (ref) = 0; ! CLASSTYPE_INTERFACE_UNKNOWN (ref) = 0; ! } ! ! /* Record how to set the access of this class's ! virtual functions. If write_virtuals == 2 or 3, then ! inline virtuals are ``extern inline''. */ ! switch (write_virtuals) ! { ! case 0: ! case 1: ! needs_writing = 1; ! break; ! case 2: ! needs_writing = !! value_member (name, pending_vtables); ! break; ! case 3: ! needs_writing = ! CLASSTYPE_INTERFACE_ONLY (ref) ! && CLASSTYPE_INTERFACE_KNOWN (ref); ! break; ! default: ! needs_writing = 0; } - /* Signatures don't have a vtable. As long as we don't have default - implementations, they behave as if `write_virtuals' were 3. */ - if (tag_code == signature_type) - CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0; - else - CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = needs_writing; - #ifdef NONNESTED_CLASSES /* Class types don't nest the way enums do. */ --- 9963,9981 ---- else { struct binding_level *old_b = class_binding_level; ref = make_lang_type (code); if (tag_code == signature_type) { SET_SIGNATURE (ref); + /* Since a signature type will be turned into the type + of signature tables, it's not only an interface. */ CLASSTYPE_INTERFACE_ONLY (ref) = 0; ! SET_CLASSTYPE_INTERFACE_KNOWN (ref); ! /* A signature doesn't have a vtable. */ ! CLASSTYPE_VTABLE_NEEDS_WRITING (ref) = 0; } #ifdef NONNESTED_CLASSES /* Class types don't nest the way enums do. */ *************** *** 10109,10112 **** --- 10105,10109 ---- TREE_VIA_PROTECTED (base_binfo) = via_protected; TREE_VIA_VIRTUAL (base_binfo) = via_virtual; + BINFO_INHERITANCE_CHAIN (base_binfo) = TYPE_BINFO (ref); SET_CLASSTYPE_MARKED (basetype); *************** *** 10210,10213 **** --- 10207,10211 ---- current_local_enum = NULL_TREE; + #if 0 /* This stuff gets cleared in finish_enum anyway. */ if (TYPE_VALUES (enumtype) != NULL_TREE) /* Completely replace its old definition. *************** *** 10222,10226 **** TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); TYPE_SIZE (enumtype) = NULL_TREE; ! fixup_unsigned_type (enumtype); /* We copy this value because enumerated type constants --- 10220,10225 ---- TYPE_PRECISION (enumtype) = TYPE_PRECISION (integer_type_node); TYPE_SIZE (enumtype) = NULL_TREE; ! fixup_signed_type (enumtype); ! #endif /* We copy this value because enumerated type constants *************** *** 10242,10250 **** register tree enumtype, values; { ! register tree pair, tem; ! register HOST_WIDE_INT maxvalue = 0; ! register HOST_WIDE_INT minvalue = 0; ! register HOST_WIDE_INT i; ! /* Calculate the maximum value of any enumerator in this type. */ --- 10241,10245 ---- register tree enumtype, values; { ! register tree minnode, maxnode; /* Calculate the maximum value of any enumerator in this type. */ *************** *** 10251,10323 **** if (values) { /* Speed up the main loop by performing some precalculations */ - - HOST_WIDE_INT value; TREE_TYPE (TREE_VALUE (values)) = enumtype; ! TREE_TYPE (DECL_INITIAL (TREE_VALUE (values))) = enumtype; ! TREE_VALUE (values) = DECL_INITIAL (TREE_VALUE (values)); ! value = TREE_INT_CST_LOW (TREE_VALUE (values)); ! minvalue = maxvalue = value; for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair)) { TREE_TYPE (TREE_VALUE (pair)) = enumtype; ! TREE_TYPE (DECL_INITIAL (TREE_VALUE (pair))) = enumtype; ! TREE_VALUE (pair) = DECL_INITIAL (TREE_VALUE (pair)); ! value = TREE_INT_CST_LOW (TREE_VALUE (pair)); ! if (value > maxvalue) ! maxvalue = value; ! else if (value < minvalue) ! minvalue = value; } } TYPE_VALUES (enumtype) = values; ! if (flag_short_enums) ! { ! /* Determine the precision this type needs, lay it out, and define ! it. */ ! ! /* First reset precision */ ! TYPE_PRECISION (enumtype) = 0; ! ! for (i = maxvalue; i; i >>= 1) ! TYPE_PRECISION (enumtype)++; ! ! if (!TYPE_PRECISION (enumtype)) ! TYPE_PRECISION (enumtype) = 1; ! ! /* Cancel the laying out previously done for the enum type, ! so that fixup_unsigned_type will do it over. */ ! TYPE_SIZE (enumtype) = NULL_TREE; fixup_unsigned_type (enumtype); ! } ! ! TREE_INT_CST_LOW (TYPE_MAX_VALUE (enumtype)) = maxvalue; - /* An enum can have some negative values; then it is signed. */ - if (minvalue < 0) - { - TREE_INT_CST_LOW (TYPE_MIN_VALUE (enumtype)) = minvalue; - TREE_INT_CST_HIGH (TYPE_MIN_VALUE (enumtype)) = -1; - TREE_UNSIGNED (enumtype) = 0; - } if (flag_cadillac) cadillac_finish_enum (enumtype); ! /* Fix up all variant types of this enum type. */ ! for (tem = TYPE_MAIN_VARIANT (enumtype); tem; tem = TYPE_NEXT_VARIANT (tem)) ! { ! TYPE_VALUES (tem) = TYPE_VALUES (enumtype); ! TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype); ! TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype); ! TYPE_SIZE (tem) = TYPE_SIZE (enumtype); ! TYPE_MODE (tem) = TYPE_MODE (enumtype); ! TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype); ! TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype); ! TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype); ! } /* Finish debugging output for this type. */ --- 10246,10327 ---- if (values) { + register tree pair; + register tree value = DECL_INITIAL (TREE_VALUE (values)); + /* Speed up the main loop by performing some precalculations */ TREE_TYPE (TREE_VALUE (values)) = enumtype; ! TREE_TYPE (value) = enumtype; ! TREE_VALUE (values) = value; ! minnode = maxnode = value; for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair)) { + value = DECL_INITIAL (TREE_VALUE (pair)); TREE_TYPE (TREE_VALUE (pair)) = enumtype; ! TREE_TYPE (value) = enumtype; ! TREE_VALUE (pair) = value; ! if (tree_int_cst_lt (maxnode, value)) ! maxnode = value; ! else if (tree_int_cst_lt (value, minnode)) ! minnode = value; } } + else + maxnode = minnode = integer_zero_node; TYPE_VALUES (enumtype) = values; ! { ! int unsignedp = tree_int_cst_sgn (minnode) >= 0; ! int lowprec = min_precision (minnode, unsignedp); ! int highprec = min_precision (maxnode, unsignedp); ! int precision = MAX (lowprec, highprec); ! ! if (! flag_short_enums && precision < TYPE_PRECISION (integer_type_node)) ! precision = TYPE_PRECISION (integer_type_node); ! ! ! /* ! * The following code is unnecessary since the function ! * type_promotes_to deals correctly with promotion of enums of ! * underlying unsigned types to signed integer types. ! * Moreover, it causes an enum bitfield to require one more bit of ! * storage than defined by the ANSI/ISO C++ resolution section r.7.2 ! * which defines the range of an enum. ! */ ! #if 0 ! /* Unlike the C frontend, we prefer signed types. */ ! if (unsignedp && int_fits_type_p (maxnode, type_for_size (precision, 0))) ! unsignedp = 0; ! #endif + TYPE_PRECISION (enumtype) = precision; + TYPE_SIZE (enumtype) = NULL_TREE; + if (unsignedp) fixup_unsigned_type (enumtype); ! else ! fixup_signed_type (enumtype); ! } if (flag_cadillac) cadillac_finish_enum (enumtype); ! { ! register tree tem; ! ! /* Fix up all variant types of this enum type. */ ! for (tem = TYPE_MAIN_VARIANT (enumtype); tem; ! tem = TYPE_NEXT_VARIANT (tem)) ! { ! TYPE_VALUES (tem) = TYPE_VALUES (enumtype); ! TYPE_MIN_VALUE (tem) = TYPE_MIN_VALUE (enumtype); ! TYPE_MAX_VALUE (tem) = TYPE_MAX_VALUE (enumtype); ! TYPE_SIZE (tem) = TYPE_SIZE (enumtype); ! TYPE_MODE (tem) = TYPE_MODE (enumtype); ! TYPE_PRECISION (tem) = TYPE_PRECISION (enumtype); ! TYPE_ALIGN (tem) = TYPE_ALIGN (enumtype); ! TREE_UNSIGNED (tem) = TREE_UNSIGNED (enumtype); ! } ! } /* Finish debugging output for this type. */ *************** *** 10679,10683 **** If it belongs to someone else's interface, it is also external. It doesn't matter whether it's inline or not. */ ! if (interface_unknown == 0) { TREE_PUBLIC (decl1) = 1; --- 10683,10688 ---- If it belongs to someone else's interface, it is also external. It doesn't matter whether it's inline or not. */ ! if (interface_unknown == 0 ! && ! TREE_PUBLIC (decl1)) { TREE_PUBLIC (decl1) = 1; *************** *** 10686,10691 **** || (DECL_INLINE (decl1) && ! flag_implement_inlines)); } - else if (DECL_EXPLICIT_INSTANTIATION (decl1)) - /* PUBLIC and EXTERNAL set by do_*_instantiation */; else { --- 10691,10694 ---- *************** *** 10696,10700 **** DECL_EXTERNAL (decl1) = current_extern_inline; ! DECL_DEFER_OUTPUT (decl1) = DECL_INLINE (decl1); } --- 10699,10706 ---- DECL_EXTERNAL (decl1) = current_extern_inline; ! DECL_DEFER_OUTPUT (decl1) ! = DECL_INLINE (decl1) && ! TREE_PUBLIC (decl1) ! && (DECL_FUNCTION_MEMBER_P (decl1) ! || DECL_TEMPLATE_INSTANTIATION (decl1)); } *************** *** 11024,11080 **** } - #if 0 - /* Generate code for default X() constructor. */ - static void - build_default_constructor (fndecl) - tree fndecl; - { - int i = CLASSTYPE_N_BASECLASSES (current_class_type); - tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); - tree fields = TYPE_FIELDS (current_class_type); - tree binfos = TYPE_BINFO_BASETYPES (current_class_type); - - if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)) - parm = TREE_CHAIN (parm); - parm = DECL_REFERENCE_SLOT (parm); - - while (--i >= 0) - { - tree basetype = TREE_VEC_ELT (binfos, i); - if (TYPE_HAS_INIT_REF (basetype)) - { - tree name = TYPE_NAME (basetype); - if (TREE_CODE (name) == TYPE_DECL) - name = DECL_NAME (name); - current_base_init_list = tree_cons (name, parm, current_base_init_list); - } - } - for (; fields; fields = TREE_CHAIN (fields)) - { - tree name, init; - if (TREE_STATIC (fields)) - continue; - if (TREE_CODE (fields) != FIELD_DECL) - continue; - if (DECL_NAME (fields)) - { - if (VFIELD_NAME_P (DECL_NAME (fields))) - continue; - if (VBASE_NAME_P (DECL_NAME (fields))) - continue; - - /* True for duplicate members. */ - if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields) - continue; - } - - init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields); - init = build_tree_list (NULL_TREE, init); - - current_member_init_list - = tree_cons (DECL_NAME (fields), init, current_member_init_list); - } - } - #endif /* Finish up a function declaration and compile that function --- 11030,11033 ---- *************** *** 11530,11541 **** can_reach_end = 0; - /* ??? Compensate for Sun brain damage in dealing with data segments - of PIC code. */ - if (flag_pic - && (DECL_CONSTRUCTOR_P (fndecl) - || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl))) - && CLASSTYPE_NEEDS_VIRTUAL_REINIT (TYPE_METHOD_BASETYPE (fntype))) - DECL_INLINE (fndecl) = 0; - if (DECL_EXTERNAL (fndecl) /* This function is just along for the ride. If we can make --- 11483,11486 ---- *************** *** 11543,11547 **** && (DECL_INLINE (fndecl) == 0 || flag_no_inline ! || function_cannot_inline_p (fndecl))) { extern int rtl_dump_and_exit; --- 11488,11499 ---- && (DECL_INLINE (fndecl) == 0 || flag_no_inline ! || function_cannot_inline_p (fndecl) ! /* ??? Compensate for Sun brain damage in dealing with ! data segments of PIC code. */ ! || (flag_pic ! && (DECL_CONSTRUCTOR_P (fndecl) ! || DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (fndecl))) ! && CLASSTYPE_NEEDS_VIRTUAL_REINIT (TYPE_METHOD_BASETYPE (fntype))))) ! { extern int rtl_dump_and_exit; *************** *** 11565,11570 **** } ! if (DECL_INLINE (fndecl) ! && !TREE_ASM_WRITTEN (fndecl) && DECL_FUNCTION_MEMBER_P (fndecl)) { mark_inline_for_output (fndecl); --- 11517,11522 ---- } ! if (DECL_INLINE (fndecl) && !TREE_ASM_WRITTEN (fndecl) ! && DECL_DEFER_OUTPUT (fndecl)) { mark_inline_for_output (fndecl); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/decl2.c gcc-2.6.1/cp/decl2.c *** gcc-2.6.0/cp/decl2.c Sat Jul 9 03:11:40 1994 --- gcc-2.6.1/cp/decl2.c Wed Oct 26 21:19:38 1994 *************** *** 85,88 **** --- 85,93 ---- int flag_no_builtin; + /* Nonzero means don't recognize the non-ANSI builtin functions. + -ansi sets this. */ + + int flag_no_nonansi_builtin; + /* Nonzero means do some things the same way PCC does. */ *************** *** 208,211 **** --- 213,222 ---- int warn_extern_inline; + /* Non-zero means warn when the compiler will reorder code. */ + int warn_reorder; + + /* Non-zero means warn when sysnthesis behavior differs from Cfront's. */ + int warn_synth; + /* Nonzero means `$' can be in an identifier. See cccp.c for reasons why this breaks some obscure ANSI C programs. */ *************** *** 321,324 **** --- 332,338 ---- int flag_conserve_space; + /* Nonzero if we want to obey access control semantics. */ + int flag_access_control = 1; + /* Table of language-dependent -f options. STRING is the option name. VARIABLE is the address of the variable. *************** *** 362,365 **** --- 376,381 ---- {"vtable-thunks", &flag_vtable_thunks, 1}, {"short-temps", &flag_short_temps, 1}, + {"access-control", &flag_access_control, 1}, + {"nonansi-builtins", &flag_no_nonansi_builtin, 0} }; *************** *** 448,451 **** --- 464,471 ---- found = 1; } + else if (!strcmp (p, "ansi-overloading")) + { + warning ("-fansi-overloading is no longer meaningful"); + } else for (j = 0; !found && j < sizeof (lang_f_options) / sizeof (lang_f_options[0]); *************** *** 512,515 **** --- 532,539 ---- else if (!strcmp (p, "extern-inline")) warn_extern_inline = setting; + else if (!strcmp (p, "reorder")) + warn_reorder = setting; + else if (!strcmp (p, "synth")) + warn_synth = setting; else if (!strcmp (p, "comment")) ; /* cpp handles this one. */ *************** *** 538,541 **** --- 562,566 ---- warn_uninitialized = (setting ? 2 : 0); warn_template_debugging = setting; + warn_reorder = setting; } *************** *** 545,549 **** } else if (!strcmp (p, "-ansi")) ! flag_no_asm = 1, dollars_in_ident = 0, flag_ansi = 1; #ifdef SPEW_DEBUG /* Undocumented, only ever used when you're invoking cc1plus by hand, since --- 570,575 ---- } else if (!strcmp (p, "-ansi")) ! flag_no_asm = 1, dollars_in_ident = 0, flag_no_nonansi_builtin = 1, ! flag_ansi = 1; #ifdef SPEW_DEBUG /* Undocumented, only ever used when you're invoking cc1plus by hand, since *************** *** 984,988 **** && TYPE_OVERLOADS_ARRAY_REF (type)) return build_opfncall (ARRAY_REF, LOOKUP_NORMAL, ! array_expr, index_exp, NULL_TREE); /* Otherwise, create an ARRAY_REF for a pointer or array type. */ --- 1010,1014 ---- && TYPE_OVERLOADS_ARRAY_REF (type)) return build_opfncall (ARRAY_REF, LOOKUP_NORMAL, ! array_expr, index_exp, NULL_TREE); /* Otherwise, create an ARRAY_REF for a pointer or array type. */ *************** *** 1001,1015 **** type = TREE_TYPE (type); ! if (TYPE_LANG_SPECIFIC (type) ! && TYPE_OVERLOADS_ARRAY_REF (type)) ! error ("array expression backwards"); ! else if (TREE_CODE (type) == POINTER_TYPE ! || TREE_CODE (type) == ARRAY_TYPE) return build_array_ref (index_exp, array_expr); - else - error("`[]' applied to non-pointer type"); ! /* We gave an error, so give an error. Huh? */ ! return error_mark_node; } --- 1027,1038 ---- type = TREE_TYPE (type); ! if (TREE_CODE (type) == POINTER_TYPE ! || TREE_CODE (type) == ARRAY_TYPE) return build_array_ref (index_exp, array_expr); ! /* The expression E1[E2] is identical (by definition) to *((E1)+(E2)). */ ! return build_indirect_ref (build_binary_op (PLUS_EXPR, array_expr, ! index_exp, 1), ! "array indexing"); } *************** *** 1058,1066 **** } ! /* You can't delete a pointer to constant. */ ! if (code == POINTER_TYPE && TREE_READONLY (TREE_TYPE (type))) { ! error ("`const *' cannot be deleted"); ! return error_mark_node; } --- 1081,1098 ---- } ! if (code == POINTER_TYPE) { ! /* You can't delete a pointer to constant. */ ! if (TREE_READONLY (TREE_TYPE (type))) ! { ! error ("`const *' cannot be deleted"); ! return error_mark_node; ! } ! /* You also can't delete functions. */ ! if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE) ! { ! error ("cannot delete a function"); ! return error_mark_node; ! } } *************** *** 1129,1139 **** if (methods != end) ! cp_error ("argument list for `%D' does not match any in class `%T'", ! fn_name, ctype); else { methods = 0; ! cp_error ("no `%D' member function declared in class `%T'", ! fn_name, ctype); } --- 1161,1171 ---- if (methods != end) ! cp_error ("argument list for `%#D' does not match any in class `%T'", ! function, ctype); else { methods = 0; ! cp_error ("no `%#D' member function declared in class `%T'", ! function, ctype); } *************** *** 1302,1318 **** if (asmspec == 0 && current_class_type) { - tree name; - char *buf, *buf2; - - buf2 = build_overload_name (current_class_type, 1, 1); - buf = (char *)alloca (IDENTIFIER_LENGTH (DECL_NAME (value)) - + sizeof (STATIC_NAME_FORMAT) - + strlen (buf2)); - sprintf (buf, STATIC_NAME_FORMAT, buf2, - IDENTIFIER_POINTER (DECL_NAME (value))); - name = get_identifier (buf); TREE_PUBLIC (value) = 1; DECL_INITIAL (value) = error_mark_node; ! DECL_ASSEMBLER_NAME (value) = name; } pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics); --- 1334,1341 ---- if (asmspec == 0 && current_class_type) { TREE_PUBLIC (value) = 1; DECL_INITIAL (value) = error_mark_node; ! DECL_ASSEMBLER_NAME (value) ! = build_static_name (current_class_type, DECL_NAME (value)); } pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics); *************** *** 1367,1373 **** --- 1390,1398 ---- return void_type_node; + #if 0 /* Just because a fn is declared doesn't mean we'll try to define it. */ if (current_function_decl && ! IS_SIGNATURE (current_class_type)) cp_error ("method `%#D' of local class must be defined in class body", value); + #endif DECL_IN_AGGR_P (value) = 1; *************** *** 2068,2074 **** } ! while (field) { ! tree decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field)); /* tell `pushdecl' that this is not tentative. */ DECL_INITIAL (decl) = error_mark_node; --- 2093,2103 ---- } ! for (; field; field = TREE_CHAIN (field)) { ! tree decl; ! if (TREE_CODE (field) != FIELD_DECL) ! continue; ! ! decl = build_decl (VAR_DECL, DECL_NAME (field), TREE_TYPE (field)); /* tell `pushdecl' that this is not tentative. */ DECL_INITIAL (decl) = error_mark_node; *************** *** 2097,2106 **** elems = tree_cons (NULL_TREE, decl, elems); TREE_TYPE (elems) = type; - field = TREE_CHAIN (field); } if (static_p) { ! make_decl_rtl (main_decl, 0, global_bindings_p ()); ! DECL_RTL (anon_union_decl) = DECL_RTL (main_decl); } --- 2126,2142 ---- elems = tree_cons (NULL_TREE, decl, elems); TREE_TYPE (elems) = type; } if (static_p) { ! if (main_decl) ! { ! make_decl_rtl (main_decl, 0, global_bindings_p ()); ! DECL_RTL (anon_union_decl) = DECL_RTL (main_decl); ! } ! else ! { ! warning ("anonymous union with no members"); ! return; ! } } *************** *** 2523,2526 **** --- 2559,2593 ---- } + /* Determines the proper settings of TREE_PUBLIC and DECL_EXTERNAL for an + inline function at end-of-file. */ + + void + import_export_inline (decl) + tree decl; + { + if (TREE_PUBLIC (decl)) + return; + + /* If an explicit instantiation doesn't have TREE_PUBLIC set, it was with + 'extern'. */ + if (DECL_EXPLICIT_INSTANTIATION (decl) + || (DECL_IMPLICIT_INSTANTIATION (decl) && ! flag_implicit_templates)) + { + TREE_PUBLIC (decl) = 1; + DECL_EXTERNAL (decl) = 1; + } + else if (DECL_FUNCTION_MEMBER_P (decl)) + { + tree ctype = DECL_CLASS_CONTEXT (decl); + if (CLASSTYPE_INTERFACE_KNOWN (ctype)) + { + TREE_PUBLIC (decl) = 1; + DECL_EXTERNAL (decl) + = (CLASSTYPE_INTERFACE_ONLY (ctype) + || (DECL_INLINE (decl) && ! flag_implement_inlines)); + } + } + } + extern int parse_time, varconst_time; *************** *** 2542,2548 **** tree vars = static_aggregates; int needs_cleaning = 0, needs_messing_up = 0; - build_exception_table (); - if (flag_detailed_statistics) dump_tree_statistics (); --- 2609,2614 ---- tree vars = static_aggregates; int needs_cleaning = 0, needs_messing_up = 0; + int have_exception_handlers = build_exception_table (); if (flag_detailed_statistics) dump_tree_statistics (); *************** *** 2637,2641 **** /* Must do this while we think we are at the top level. */ vars = nreverse (static_aggregates); ! if (vars != NULL_TREE) { fnname = get_file_function_name ('I'); --- 2703,2707 ---- /* Must do this while we think we are at the top level. */ vars = nreverse (static_aggregates); ! if (vars != NULL_TREE || have_exception_handlers) { fnname = get_file_function_name ('I'); *************** *** 2649,2652 **** --- 2715,2721 ---- expand_start_bindings (0); + if (have_exception_handlers) + register_exception_table (); + while (vars) { *************** *** 2713,2717 **** } if (IS_AGGR_TYPE (TREE_TYPE (decl)) - || init == 0 || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) expand_aggr_init (decl, init, 0); --- 2782,2785 ---- *************** *** 2829,2843 **** if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0) continue; ! if (DECL_FUNCTION_MEMBER_P (decl) && !TREE_PUBLIC (decl)) ! { ! tree ctype = DECL_CLASS_CONTEXT (decl); ! if (CLASSTYPE_INTERFACE_KNOWN (ctype)) ! { ! TREE_PUBLIC (decl) = 1; ! DECL_EXTERNAL (decl) ! = (CLASSTYPE_INTERFACE_ONLY (ctype) ! || (DECL_INLINE (decl) && ! flag_implement_inlines)); ! } ! } if (TREE_PUBLIC (decl) || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) --- 2897,2901 ---- if (TREE_ASM_WRITTEN (decl) || DECL_SAVED_INSNS (decl) == 0) continue; ! import_export_inline (decl); if (TREE_PUBLIC (decl) || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)) *************** *** 2844,2850 **** || flag_keep_inline_functions) { ! if (DECL_EXTERNAL (decl) ! || (DECL_IMPLICIT_INSTANTIATION (decl) ! && ! flag_implicit_templates)) assemble_external (decl); else --- 2902,2906 ---- || flag_keep_inline_functions) { ! if (DECL_EXTERNAL (decl)) assemble_external (decl); else *************** *** 2873,2879 **** && ! TREE_ASM_WRITTEN (decl)) { ! if (DECL_EXTERNAL (decl) ! || (DECL_IMPLICIT_INSTANTIATION (decl) ! && ! flag_implicit_templates)) assemble_external (decl); else --- 2929,2933 ---- && ! TREE_ASM_WRITTEN (decl)) { ! if (DECL_EXTERNAL (decl)) assemble_external (decl); else diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/errfn.c gcc-2.6.1/cp/errfn.c *** gcc-2.6.0/cp/errfn.c Thu May 19 16:16:28 1994 --- gcc-2.6.1/cp/errfn.c Thu Aug 18 16:47:45 1994 *************** *** 31,34 **** --- 31,39 ---- extern cp_printer * cp_printers[256]; + /* Whether or not we should try to be quiet for errors and warnings; this is + used to avoid being too talkative about problems with tentative choices + when we're computing the conversion costs for a method call. */ + int cp_silent = 0; + typedef void errorfn (); /* deliberately vague */ *************** *** 151,155 **** { extern errorfn error; ! cp_thing (error, 0, format, arglist); } --- 156,161 ---- { extern errorfn error; ! if (! cp_silent) ! cp_thing (error, 0, format, arglist); } *************** *** 160,164 **** { extern errorfn warning; ! cp_thing (warning, 0, format, arglist); } --- 166,171 ---- { extern errorfn warning; ! if (! cp_silent) ! cp_thing (warning, 0, format, arglist); } *************** *** 169,173 **** { extern errorfn pedwarn; ! cp_thing (pedwarn, 0, format, arglist); } --- 176,181 ---- { extern errorfn pedwarn; ! if (! cp_silent) ! cp_thing (pedwarn, 0, format, arglist); } *************** *** 178,182 **** { extern errorfn compiler_error; ! cp_thing (compiler_error, 0, format, arglist); } --- 186,191 ---- { extern errorfn compiler_error; ! if (! cp_silent) ! cp_thing (compiler_error, 0, format, arglist); } *************** *** 196,200 **** { extern errorfn error_with_file_and_line; ! cp_thing (error_with_file_and_line, 1, format, arglist); } --- 205,210 ---- { extern errorfn error_with_file_and_line; ! if (! cp_silent) ! cp_thing (error_with_file_and_line, 1, format, arglist); } *************** *** 205,209 **** { extern errorfn warning_with_file_and_line; ! cp_thing (warning_with_file_and_line, 1, format, arglist); } --- 215,220 ---- { extern errorfn warning_with_file_and_line; ! if (! cp_silent) ! cp_thing (warning_with_file_and_line, 1, format, arglist); } *************** *** 214,217 **** { extern errorfn pedwarn_with_file_and_line; ! cp_thing (pedwarn_with_file_and_line, 1, format, arglist); } --- 225,229 ---- { extern errorfn pedwarn_with_file_and_line; ! if (! cp_silent) ! cp_thing (pedwarn_with_file_and_line, 1, format, arglist); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/error.c gcc-2.6.1/cp/error.c *** gcc-2.6.0/cp/error.c Fri Jun 3 17:36:26 1994 --- gcc-2.6.1/cp/error.c Mon Sep 26 16:11:17 1994 *************** *** 105,108 **** --- 105,110 ---- if (TYPE_READONLY (t)) OB_PUTS ("const"); + if (TYPE_READONLY (t) && TYPE_VOLATILE (t)) + OB_PUTC (' '); if (TYPE_VOLATILE (t)) OB_PUTS ("volatile"); *************** *** 570,574 **** /* Don't say 'typedef class A' */ tree type = TREE_TYPE (t); ! if (IS_AGGR_TYPE (type) && ! TYPE_PTRMEMFUNC_P (type) && type == TYPE_MAIN_VARIANT (type)) { --- 572,577 ---- /* Don't say 'typedef class A' */ tree type = TREE_TYPE (t); ! if (((IS_AGGR_TYPE (type) && ! TYPE_PTRMEMFUNC_P (type)) ! || TREE_CODE (type) == ENUMERAL_TYPE) && type == TYPE_MAIN_VARIANT (type)) { *************** *** 667,671 **** { tree args = DECL_TEMPLATE_PARMS (t); ! int i, len = TREE_VEC_LENGTH (args); OB_PUTS ("template <"); for (i = 0; i < len; i++) --- 670,674 ---- { tree args = DECL_TEMPLATE_PARMS (t); ! int i, len = args ? TREE_VEC_LENGTH (args) : 0; OB_PUTS ("template <"); for (i = 0; i < len; i++) *************** *** 672,685 **** { tree arg = TREE_VEC_ELT (args, i); ! if (TREE_CODE (arg) == IDENTIFIER_NODE) { OB_PUTS ("class "); ! OB_PUTID (arg); } else dump_decl (arg, 1); OB_PUTC2 (',', ' '); } ! OB_UNPUT (2); OB_PUTC2 ('>', ' '); --- 675,698 ---- { tree arg = TREE_VEC_ELT (args, i); ! tree defval = TREE_PURPOSE (arg); ! arg = TREE_VALUE (arg); ! if (TREE_CODE (arg) == TYPE_DECL) { OB_PUTS ("class "); ! OB_PUTID (DECL_NAME (arg)); } else dump_decl (arg, 1); + + if (defval) + { + OB_PUTS (" = "); + dump_decl (defval, 1); + } + OB_PUTC2 (',', ' '); } ! if (len != 0) ! OB_UNPUT (2); OB_PUTC2 ('>', ' '); *************** *** 1220,1223 **** --- 1233,1244 ---- } + case TREE_LIST: + if (TREE_VALUE (t) && TREE_CODE (TREE_VALUE (t)) == FUNCTION_DECL) + { + OB_PUTID (DECL_NAME (TREE_VALUE (t))); + break; + } + /* else fall through */ + /* This list is incomplete, but should suffice for now. It is very important that `sorry' does not call *************** *** 1332,1341 **** tree t; { if (TREE_CODE (t) == PARM_DECL) ! return DECL_SOURCE_LINE (DECL_CONTEXT (t)); ! else if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') ! return DECL_SOURCE_LINE (TYPE_NAME (t)); else ! return DECL_SOURCE_LINE (t); } --- 1353,1376 ---- tree t; { + int line = 0; if (TREE_CODE (t) == PARM_DECL) ! line = DECL_SOURCE_LINE (DECL_CONTEXT (t)); ! if (TREE_CODE (t) == TYPE_DECL && DECL_ARTIFICIAL (t)) ! t = TREE_TYPE (t); ! ! if (TREE_CODE_CLASS (TREE_CODE (t)) == 't') ! { ! if (IS_AGGR_TYPE (t)) ! line = CLASSTYPE_SOURCE_LINE (t); ! else ! line = DECL_SOURCE_LINE (TYPE_NAME (t)); ! } else ! line = DECL_SOURCE_LINE (t); ! ! if (line == 0) ! return lineno; ! ! return line; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/except.c gcc-2.6.1/cp/except.c *** gcc-2.6.0/cp/except.c Thu Jul 7 00:17:42 1994 --- gcc-2.6.1/cp/except.c Mon Oct 17 19:01:27 1994 *************** *** 60,68 **** void - build_exception_table () - { - } - - void expand_exception_blocks () { --- 60,63 ---- *************** *** 181,207 **** char label[100]; ! fprintf (file, "\t%s\t ", ASM_LONG); ! if (GET_CODE (start_label) == CODE_LABEL) ! { ! ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (start_label)); ! assemble_name (file, label); ! } ! else if (GET_CODE (start_label) == SYMBOL_REF) ! { ! fprintf (stderr, "YYYYYYYYYEEEEEEEESSSSSSSSSSSS!!!!!!!!!!\n"); ! assemble_name (file, XSTR (start_label, 0)); ! } ! putc ('\n', file); ! ! fprintf (file, "\t%s\t ", ASM_LONG); ! ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (end_label)); ! assemble_name (file, label); ! putc ('\n', file); ! ! fprintf (file, "\t%s\t ", ASM_LONG); ! ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (eh_label)); ! assemble_name (file, label); ! putc ('\n', file); ! putc ('\n', file); /* blank line */ } --- 176,182 ---- char label[100]; ! assemble_integer (start_label, BITS_PER_WORD/BITS_PER_UNIT, 1); ! assemble_integer (end_label, BITS_PER_WORD/BITS_PER_UNIT, 1); ! assemble_integer (eh_label, BITS_PER_WORD/BITS_PER_UNIT, 1); putc ('\n', file); /* blank line */ } *************** *** 1162,1172 **** type = NULL_TREE; ! false_label_rtx = gen_label_rtx (); ! push_label_entry (&false_label_stack, false_label_rtx); ! ! /* This is saved for the exception table. */ push_rtl_perm (); protect_label_rtx = gen_label_rtx (); pop_rtl_from_perm (); push_label_entry (&false_label_stack, protect_label_rtx); --- 1137,1146 ---- type = NULL_TREE; ! /* These are saved for the exception table. */ push_rtl_perm (); + false_label_rtx = gen_label_rtx (); protect_label_rtx = gen_label_rtx (); pop_rtl_from_perm (); + push_label_entry (&false_label_stack, false_label_rtx); push_label_entry (&false_label_stack, protect_label_rtx); *************** *** 1437,1473 **** } ! /* output the exception table */ ! void build_exception_table () { extern FILE *asm_out_file; struct ehEntry *entry; if (! doing_eh (0)) ! return; ! ! exception_section (); ! ! /* Beginning marker for table. */ ! fprintf (asm_out_file, " .global ___EXCEPTION_TABLE__\n"); ! fprintf (asm_out_file, " .align 4\n"); ! fprintf (asm_out_file, "___EXCEPTION_TABLE__:\n"); ! fprintf (asm_out_file, " .word 0, 0, 0\n"); ! while (entry = dequeue_eh_entry (&eh_table_output_queue)) { output_exception_table_entry (asm_out_file, ! entry->start_label, entry->end_label, entry->exception_handler_label); } ! /* Ending marker for table. */ ! fprintf (asm_out_file, " .global ___EXCEPTION_END__\n"); ! fprintf (asm_out_file, "___EXCEPTION_END__:\n"); ! fprintf (asm_out_file, " .word -1, -1, -1\n"); ! } ! /* end of: my-cp-except.c */ ! #endif /* Build a throw expression. */ --- 1411,1470 ---- } + /* end of: my-cp-except.c */ + #endif ! ! /* Output the exception table. ! Return the number of handlers. */ ! int build_exception_table () { + int count = 0; + #ifdef TRY_NEW_EH extern FILE *asm_out_file; struct ehEntry *entry; + tree eh_node_decl; if (! doing_eh (0)) ! return 0; ! while (entry = dequeue_eh_entry (&eh_table_output_queue)) ! { ! if (count == 0) ! { ! exception_section (); ! ! /* Beginning marker for table. */ ! ASM_OUTPUT_ALIGN (asm_out_file, 2); ! ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_TABLE__"); ! fprintf (asm_out_file, " .word 0, 0, 0\n"); ! } ! count++; output_exception_table_entry (asm_out_file, ! entry->start_label, entry->end_label, ! entry->exception_handler_label); } ! if (count) ! { ! /* Ending marker for table. */ ! ASM_OUTPUT_LABEL (asm_out_file, "__EXCEPTION_END__"); ! fprintf (asm_out_file, " .word -1, -1, -1\n"); ! } ! #endif /* TRY_NEW_EH */ ! return count; ! } + void + register_exception_table () + { + #ifdef TRY_NEW_EH + emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__register_exceptions"), 0, + VOIDmode, 1, + gen_rtx (SYMBOL_REF, Pmode, "__EXCEPTION_TABLE__"), + Pmode); + #endif /* TRY_NEW_EH */ + } /* Build a throw expression. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/expr.c gcc-2.6.1/cp/expr.c *** gcc-2.6.0/cp/expr.c Fri May 6 05:23:44 1994 --- gcc-2.6.1/cp/expr.c Wed Oct 26 21:19:39 1994 *************** *** 149,155 **** --- 149,162 ---- if (pcc_struct_return) { + extern int flag_access_control; + int old_ac = flag_access_control; + tree init = build (RTL_EXPR, type, 0, return_target); TREE_ADDRESSABLE (init) = 1; + + flag_access_control = 0; expand_aggr_init (slot, init, 0); + flag_access_control = old_ac; + if (TYPE_NEEDS_DESTRUCTOR (type)) { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/g++.c gcc-2.6.1/cp/g++.c *** gcc-2.6.0/cp/g++.c Mon Jul 11 18:24:32 1994 --- gcc-2.6.1/cp/g++.c Sat Oct 29 07:17:44 1994 *************** *** 41,44 **** --- 41,45 ---- #include #include /* May get R_OK, etc. on some systems. */ + #include /* Defined to the name of the compiler; if using a cross compiler, the *************** *** 79,83 **** #endif ! extern int errno, sys_nerr; #if defined(bsd4_4) || defined(__NetBSD__) extern const char *const sys_errlist[]; --- 80,88 ---- #endif ! #ifndef errno ! extern int errno; ! #endif ! ! extern int sys_nerr; #if defined(bsd4_4) || defined(__NetBSD__) extern const char *const sys_errlist[]; *************** *** 391,395 **** args = (int *) malloc (argc * sizeof (int)); ! bzero (args, argc * sizeof (int)); for (i = 1; i < argc; i++) --- 396,400 ---- args = (int *) malloc (argc * sizeof (int)); ! bzero ((char *) args, argc * sizeof (int)); for (i = 1; i < argc; i++) *************** *** 432,436 **** || strcmp (argv[i], "-Tdata") == 0)) quote = argv[i]; ! else if (((argv[i][2] == '\0' && (char *) strchr ("cSEM", argv[i][1]) != NULL) || strcmp (argv[i], "-MM") == 0)) --- 437,441 ---- || strcmp (argv[i], "-Tdata") == 0)) quote = argv[i]; ! else if (library != NULL && ((argv[i][2] == '\0' && (char *) strchr ("cSEM", argv[i][1]) != NULL) || strcmp (argv[i], "-MM") == 0)) *************** *** 450,454 **** if (saw_speclang) ! continue; /* If the filename ends in .c or .i, put options around it. --- 455,462 ---- if (saw_speclang) ! { ! saw_speclang = 0; ! continue; ! } /* If the filename ends in .c or .i, put options around it. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/gxxint.texi gcc-2.6.1/cp/gxxint.texi *** gcc-2.6.0/cp/gxxint.texi Thu Jul 7 00:17:52 1994 --- gcc-2.6.1/cp/gxxint.texi Thu Sep 29 20:48:49 1994 *************** *** 1200,1205 **** partially constructed objects are not cleaned up. Don't expect exception handling to work right if you optimize, in fact the compiler ! will probably core dump. You can only have one source file worth of ! exception handling code. If two EH regions are the exact same size, the backend cannot tell which one is first. It punts by picking the last one, if they tie. This is usually right. We really should stick in a --- 1200,1204 ---- partially constructed objects are not cleaned up. Don't expect exception handling to work right if you optimize, in fact the compiler ! will probably core dump. If two EH regions are the exact same size, the backend cannot tell which one is first. It punts by picking the last one, if they tie. This is usually right. We really should stick in a *************** *** 1224,1228 **** EH objects make it through unwinding, but are subject to being ! overwritten as they are still past the top of stack. Exceptions in catch handlers now go to outer block. --- 1223,1228 ---- EH objects make it through unwinding, but are subject to being ! overwritten as they are still past the top of stack. Don't throw ! automatic objects if this is a problem. Exceptions in catch handlers now go to outer block. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/init.c gcc-2.6.1/cp/init.c *** gcc-2.6.0/cp/init.c Thu Jun 23 20:52:19 1994 --- gcc-2.6.1/cp/init.c Tue Oct 11 14:19:21 1994 *************** *** 218,221 **** --- 218,222 ---- } } + expand_cleanups_to (NULL_TREE); if (flag_handle_exceptions && TYPE_NEEDS_DESTRUCTOR (type)) cp_warning ("caution, member `%D' may not be destroyed in the presense of an exception during construction", member); *************** *** 227,230 **** --- 228,232 ---- tree t; { + extern int warn_reorder; tree x, member, name, field, init; tree init_list = NULL_TREE; *************** *** 231,239 **** tree fields_to_unmark = NULL_TREE; int found; for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member)) { found = 0; ! for (x = current_member_init_list ; x ; x = TREE_CHAIN (x)) { /* If we cleared this out, then pay no attention to it. */ --- 233,244 ---- tree fields_to_unmark = NULL_TREE; int found; + int last_pos = 0; + tree last_field; for (member = TYPE_FIELDS (t); member ; member = TREE_CHAIN (member)) { + int pos; found = 0; ! for (x = current_member_init_list, pos = 0; x; x = TREE_CHAIN (x), ++pos) { /* If we cleared this out, then pay no attention to it. */ *************** *** 265,268 **** --- 270,284 ---- continue; } + else + { + if (pos < last_pos && warn_reorder) + { + cp_warning_at ("member initializers for `%#D'", last_field); + cp_warning_at (" and `%#D'", field); + warning (" will be re-ordered to match declaration order"); + } + last_pos = pos; + last_field = field; + } init_list = chainon (init_list, *************** *** 501,507 **** member = convert_pointer_to (binfo, current_class_decl); ! expand_aggr_init_1 (t_binfo, 0, build_indirect_ref (member, NULL_PTR), init, ! BINFO_OFFSET_ZEROP (binfo), LOOKUP_COMPLAIN); } --- 517,524 ---- member = convert_pointer_to (binfo, current_class_decl); ! expand_aggr_init_1 (binfo, 0, build_indirect_ref (member, NULL_PTR), init, ! BINFO_OFFSET_ZEROP (binfo), LOOKUP_NORMAL); ! expand_cleanups_to (NULL_TREE); } *************** *** 569,575 **** ref = build_indirect_ref (base, NULL_PTR); ! expand_aggr_init_1 (t_binfo, 0, ref, NULL_TREE, BINFO_OFFSET_ZEROP (base_binfo), ! LOOKUP_COMPLAIN); } } --- 586,593 ---- ref = build_indirect_ref (base, NULL_PTR); ! expand_aggr_init_1 (base_binfo, 0, ref, NULL_TREE, BINFO_OFFSET_ZEROP (base_binfo), ! LOOKUP_NORMAL); ! expand_cleanups_to (NULL_TREE); } } *************** *** 656,664 **** current_member_init_list = NULL_TREE; - /* It is possible for the initializers to need cleanups. - Expand those cleanups now that all the initialization - has been done. */ - expand_cleanups_to (NULL_TREE); - if (! immediately) { --- 674,677 ---- *************** *** 735,738 **** --- 748,752 ---- expand_aggr_init_1 (binfo, exp, ref, init, 0, LOOKUP_COMPLAIN|LOOKUP_SPECULATIVELY); + expand_cleanups_to (NULL_TREE); CLEAR_BINFO_VBASE_INIT_MARKED (binfo); } *************** *** 1118,1122 **** tree itype = init ? TREE_TYPE (init) : NULL_TREE; if (was_const_elts) ! TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type); if (init && TREE_TYPE (init) == NULL_TREE) { --- 1132,1140 ---- tree itype = init ? TREE_TYPE (init) : NULL_TREE; if (was_const_elts) ! { ! TREE_TYPE (exp) = TYPE_MAIN_VARIANT (type); ! if (init) ! TREE_TYPE (init) = TYPE_MAIN_VARIANT (itype); ! } if (init && TREE_TYPE (init) == NULL_TREE) { *************** *** 1140,1144 **** TREE_READONLY (exp) = was_const; TREE_TYPE (exp) = type; ! if (init) TREE_TYPE (init) = itype; return; } --- 1158,1163 ---- TREE_READONLY (exp) = was_const; TREE_TYPE (exp) = type; ! if (init) ! TREE_TYPE (init) = itype; return; } *************** *** 1188,1191 **** --- 1207,1211 ---- { rval = convert_for_initialization (exp, type, init, 0, 0, 0, 0); + TREE_USED (rval) = 1; expand_expr_stmt (rval); return; *************** *** 1393,1397 **** if (TREE_CODE (init) == TARGET_EXPR) { ! if (init_type == type) { if (TREE_CODE (exp) == VAR_DECL --- 1413,1417 ---- if (TREE_CODE (init) == TARGET_EXPR) { ! if (TYPE_MAIN_VARIANT (init_type) == TYPE_MAIN_VARIANT (type)) { if (TREE_CODE (exp) == VAR_DECL *************** *** 1967,1976 **** #endif - fnfields = lookup_fnfields (TYPE_BINFO (type), name, 1); - fields = lookup_field (type, name, 0, 0); - - if (fields == error_mark_node || fnfields == error_mark_node) - return error_mark_node; - if (current_class_type == 0 || get_base_distance (type, current_class_type, 0, &basetypes) == -1) --- 1987,1990 ---- *************** *** 1987,1990 **** --- 2001,2010 ---- decl = C_C_D; + fnfields = lookup_fnfields (basetypes, name, 1); + fields = lookup_field (basetypes, name, 0, 0); + + if (fields == error_mark_node || fnfields == error_mark_node) + return error_mark_node; + /* A lot of this logic is now handled in lookup_field and lookup_fnfield. */ *************** *** 2019,2023 **** extern int flag_save_memoized_contexts; - /* This does not handle access checking yet. */ if (DECL_CHAIN (t) == NULL_TREE || dtor) { --- 2039,2042 ---- *************** *** 2288,2294 **** basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (member)); addr = convert_pointer_to (basetype, addr); ! member = convert (ptr_type_node, build_unary_op (ADDR_EXPR, member, 0)); return build1 (INDIRECT_REF, type, ! build (PLUS_EXPR, ptr_type_node, addr, member)); } else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member))) --- 2307,2315 ---- basetype = TYPE_OFFSET_BASETYPE (TREE_TYPE (member)); addr = convert_pointer_to (basetype, addr); ! member = convert (ptrdiff_type_node, ! build_unary_op (ADDR_EXPR, member, 0)); return build1 (INDIRECT_REF, type, ! build (PLUS_EXPR, build_pointer_type (type), ! addr, member)); } else if (TYPE_PTRMEMFUNC_P (TREE_TYPE (member))) *************** *** 3262,3266 **** } ! return save_expr (rval); } --- 3283,3287 ---- } ! return rval; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/lex.c gcc-2.6.1/cp/lex.c *** gcc-2.6.0/cp/lex.c Wed Jun 15 14:29:07 1994 --- gcc-2.6.1/cp/lex.c Fri Oct 14 20:31:17 1994 *************** *** 76,79 **** --- 76,85 ---- static char *inline_text_firstobj; + /* This obstack is used to hold information about methods to be + synthesized. It should go away when synthesized methods are handled + properly (i.e. only when needed). */ + struct obstack synth_obstack; + static char *synth_firstobj; + int end_of_file; *************** *** 565,568 **** --- 571,576 ---- gcc_obstack_init (&inline_text_obstack); inline_text_firstobj = (char *) obstack_alloc (&inline_text_obstack, 0); + gcc_obstack_init (&synth_obstack); + synth_firstobj = (char *) obstack_alloc (&synth_obstack, 0); /* Start it at 0, because check_newline is called at the very beginning *************** *** 961,973 **** } - #ifdef SPEW_DEBUG - const char * - debug_yytranslate (value) - int value; - { - return yytname[YYTRANSLATE (value)]; - } - - #endif /* Functions and data structures for #pragma interface. --- 969,972 ---- *************** *** 1096,1100 **** do_pending_inlines () { - struct pending_inline *prev = 0, *tail; struct pending_inline *t; --- 1095,1098 ---- *************** *** 1102,1123 **** if (yychar == PRE_PARSED_FUNCTION_DECL) return; ! /* Reverse the pending inline functions, since they were cons'd instead of appended. */ ! ! for (t = pending_inlines; t; t = tail) ! { ! t->deja_vu = 1; ! tail = t->next; ! t->next = prev; ! prev = t; ! } ! /* Reset to zero so that if the inline functions we are currently ! processing define inline functions of their own, that is handled ! correctly. ??? This hasn't been checked in a while. */ ! pending_inlines = 0; ! /* Now start processing the first inline function. */ - t = prev; my_friendly_assert ((t->parm_vec == NULL_TREE) == (t->bindings == NULL_TREE), 226); --- 1100,1164 ---- if (yychar == PRE_PARSED_FUNCTION_DECL) return; ! /* Reverse the pending inline functions, since they were cons'd instead of appended. */ ! { ! struct pending_inline *prev = 0, *tail, *bottom = 0; ! t = pending_inlines; ! pending_inlines = 0; ! ! for (; t; t = tail) ! { ! tail = t->next; ! t->next = prev; ! t->deja_vu = 1; ! prev = t; ! } ! ! /* This kludge should go away when synthesized methods are handled ! properly, i.e. only when needed. */ ! for (t = prev; t; t = t->next) ! { ! if (t->lineno <= 0) ! { ! tree f = t->fndecl; ! DECL_PENDING_INLINE_INFO (f) = 0; ! interface_unknown = t->interface == 1; ! interface_only = t->interface == 0; ! switch (- t->lineno) ! { ! case 0: case 1: ! build_dtor (f); break; ! case 2: ! build_default_constructor (f); break; ! case 3: case 4: ! build_copy_constructor (f); break; ! case 5: case 6: ! build_assign_ref (f); break; ! default: ! ; ! } ! if (tail) ! tail->next = t->next; ! else ! prev = t->next; ! if (! bottom) ! bottom = t; ! } ! else ! tail = t; ! } ! if (bottom) ! { ! obstack_free (&synth_obstack, bottom); ! extract_interface_info (); ! } ! t = prev; ! } ! ! if (t == 0) ! return; ! /* Now start processing the first inline function. */ my_friendly_assert ((t->parm_vec == NULL_TREE) == (t->bindings == NULL_TREE), 226); *************** *** 1661,1666 **** tree ! cons_up_default_function (type, name, fields, kind) ! tree type, name, fields; int kind; { --- 1702,1707 ---- tree ! cons_up_default_function (type, name, kind) ! tree type, name; int kind; { *************** *** 1686,1697 **** /* Default constructor. */ args = void_list_node; - { - if (declspecs) - declspecs = decl_tree_cons (NULL_TREE, - ridpointers [(int) RID_INLINE], - declspecs); - else - declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]); - } break; --- 1727,1730 ---- *************** *** 1701,1708 **** case 4: /* According to ARM $12.8, the default copy ctor will be declared, but ! not defined, unless it's needed. So we mark this as `inline'; that ! way, if it's never used it won't be emitted. */ ! declspecs = build_decl_list (NULL_TREE, ridpointers [(int) RID_INLINE]); ! argtype = build_reference_type (type); args = tree_cons (NULL_TREE, --- 1734,1738 ---- case 4: /* According to ARM $12.8, the default copy ctor will be declared, but ! not defined, unless it's needed. */ argtype = build_reference_type (type); args = tree_cons (NULL_TREE, *************** *** 1710,1714 **** get_identifier ("_ctor_arg")), void_list_node); - default_copy_constructor_body (&func_buf, &func_len, type, fields); break; --- 1740,1743 ---- *************** *** 1718,1726 **** case 6: retref = 1; ! declspecs = ! decl_tree_cons (NULL_TREE, name, ! decl_tree_cons (NULL_TREE, ! ridpointers [(int) RID_INLINE], ! NULL_TREE)); name = ansi_opname [(int) MODIFY_EXPR]; --- 1747,1751 ---- case 6: retref = 1; ! declspecs = build_decl_list (NULL_TREE, name); name = ansi_opname [(int) MODIFY_EXPR]; *************** *** 1731,1735 **** get_identifier ("_ctor_arg")), void_list_node); - default_assign_ref_body (&func_buf, &func_len, type, fields); break; --- 1756,1759 ---- *************** *** 1738,1747 **** } ! if (!func_buf) ! { ! func_len = 2; ! func_buf = obstack_alloc (&inline_text_obstack, func_len); ! strcpy (func_buf, "{}"); ! } TREE_PARMLIST (args) = 1; --- 1762,1767 ---- } ! declspecs = decl_tree_cons (NULL_TREE, ridpointers [(int) RID_INLINE], ! declspecs); TREE_PARMLIST (args) = 1; *************** *** 1752,1756 **** declarator = build_parse_node (ADDR_EXPR, declarator); ! fn = start_method (declspecs, declarator, NULL_TREE); } --- 1772,1776 ---- declarator = build_parse_node (ADDR_EXPR, declarator); ! fn = grokfield (declarator, declspecs, NULL_TREE, NULL_TREE, NULL_TREE); } *************** *** 1758,1801 **** return fn; ! current_base_init_list = NULL_TREE; ! current_member_init_list = NULL_TREE; { struct pending_inline *t; ! ! t = (struct pending_inline *) obstack_alloc (&inline_text_obstack, ! sizeof (struct pending_inline)); ! t->lineno = lineno; ! ! #if 1 ! t->filename = input_filename; ! #else /* This breaks; why? */ ! #define MGMSG "(synthetic code at) " ! t->filename = obstack_alloc (&inline_text_obstack, ! strlen (input_filename) + sizeof (MGMSG) + 1); ! strcpy (t->filename, MGMSG); ! strcat (t->filename, input_filename); ! #endif ! t->token = YYEMPTY; ! t->token_value = 0; ! t->buf = func_buf; ! t->len = func_len; ! t->can_free = 1; ! t->deja_vu = 0; ! if (interface_unknown && processing_template_defn && flag_external_templates && ! DECL_IN_SYSTEM_HEADER (fn)) ! warn_if_unknown_interface (); t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2)); store_pending_inline (fn, t); - if (interface_unknown) - TREE_PUBLIC (fn) = 0; - else - { - TREE_PUBLIC (fn) = 1; - DECL_EXTERNAL (fn) = interface_only; - } } - finish_method (fn); - #ifdef DEBUG_DEFAULT_FUNCTIONS { char *fn_type = NULL; --- 1778,1796 ---- return fn; ! if (CLASSTYPE_TEMPLATE_INSTANTIATION (type)) ! SET_DECL_IMPLICIT_INSTANTIATION (fn); + /* This kludge should go away when synthesized methods are handled + properly, i.e. only when needed. */ { struct pending_inline *t; ! t = (struct pending_inline *) ! obstack_alloc (&synth_obstack, sizeof (struct pending_inline)); ! t->lineno = -kind; ! t->can_free = 0; t->interface = (interface_unknown ? 1 : (interface_only ? 0 : 2)); store_pending_inline (fn, t); } #ifdef DEBUG_DEFAULT_FUNCTIONS { char *fn_type = NULL; *************** *** 1819,1824 **** #endif /* DEBUG_DEFAULT_FUNCTIONS */ - DECL_CLASS_CONTEXT (fn) = TYPE_MAIN_VARIANT (type); - /* Show that this function was generated by the compiler. */ SET_DECL_ARTIFICIAL (fn); --- 1814,1817 ---- *************** *** 1827,1830 **** --- 1820,1824 ---- } + #if 0 /* Used by default_copy_constructor_body. For the anonymous union in TYPE, return the member that is at least as large as the rest *************** *** 2172,2175 **** --- 2166,2170 ---- strcat (*bufp, "{}"); } + #endif /* Heuristic to tell whether the user is missing a semicolon *************** *** 2183,2190 **** yychar = yylex (); ! if (yychar > 255 ! && yychar != SCSPEC ! && yychar != IDENTIFIER ! && yychar != TYPENAME) { if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))) --- 2178,2186 ---- yychar = yylex (); ! if ((yychar > 255 ! && yychar != SCSPEC ! && yychar != IDENTIFIER ! && yychar != TYPENAME) ! || end_of_file) { if (ANON_AGGRNAME_P (TYPE_IDENTIFIER (type))) *************** *** 2192,2197 **** TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct"); else ! error ("semicolon missing after declaration of `%s'", ! TYPE_NAME_STRING (type)); shadow_tag (build_tree_list (0, type)); } --- 2188,2192 ---- TREE_CODE (type) == ENUMERAL_TYPE ? "enum" : "struct"); else ! cp_error ("semicolon missing after declaration of `%T'", type); shadow_tag (build_tree_list (0, type)); } *************** *** 2876,2880 **** { if (entering_c_header) ! warning ("Badly nested C headers from preprocessor"); --pending_lang_change; } --- 2871,2875 ---- { if (entering_c_header) ! warning ("badly nested C headers from preprocessor"); --pending_lang_change; } *************** *** 4204,4208 **** yylval.ttype = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0 ! >> (HOST_BITS_PER_INT - num_bits)), 0); else --- 4199,4203 ---- yylval.ttype = build_int_2 (result & ((unsigned HOST_WIDE_INT) ~0 ! >> (HOST_BITS_PER_WIDE_INT - num_bits)), 0); else *************** *** 4209,4213 **** yylval.ttype = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0 ! >> (HOST_BITS_PER_INT - num_bits)), -1); if (num_chars<=1) --- 4204,4208 ---- yylval.ttype = build_int_2 (result | ~((unsigned HOST_WIDE_INT) ~0 ! >> (HOST_BITS_PER_WIDE_INT - num_bits)), -1); if (num_chars<=1) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/lex.h gcc-2.6.1/cp/lex.h *** gcc-2.6.0/cp/lex.h Fri Jun 3 17:36:53 1994 --- gcc-2.6.1/cp/lex.h Thu Aug 18 16:48:44 1994 *************** *** 59,70 **** RID_FRIEND, RID_VIRTUAL, RID_PUBLIC, RID_PRIVATE, RID_PROTECTED, - RID_SIGNED, RID_EXCEPTION, - RID_RAISES, - RID_AUTO, - RID_MUTABLE, RID_TEMPLATE, RID_SIGNATURE, --- 59,72 ---- RID_FRIEND, RID_VIRTUAL, + RID_SIGNED, + RID_AUTO, + RID_MUTABLE, + + /* This is where grokdeclarator ends its search when setting the specbits. */ + RID_PUBLIC, RID_PRIVATE, RID_PROTECTED, RID_EXCEPTION, RID_TEMPLATE, RID_SIGNATURE, *************** *** 77,80 **** --- 79,83 ---- #define RID_FIRST_MODIFIER RID_EXTERN + #define RID_LAST_MODIFIER RID_MUTABLE /* The type that can represent all values of RIDBIT. */ Only in gcc-2.6.0/cp: lib-except.c diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/method.c gcc-2.6.1/cp/method.c *** gcc-2.6.0/cp/method.c Wed Jul 13 07:50:26 1994 --- gcc-2.6.1/cp/method.c Fri Oct 14 20:31:13 1994 *************** *** 314,317 **** --- 314,318 ---- } + static int numeric_outputed_need_bar; static void build_overload_identifier (); *************** *** 464,470 **** for (i = 0; i < nparms; i++) { ! tree parm = TREE_VEC_ELT (parmlist, i); tree arg = TREE_VEC_ELT (arglist, i); ! if (TREE_CODE (parm) == IDENTIFIER_NODE) { /* This parameter is a type. */ --- 465,471 ---- for (i = 0; i < nparms; i++) { ! tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i)); tree arg = TREE_VEC_ELT (arglist, i); ! if (TREE_CODE (parm) == TYPE_DECL) { /* This parameter is a type. */ *************** *** 477,480 **** --- 478,482 ---- build_overload_name (TREE_TYPE (parm), 0, 0); build_overload_value (parm, arg); + numeric_outputed_need_bar = 1; } } *************** *** 482,485 **** --- 484,492 ---- else { + if (numeric_outputed_need_bar) + { + OB_PUTC ('_'); + numeric_outputed_need_bar = 0; + } icat (IDENTIFIER_LENGTH (name)); OB_PUTID (name); *************** *** 773,776 **** --- 780,784 ---- if (i > 9) OB_PUTC ('_'); + numeric_outputed_need_bar = 0; build_overload_nested_name (TYPE_NAME (parmtype)); } *************** *** 818,821 **** --- 826,841 ---- return (char *)obstack_base (&scratch_obstack); } + + tree + build_static_name (basetype, name) + tree basetype, name; + { + char *basename = build_overload_name (basetype, 1, 1); + char *buf = (char *) alloca (IDENTIFIER_LENGTH (name) + + sizeof (STATIC_NAME_FORMAT) + + strlen (basename)); + sprintf (buf, STATIC_NAME_FORMAT, basename, IDENTIFIER_POINTER (name)); + return get_identifier (buf); + } /* Generate an identifier that encodes the (ANSI) exception TYPE. */ *************** *** 853,858 **** if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST) { ! if (TREE_VALUE (parms) == sizetype ! && TREE_CHAIN (parms) == void_list_node) { if (dname == ansi_opname[(int) NEW_EXPR]) --- 873,881 ---- if (! for_method && parms != NULL_TREE && TREE_CODE (parms) == TREE_LIST) { ! if (dname == ansi_opname[(int) DELETE_EXPR]) ! return get_identifier ("__builtin_delete"); ! else if (dname == ansi_opname[(int) VEC_DELETE_EXPR]) ! return get_identifier ("__builtin_vec_delete"); ! else if (TREE_CHAIN (parms) == void_list_node) { if (dname == ansi_opname[(int) NEW_EXPR]) *************** *** 861,868 **** return get_identifier ("__builtin_vec_new"); } - else if (dname == ansi_opname[(int) DELETE_EXPR]) - return get_identifier ("__builtin_delete"); - else if (dname == ansi_opname[(int) VEC_DELETE_EXPR]) - return get_identifier ("__builtin_vec_delete"); } --- 884,887 ---- *************** *** 902,905 **** --- 921,925 ---- ALLOCATE_TYPEVEC (parms); nofold = 0; + numeric_outputed_need_bar = 0; if (for_method) { *************** *** 1462,1470 **** { tree t = get_first_fn (value); ! while (t) { assemble_external (t); TREE_USED (t) = 1; - t = DECL_CHAIN (t); } } --- 1482,1492 ---- { tree t = get_first_fn (value); ! for (; t; t = DECL_CHAIN (t)) { + if (TREE_CODE (t) == TEMPLATE_DECL) + continue; + assemble_external (t); TREE_USED (t) = 1; } } *************** *** 1946,1948 **** --- 1968,2171 ---- decl_printable_name = save_decl_printable_name; current_function_decl = 0; + } + + /* Code for synthesizing methods which have default semantics defined. */ + + void + build_default_constructor (fndecl) + tree fndecl; + { + start_function (NULL_TREE, fndecl, NULL_TREE, 1); + store_parm_decls (); + setup_vtbl_ptr (); + finish_function (lineno, 0); + } + + /* For the anonymous union in TYPE, return the member that is at least as + large as the rest of the members, so we can copy it. */ + static tree + largest_union_member (type) + tree type; + { + tree f, type_size = TYPE_SIZE (type); + + for (f = TYPE_FIELDS (type); f; f = TREE_CHAIN (f)) + if (simple_cst_equal (DECL_SIZE (f), type_size)) + return f; + + /* We should always find one. */ + my_friendly_abort (323); + return NULL_TREE; + } + + /* Generate code for default X(X&) constructor. */ + void + build_copy_constructor (fndecl) + tree fndecl; + { + tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); + tree t; + + start_function (NULL_TREE, fndecl, NULL_TREE, 1); + store_parm_decls (); + clear_last_expr (); + push_momentary (); + + if (TYPE_USES_VIRTUAL_BASECLASSES (current_class_type)) + parm = TREE_CHAIN (parm); + parm = convert_from_reference (parm); + + if (! TYPE_HAS_COMPLEX_INIT_REF (current_class_type)) + { + t = build (INIT_EXPR, void_type_node, C_C_D, parm); + TREE_SIDE_EFFECTS (t) = 1; + cplus_expand_expr_stmt (t); + } + else + { + tree fields = TYPE_FIELDS (current_class_type); + int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type); + tree binfos = TYPE_BINFO_BASETYPES (current_class_type); + int i; + + for (t = CLASSTYPE_VBASECLASSES (current_class_type); t; + t = TREE_CHAIN (t)) + { + tree basetype = BINFO_TYPE (t); + tree p = convert (build_reference_type (basetype), parm); + p = convert_from_reference (p); + current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype), + p, current_base_init_list); + } + + for (i = 0; i < n_bases; ++i) + { + tree p, basetype = TREE_VEC_ELT (binfos, i); + if (TREE_VIA_VIRTUAL (basetype)) + continue; + + basetype = BINFO_TYPE (basetype); + p = convert (build_reference_type (basetype), parm); + p = convert_from_reference (p); + current_base_init_list = tree_cons (TYPE_NESTED_NAME (basetype), + p, current_base_init_list); + } + for (; fields; fields = TREE_CHAIN (fields)) + { + tree name, init, t; + if (TREE_CODE (fields) != FIELD_DECL) + continue; + if (DECL_NAME (fields)) + { + if (VFIELD_NAME_P (DECL_NAME (fields))) + continue; + if (VBASE_NAME_P (DECL_NAME (fields))) + continue; + + /* True for duplicate members. */ + if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields) + continue; + } + else if ((t = TREE_TYPE (fields)) != NULL_TREE + && TREE_CODE (t) == UNION_TYPE + && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)) + && TYPE_FIELDS (t) != NULL_TREE) + fields = largest_union_member (t); + else + continue; + + init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields); + init = build_tree_list (NULL_TREE, init); + + current_member_init_list + = tree_cons (DECL_NAME (fields), init, current_member_init_list); + } + current_member_init_list = nreverse (current_member_init_list); + setup_vtbl_ptr (); + } + + pop_momentary (); + finish_function (lineno, 0); + } + + void + build_assign_ref (fndecl) + tree fndecl; + { + tree parm = TREE_CHAIN (DECL_ARGUMENTS (fndecl)); + + start_function (NULL_TREE, fndecl, NULL_TREE, 1); + store_parm_decls (); + push_momentary (); + + parm = convert_from_reference (parm); + + if (! TYPE_HAS_COMPLEX_ASSIGN_REF (current_class_type)) + { + tree t = build (MODIFY_EXPR, void_type_node, C_C_D, parm); + TREE_SIDE_EFFECTS (t) = 1; + cplus_expand_expr_stmt (t); + } + else + { + tree fields = TYPE_FIELDS (current_class_type); + int n_bases = CLASSTYPE_N_BASECLASSES (current_class_type); + tree binfos = TYPE_BINFO_BASETYPES (current_class_type); + int i; + + for (i = 0; i < n_bases; ++i) + { + tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i)); + if (TYPE_HAS_ASSIGN_REF (basetype)) + { + tree p = convert (build_reference_type (basetype), parm); + p = convert_from_reference (p); + p = build_member_call (TYPE_NESTED_NAME (basetype), + ansi_opname [MODIFY_EXPR], + build_tree_list (NULL_TREE, p)); + expand_expr_stmt (p); + } + } + for (; fields; fields = TREE_CHAIN (fields)) + { + tree comp, init, t; + if (TREE_CODE (fields) != FIELD_DECL) + continue; + if (DECL_NAME (fields)) + { + if (VFIELD_NAME_P (DECL_NAME (fields))) + continue; + if (VBASE_NAME_P (DECL_NAME (fields))) + continue; + + /* True for duplicate members. */ + if (IDENTIFIER_CLASS_VALUE (DECL_NAME (fields)) != fields) + continue; + } + else if ((t = TREE_TYPE (fields)) != NULL_TREE + && TREE_CODE (t) == UNION_TYPE + && ANON_AGGRNAME_P (TYPE_IDENTIFIER (t)) + && TYPE_FIELDS (t) != NULL_TREE) + fields = largest_union_member (t); + else + continue; + + comp = build (COMPONENT_REF, TREE_TYPE (fields), C_C_D, fields); + init = build (COMPONENT_REF, TREE_TYPE (fields), parm, fields); + + expand_expr_stmt (build_modify_expr (comp, NOP_EXPR, init)); + } + } + c_expand_return (C_C_D); + pop_momentary (); + finish_function (lineno, 0); + } + + void + build_dtor (fndecl) + tree fndecl; + { + start_function (NULL_TREE, fndecl, NULL_TREE, 1); + store_parm_decls (); + finish_function (lineno, 0); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/parse.c gcc-2.6.1/cp/parse.c *** gcc-2.6.0/cp/parse.c Thu Jul 7 01:48:19 1994 --- gcc-2.6.1/cp/parse.c Fri Oct 14 14:51:23 1994 *************** *** 151,155 **** #line 108 "parse.y" typedef union {long itype; tree ttype; char *strtype; enum tree_code code; } YYSTYPE; ! #line 276 "parse.y" /* List of types and structure classes of the current declaration. */ --- 151,155 ---- #line 108 "parse.y" typedef union {long itype; tree ttype; char *strtype; enum tree_code code; } YYSTYPE; ! #line 277 "parse.y" /* List of types and structure classes of the current declaration. */ *************** *** 191,199 **** ! #define YYFINAL 1346 #define YYFLAG -32768 #define YYNTBASE 106 ! #define YYTRANSLATE(x) ((unsigned)(x) <= 336 ? yytranslate[x] : 336) static const char yytranslate[] = { 0, --- 191,199 ---- ! #define YYFINAL 1356 #define YYFLAG -32768 #define YYNTBASE 106 ! #define YYTRANSLATE(x) ((unsigned)(x) <= 336 ? yytranslate[x] : 338) static const char yytranslate[] = { 0, *************** *** 238,313 **** 0, 1, 3, 4, 7, 10, 11, 12, 14, 16, 17, 20, 22, 24, 26, 28, 34, 39, 43, 48, ! 53, 55, 56, 62, 64, 68, 71, 76, 78, 82, ! 84, 88, 89, 95, 96, 102, 103, 109, 110, 116, ! 120, 124, 131, 139, 144, 148, 152, 154, 156, 158, ! 160, 162, 165, 169, 173, 177, 181, 184, 187, 190, ! 193, 196, 198, 202, 207, 211, 217, 222, 226, 230, ! 233, 237, 241, 244, 246, 253, 258, 262, 266, 269, ! 272, 274, 278, 283, 286, 290, 291, 292, 294, 298, ! 301, 305, 307, 312, 315, 320, 323, 328, 331, 333, ! 335, 337, 339, 341, 343, 345, 347, 351, 355, 360, ! 365, 369, 374, 379, 380, 382, 386, 388, 390, 391, ! 398, 399, 401, 402, 405, 407, 409, 411, 413, 415, ! 417, 419, 421, 425, 427, 431, 432, 434, 436, 437, ! 446, 448, 451, 456, 461, 463, 467, 471, 475, 479, ! 481, 483, 485, 486, 490, 493, 496, 499, 502, 505, ! 508, 513, 516, 521, 524, 528, 532, 537, 542, 548, ! 554, 561, 564, 569, 575, 579, 583, 587, 589, 593, ! 596, 600, 605, 607, 610, 616, 618, 623, 628, 633, ! 635, 639, 643, 647, 651, 655, 659, 663, 667, 671, ! 675, 679, 683, 687, 691, 695, 699, 703, 707, 711, ! 717, 721, 725, 727, 730, 734, 736, 738, 740, 742, ! 744, 746, 748, 751, 754, 756, 758, 760, 762, 764, ! 766, 768, 772, 776, 777, 782, 783, 790, 793, 798, ! 801, 804, 806, 811, 813, 821, 829, 837, 845, 850, ! 855, 858, 861, 863, 868, 871, 874, 877, 883, 887, ! 893, 897, 902, 909, 911, 914, 916, 919, 921, 923, ! 925, 928, 929, 932, 935, 939, 943, 947, 951, 955, ! 958, 961, 963, 965, 967, 970, 973, 976, 979, 981, ! 983, 985, 987, 990, 993, 997, 1001, 1006, 1008, 1011, ! 1014, 1016, 1018, 1021, 1024, 1026, 1029, 1032, 1036, 1038, ! 1041, 1043, 1045, 1047, 1052, 1057, 1062, 1067, 1069, 1071, ! 1073, 1075, 1079, 1081, 1085, 1087, 1091, 1092, 1097, 1098, ! 1106, 1111, 1112, 1120, 1125, 1126, 1134, 1139, 1140, 1148, ! 1153, 1154, 1156, 1158, 1161, 1168, 1170, 1174, 1175, 1177, ! 1182, 1189, 1194, 1196, 1198, 1200, 1202, 1204, 1208, 1210, ! 1213, 1217, 1222, 1224, 1226, 1230, 1235, 1242, 1246, 1252, ! 1253, 1261, 1266, 1267, 1274, 1278, 1281, 1284, 1289, 1291, ! 1292, 1294, 1295, 1297, 1299, 1302, 1305, 1308, 1311, 1315, ! 1318, 1321, 1324, 1328, 1332, 1334, 1337, 1338, 1339, 1343, ! 1347, 1350, 1352, 1354, 1355, 1357, 1360, 1362, 1366, 1368, ! 1371, 1373, 1378, 1383, 1385, 1387, 1390, 1393, 1395, 1396, ! 1398, 1403, 1407, 1409, 1412, 1415, 1418, 1421, 1424, 1427, ! 1430, 1433, 1438, 1441, 1443, 1449, 1453, 1454, 1456, 1460, ! 1461, 1463, 1467, 1469, 1471, 1473, 1475, 1480, 1487, 1492, ! 1497, 1504, 1509, 1513, 1518, 1525, 1530, 1535, 1542, 1547, ! 1551, 1553, 1557, 1559, 1563, 1566, 1568, 1575, 1576, 1579, ! 1581, 1584, 1585, 1588, 1592, 1596, 1599, 1602, 1606, 1608, ! 1610, 1612, 1615, 1621, 1627, 1631, 1637, 1642, 1646, 1650, ! 1653, 1655, 1659, 1663, 1666, 1669, 1673, 1675, 1679, 1683, ! 1686, 1689, 1693, 1695, 1701, 1707, 1711, 1717, 1721, 1725, ! 1730, 1734, 1737, 1740, 1742, 1745, 1750, 1755, 1758, 1760, ! 1762, 1764, 1767, 1770, 1773, 1775, 1778, 1780, 1783, 1786, ! 1790, 1792, 1796, 1799, 1803, 1806, 1809, 1813, 1815, 1819, ! 1824, 1828, 1831, 1834, 1836, 1840, 1843, 1846, 1848, 1851, ! 1855, 1857, 1861, 1863, 1869, 1873, 1878, 1882, 1887, 1890, ! 1893, 1897, 1900, 1902, 1904, 1907, 1910, 1913, 1914, 1915, ! 1917, 1919, 1922, 1926, 1928, 1931, 1935, 1941, 1948, 1954, ! 1955, 1956, 1963, 1965, 1968, 1970, 1972, 1974, 1977, 1978, ! 1983, 1985, 1986, 1987, 1994, 1995, 1996, 2004, 2005, 2006, ! 2007, 2018, 2019, 2020, 2021, 2032, 2033, 2041, 2042, 2048, ! 2049, 2057, 2058, 2063, 2066, 2069, 2072, 2076, 2083, 2092, ! 2103, 2116, 2121, 2125, 2128, 2131, 2133, 2135, 2136, 2137, ! 2145, 2147, 2150, 2153, 2154, 2155, 2161, 2163, 2165, 2169, ! 2173, 2176, 2179, 2183, 2188, 2193, 2197, 2202, 2209, 2216, ! 2217, 2219, 2220, 2222, 2224, 2225, 2227, 2229, 2233, 2238, ! 2240, 2244, 2245, 2247, 2249, 2251, 2254, 2257, 2260, 2262, ! 2264, 2267, 2270, 2273, 2276, 2278, 2282, 2285, 2290, 2293, ! 2298, 2301, 2304, 2307, 2310, 2313, 2316, 2318, 2321, 2323, ! 2325, 2326, 2327, 2329, 2330, 2335, 2337, 2339, 2343, 2344, ! 2348, 2352, 2356, 2358, 2361, 2364, 2367, 2370, 2373, 2376, ! 2379, 2382, 2385, 2388, 2391, 2394, 2397, 2400, 2403, 2406, ! 2409, 2412, 2415, 2418, 2421, 2424, 2427, 2431, 2434, 2437, ! 2440, 2443, 2447, 2450, 2453, 2458, 2463, 2467 }; --- 238,314 ---- 0, 1, 3, 4, 7, 10, 11, 12, 14, 16, 17, 20, 22, 24, 26, 28, 34, 39, 43, 48, ! 53, 55, 56, 62, 64, 68, 70, 73, 75, 79, ! 81, 85, 87, 91, 92, 98, 99, 105, 106, 112, ! 113, 119, 123, 127, 134, 142, 147, 151, 155, 157, ! 159, 161, 163, 165, 168, 172, 176, 180, 184, 187, ! 190, 193, 196, 199, 201, 205, 210, 214, 220, 225, ! 229, 233, 236, 240, 244, 247, 249, 256, 261, 265, ! 269, 272, 275, 277, 281, 286, 289, 293, 294, 295, ! 297, 301, 304, 308, 310, 315, 318, 323, 326, 331, ! 334, 336, 338, 340, 342, 344, 346, 348, 350, 354, ! 358, 363, 368, 372, 377, 381, 386, 387, 389, 393, ! 395, 397, 398, 405, 406, 408, 409, 412, 414, 416, ! 418, 420, 422, 424, 426, 428, 432, 434, 438, 439, ! 441, 443, 444, 453, 455, 458, 463, 468, 470, 474, ! 478, 482, 486, 488, 490, 492, 493, 497, 500, 503, ! 506, 509, 512, 515, 520, 523, 528, 531, 535, 539, ! 544, 549, 555, 561, 568, 571, 576, 582, 586, 590, ! 594, 596, 600, 603, 607, 612, 614, 617, 623, 625, ! 630, 635, 640, 642, 646, 650, 654, 658, 662, 666, ! 670, 674, 678, 682, 686, 690, 694, 698, 702, 706, ! 710, 714, 718, 724, 728, 732, 734, 737, 741, 743, ! 745, 747, 749, 751, 753, 755, 758, 761, 765, 767, ! 769, 771, 775, 777, 779, 781, 783, 787, 791, 792, ! 797, 798, 805, 808, 813, 816, 819, 821, 826, 828, ! 836, 844, 852, 860, 865, 870, 873, 876, 878, 883, ! 886, 889, 892, 898, 902, 908, 912, 917, 924, 926, ! 929, 931, 934, 936, 938, 940, 943, 944, 947, 950, ! 954, 958, 962, 966, 970, 973, 976, 978, 980, 982, ! 985, 988, 991, 994, 996, 998, 1000, 1002, 1005, 1008, ! 1012, 1016, 1021, 1023, 1026, 1029, 1031, 1033, 1036, 1039, ! 1041, 1044, 1047, 1051, 1053, 1056, 1058, 1060, 1062, 1067, ! 1072, 1077, 1082, 1084, 1086, 1088, 1090, 1094, 1096, 1100, ! 1102, 1106, 1107, 1112, 1113, 1121, 1126, 1127, 1135, 1140, ! 1141, 1149, 1154, 1155, 1163, 1168, 1169, 1171, 1173, 1176, ! 1183, 1185, 1189, 1190, 1192, 1197, 1204, 1209, 1211, 1213, ! 1215, 1217, 1219, 1223, 1225, 1228, 1232, 1237, 1239, 1241, ! 1245, 1250, 1257, 1261, 1267, 1268, 1276, 1281, 1282, 1289, ! 1293, 1296, 1299, 1304, 1306, 1307, 1309, 1310, 1312, 1314, ! 1317, 1320, 1323, 1326, 1330, 1333, 1336, 1339, 1343, 1347, ! 1349, 1352, 1353, 1354, 1358, 1362, 1365, 1367, 1369, 1370, ! 1372, 1375, 1377, 1381, 1383, 1386, 1388, 1393, 1398, 1400, ! 1402, 1405, 1408, 1410, 1411, 1413, 1418, 1422, 1424, 1427, ! 1430, 1433, 1436, 1439, 1442, 1445, 1448, 1453, 1456, 1458, ! 1464, 1468, 1469, 1471, 1475, 1476, 1478, 1482, 1484, 1486, ! 1488, 1490, 1495, 1502, 1507, 1512, 1519, 1524, 1528, 1533, ! 1540, 1545, 1550, 1557, 1562, 1566, 1568, 1572, 1574, 1578, ! 1581, 1583, 1590, 1591, 1594, 1596, 1599, 1600, 1603, 1607, ! 1611, 1614, 1617, 1621, 1623, 1625, 1627, 1630, 1636, 1642, ! 1646, 1652, 1657, 1661, 1665, 1668, 1670, 1674, 1678, 1681, ! 1684, 1688, 1690, 1694, 1698, 1701, 1704, 1708, 1710, 1716, ! 1722, 1726, 1732, 1736, 1741, 1745, 1748, 1751, 1753, 1756, ! 1761, 1766, 1769, 1771, 1773, 1775, 1778, 1781, 1784, 1786, ! 1789, 1791, 1794, 1797, 1801, 1803, 1807, 1810, 1814, 1817, ! 1820, 1824, 1826, 1830, 1835, 1839, 1842, 1845, 1847, 1851, ! 1854, 1857, 1859, 1862, 1866, 1868, 1872, 1874, 1880, 1884, ! 1889, 1893, 1898, 1901, 1904, 1908, 1911, 1913, 1915, 1918, ! 1921, 1924, 1925, 1926, 1928, 1930, 1933, 1937, 1939, 1942, ! 1946, 1952, 1959, 1965, 1966, 1967, 1974, 1976, 1979, 1981, ! 1983, 1985, 1988, 1989, 1994, 1996, 1997, 1998, 2005, 2006, ! 2007, 2015, 2016, 2017, 2018, 2029, 2030, 2031, 2032, 2043, ! 2044, 2052, 2053, 2059, 2060, 2068, 2069, 2074, 2077, 2080, ! 2083, 2087, 2094, 2103, 2114, 2127, 2132, 2136, 2139, 2142, ! 2144, 2146, 2147, 2148, 2156, 2158, 2161, 2164, 2165, 2166, ! 2172, 2174, 2176, 2180, 2184, 2187, 2190, 2193, 2197, 2202, ! 2207, 2211, 2216, 2223, 2230, 2231, 2233, 2234, 2236, 2238, ! 2239, 2241, 2243, 2247, 2252, 2254, 2258, 2259, 2261, 2263, ! 2265, 2268, 2271, 2274, 2276, 2278, 2281, 2284, 2287, 2290, ! 2292, 2296, 2299, 2302, 2307, 2310, 2313, 2316, 2319, 2322, ! 2325, 2327, 2330, 2332, 2336, 2338, 2340, 2341, 2342, 2344, ! 2345, 2350, 2352, 2354, 2358, 2359, 2363, 2367, 2371, 2373, ! 2376, 2379, 2382, 2385, 2388, 2391, 2394, 2397, 2400, 2403, ! 2406, 2409, 2412, 2415, 2418, 2421, 2424, 2427, 2430, 2433, ! 2436, 2439, 2442, 2446, 2449, 2452, 2455, 2458, 2462, 2465, ! 2468, 2473, 2478, 2482 }; *************** *** 314,563 **** static const short yyrhs[] = { -1, 107, 0, 0, 108, 112, 0, 107, 112, 0, 0, ! 0, 25, 0, 26, 0, 0, 113, 114, 0, 129, ! 0, 128, 0, 122, 0, 120, 0, 111, 88, 179, 102, 56, 0, 115, 54, 107, 103, 0, 115, 54, ! 103, 0, 115, 109, 129, 110, 0, 115, 109, 128, 110, 0, 95, 0, 0, 45, 69, 117, 118, 70, ! 0, 119, 0, 118, 55, 119, 0, 220, 138, 0, ! 220, 140, 60, 232, 0, 327, 0, 39, 121, 56, ! 0, 3, 0, 121, 55, 3, 0, 0, 116, 222, ! 54, 123, 56, 0, 0, 116, 223, 54, 124, 56, ! 0, 0, 116, 222, 60, 125, 56, 0, 0, 116, ! 223, 60, 126, 56, 0, 116, 222, 56, 0, 116, ! 223, 56, 0, 116, 258, 330, 197, 206, 127, 0, ! 116, 186, 183, 330, 197, 206, 127, 0, 116, 189, ! 258, 127, 0, 116, 1, 103, 0, 116, 1, 56, ! 0, 54, 0, 60, 0, 56, 0, 58, 0, 23, ! 0, 196, 56, 0, 189, 195, 56, 0, 189, 258, ! 56, 0, 186, 194, 56, 0, 186, 183, 56, 0, ! 189, 56, 0, 141, 56, 0, 186, 56, 0, 1, ! 56, 0, 1, 103, 0, 56, 0, 130, 134, 282, ! 0, 130, 133, 134, 282, 0, 130, 180, 282, 0, ! 130, 133, 56, 180, 282, 0, 130, 133, 180, 282, ! 0, 186, 183, 1, 0, 189, 258, 1, 0, 258, ! 1, 0, 186, 183, 330, 0, 189, 258, 330, 0, ! 258, 330, 0, 94, 0, 186, 88, 322, 102, 250, ! 330, 0, 186, 44, 250, 330, 0, 186, 183, 330, ! 0, 189, 258, 330, 0, 258, 330, 0, 23, 3, ! 0, 132, 0, 132, 58, 213, 0, 132, 88, 160, ! 102, 0, 132, 44, 0, 60, 135, 136, 0, 0, ! 0, 137, 0, 136, 55, 137, 0, 136, 1, 0, ! 88, 160, 102, 0, 44, 0, 139, 88, 160, 102, ! 0, 139, 44, 0, 268, 88, 160, 102, 0, 268, ! 44, 0, 262, 88, 160, 102, 0, 262, 44, 0, ! 3, 0, 4, 0, 53, 0, 3, 0, 53, 0, ! 99, 0, 98, 0, 100, 0, 45, 221, 149, 0, ! 45, 186, 183, 0, 5, 45, 221, 149, 0, 5, ! 45, 186, 183, 0, 143, 144, 149, 0, 53, 69, ! 145, 70, 0, 4, 69, 145, 70, 0, 0, 146, ! 0, 145, 55, 146, 0, 185, 0, 168, 0, 0, ! 97, 229, 148, 234, 235, 103, 0, 0, 147, 0, ! 0, 147, 150, 0, 74, 0, 73, 0, 81, 0, ! 82, 0, 104, 0, 159, 0, 168, 0, 44, 0, ! 88, 152, 102, 0, 44, 0, 88, 156, 102, 0, ! 0, 156, 0, 1, 0, 0, 311, 183, 330, 197, ! 206, 58, 157, 213, 0, 152, 0, 54, 103, 0, ! 54, 279, 276, 103, 0, 54, 279, 1, 103, 0, ! 289, 0, 168, 55, 168, 0, 168, 55, 1, 0, ! 159, 55, 168, 0, 159, 55, 1, 0, 168, 0, ! 159, 0, 173, 0, 0, 33, 162, 166, 0, 75, ! 166, 0, 65, 166, 0, 83, 166, 0, 151, 166, ! 0, 62, 138, 0, 11, 161, 0, 11, 88, 185, ! 102, 0, 28, 161, 0, 28, 88, 185, 102, 0, ! 176, 249, 0, 176, 249, 164, 0, 176, 163, 249, ! 0, 176, 163, 249, 164, 0, 176, 88, 185, 102, ! 0, 176, 88, 185, 102, 164, 0, 176, 163, 88, ! 185, 102, 0, 176, 163, 88, 185, 102, 164, 0, ! 177, 166, 0, 177, 89, 105, 166, 0, 177, 89, ! 152, 105, 166, 0, 88, 160, 102, 0, 54, 160, ! 103, 0, 88, 160, 102, 0, 44, 0, 88, 192, ! 102, 0, 58, 213, 0, 88, 185, 102, 0, 165, ! 88, 185, 102, 0, 167, 0, 165, 167, 0, 165, ! 54, 214, 218, 103, 0, 161, 0, 29, 88, 152, ! 102, 0, 30, 88, 152, 102, 0, 30, 88, 4, ! 102, 0, 166, 0, 168, 78, 168, 0, 168, 79, ! 168, 0, 168, 73, 168, 0, 168, 74, 168, 0, ! 168, 75, 168, 0, 168, 76, 168, 0, 168, 77, ! 168, 0, 168, 71, 168, 0, 168, 72, 168, 0, ! 168, 68, 168, 0, 168, 69, 168, 0, 168, 70, ! 168, 0, 168, 67, 168, 0, 168, 66, 168, 0, ! 168, 65, 168, 0, 168, 63, 168, 0, 168, 64, ! 168, 0, 168, 62, 168, 0, 168, 61, 168, 0, ! 168, 59, 317, 60, 168, 0, 168, 58, 168, 0, ! 168, 57, 168, 0, 92, 0, 92, 168, 0, 83, ! 328, 138, 0, 335, 0, 3, 0, 53, 0, 169, ! 0, 4, 0, 169, 0, 262, 0, 75, 171, 0, ! 65, 171, 0, 260, 0, 169, 0, 262, 0, 169, ! 0, 8, 0, 178, 0, 179, 0, 88, 152, 102, ! 0, 88, 1, 102, 0, 0, 88, 174, 283, 102, ! 0, 0, 173, 88, 160, 102, 175, 150, 0, 173, ! 44, 0, 173, 89, 152, 105, 0, 173, 81, 0, ! 173, 82, 0, 40, 0, 7, 88, 160, 102, 0, ! 264, 0, 47, 69, 185, 70, 88, 152, 102, 0, ! 48, 69, 185, 70, 88, 152, 102, 0, 49, 69, ! 185, 70, 88, 152, 102, 0, 50, 69, 185, 70, ! 88, 152, 102, 0, 46, 88, 152, 102, 0, 46, ! 88, 185, 102, 0, 271, 3, 0, 271, 335, 0, ! 263, 0, 263, 88, 160, 102, 0, 263, 44, 0, ! 181, 170, 0, 181, 261, 0, 181, 170, 88, 160, ! 102, 0, 181, 170, 44, 0, 181, 261, 88, 160, ! 102, 0, 181, 261, 44, 0, 181, 83, 6, 44, ! 0, 181, 6, 51, 83, 6, 44, 0, 38, 0, ! 271, 38, 0, 37, 0, 271, 177, 0, 42, 0, ! 43, 0, 9, 0, 179, 9, 0, 0, 173, 87, ! 0, 173, 86, 0, 192, 183, 56, 0, 186, 183, ! 56, 0, 192, 194, 56, 0, 186, 194, 56, 0, ! 189, 195, 56, 0, 186, 56, 0, 189, 56, 0, ! 254, 0, 258, 0, 44, 0, 184, 44, 0, 190, ! 274, 0, 251, 274, 0, 192, 274, 0, 190, 0, ! 251, 0, 190, 0, 187, 0, 189, 192, 0, 192, ! 188, 0, 189, 192, 188, 0, 189, 192, 191, 0, ! 189, 192, 191, 188, 0, 5, 0, 188, 193, 0, ! 188, 5, 0, 251, 0, 5, 0, 189, 7, 0, ! 189, 5, 0, 192, 0, 251, 192, 0, 192, 191, ! 0, 251, 192, 191, 0, 193, 0, 191, 193, 0, ! 215, 0, 6, 0, 268, 0, 27, 88, 152, 102, ! 0, 27, 88, 185, 102, 0, 31, 88, 152, 102, ! 0, 31, 88, 185, 102, 0, 6, 0, 7, 0, ! 215, 0, 198, 0, 194, 55, 200, 0, 202, 0, ! 195, 55, 200, 0, 204, 0, 196, 55, 200, 0, ! 0, 111, 88, 179, 102, 0, 0, 183, 330, 197, ! 206, 58, 199, 213, 0, 183, 330, 197, 206, 0, ! 0, 183, 330, 197, 206, 58, 201, 213, 0, 183, ! 330, 197, 206, 0, 0, 258, 330, 197, 206, 58, ! 203, 213, 0, 258, 330, 197, 206, 0, 0, 258, ! 330, 197, 206, 58, 205, 213, 0, 258, 330, 197, ! 206, 0, 0, 207, 0, 208, 0, 207, 208, 0, ! 32, 88, 88, 209, 102, 102, 0, 210, 0, 209, ! 55, 210, 0, 0, 211, 0, 211, 88, 3, 102, ! 0, 211, 88, 3, 55, 160, 102, 0, 211, 88, ! 160, 102, 0, 138, 0, 5, 0, 6, 0, 7, ! 0, 138, 0, 212, 55, 138, 0, 168, 0, 54, ! 103, 0, 54, 214, 103, 0, 54, 214, 55, 103, ! 0, 1, 0, 213, 0, 214, 55, 213, 0, 89, ! 168, 105, 213, 0, 214, 55, 19, 168, 60, 213, ! 0, 138, 60, 213, 0, 214, 55, 138, 60, 213, ! 0, 0, 12, 138, 54, 216, 247, 219, 103, 0, ! 12, 138, 54, 103, 0, 0, 12, 54, 217, 247, ! 219, 103, 0, 12, 54, 103, 0, 12, 138, 0, ! 12, 269, 0, 228, 234, 235, 103, 0, 228, 0, ! 0, 55, 0, 0, 55, 0, 35, 0, 220, 5, ! 0, 220, 6, 0, 220, 7, 0, 220, 35, 0, ! 220, 143, 56, 0, 220, 138, 0, 220, 269, 0, ! 220, 142, 0, 220, 143, 54, 0, 220, 143, 60, ! 0, 221, 0, 220, 140, 0, 0, 0, 222, 224, ! 229, 0, 223, 225, 229, 0, 220, 54, 0, 227, ! 0, 226, 0, 0, 60, 0, 60, 230, 0, 231, ! 0, 230, 55, 231, 0, 232, 0, 233, 232, 0, ! 268, 0, 31, 88, 152, 102, 0, 31, 88, 185, ! 102, 0, 36, 0, 5, 0, 233, 36, 0, 233, ! 5, 0, 54, 0, 0, 236, 0, 235, 36, 60, ! 236, 0, 235, 36, 60, 0, 237, 0, 236, 237, ! 0, 236, 56, 0, 238, 56, 0, 238, 103, 0, ! 131, 60, 0, 131, 54, 0, 186, 239, 0, 189, ! 240, 0, 258, 330, 197, 206, 0, 60, 168, 0, ! 1, 0, 186, 88, 322, 102, 250, 0, 186, 44, ! 250, 0, 0, 241, 0, 239, 55, 242, 0, 0, ! 244, 0, 240, 55, 246, 0, 243, 0, 244, 0, ! 245, 0, 246, 0, 254, 330, 197, 206, 0, 254, ! 330, 197, 206, 58, 213, 0, 4, 60, 168, 206, ! 0, 258, 330, 197, 206, 0, 258, 330, 197, 206, ! 58, 213, 0, 3, 60, 168, 206, 0, 60, 168, ! 206, 0, 254, 330, 197, 206, 0, 254, 330, 197, ! 206, 58, 213, 0, 4, 60, 168, 206, 0, 258, ! 330, 197, 206, 0, 258, 330, 197, 206, 58, 213, ! 0, 3, 60, 168, 206, 0, 60, 168, 206, 0, ! 248, 0, 247, 55, 248, 0, 138, 0, 138, 58, ! 168, 0, 311, 272, 0, 311, 0, 88, 185, 102, ! 89, 152, 105, 0, 0, 250, 7, 0, 7, 0, ! 251, 7, 0, 0, 253, 152, 0, 75, 251, 254, ! 0, 65, 251, 254, 0, 75, 254, 0, 65, 254, ! 0, 270, 250, 254, 0, 257, 0, 265, 0, 256, ! 0, 266, 265, 0, 257, 88, 160, 102, 250, 0, ! 257, 88, 322, 102, 250, 0, 257, 44, 250, 0, ! 257, 88, 1, 102, 250, 0, 257, 89, 252, 105, ! 0, 257, 89, 105, 0, 88, 254, 102, 0, 266, ! 265, 0, 265, 0, 75, 251, 258, 0, 65, 251, ! 258, 0, 75, 258, 0, 65, 258, 0, 270, 250, ! 258, 0, 172, 0, 75, 251, 258, 0, 65, 251, ! 258, 0, 75, 259, 0, 65, 259, 0, 270, 250, ! 258, 0, 260, 0, 172, 88, 160, 102, 250, 0, ! 172, 88, 322, 102, 250, 0, 172, 44, 250, 0, ! 172, 88, 1, 102, 250, 0, 88, 171, 102, 0, ! 88, 259, 102, 0, 172, 89, 252, 105, 0, 172, ! 89, 105, 0, 266, 170, 0, 266, 169, 0, 262, ! 0, 271, 262, 0, 192, 88, 160, 102, 0, 192, ! 88, 171, 102, 0, 192, 184, 0, 4, 0, 142, ! 0, 267, 0, 266, 267, 0, 4, 51, 0, 142, ! 51, 0, 255, 0, 271, 255, 0, 256, 0, 271, ! 255, 0, 266, 75, 0, 271, 266, 75, 0, 51, ! 0, 75, 250, 272, 0, 75, 250, 0, 65, 250, ! 272, 0, 65, 250, 0, 270, 250, 0, 270, 250, ! 272, 0, 273, 0, 89, 152, 105, 0, 273, 89, ! 252, 105, 0, 75, 251, 274, 0, 75, 274, 0, ! 75, 251, 0, 75, 0, 65, 251, 274, 0, 65, ! 274, 0, 65, 251, 0, 65, 0, 270, 250, 0, ! 270, 250, 274, 0, 275, 0, 88, 274, 102, 0, ! 85, 0, 275, 88, 322, 102, 250, 0, 275, 44, ! 250, 0, 275, 89, 252, 105, 0, 275, 89, 105, ! 0, 88, 323, 102, 250, 0, 165, 250, 0, 184, ! 250, 0, 89, 252, 105, 0, 89, 105, 0, 288, ! 0, 277, 0, 276, 288, 0, 276, 277, 0, 1, ! 56, 0, 0, 0, 280, 0, 281, 0, 280, 281, ! 0, 34, 212, 56, 0, 283, 0, 1, 283, 0, ! 54, 278, 103, 0, 54, 278, 279, 276, 103, 0, ! 54, 278, 279, 276, 1, 103, 0, 54, 278, 279, ! 1, 103, 0, 0, 0, 13, 285, 278, 154, 286, ! 287, 0, 283, 0, 278, 289, 0, 283, 0, 289, ! 0, 182, 0, 152, 56, 0, 0, 284, 14, 290, ! 287, 0, 284, 0, 0, 0, 15, 291, 278, 154, ! 292, 158, 0, 0, 0, 16, 293, 287, 15, 294, ! 153, 56, 0, 0, 0, 0, 314, 295, 278, 155, ! 56, 296, 317, 102, 297, 158, 0, 0, 0, 0, ! 315, 298, 278, 155, 56, 299, 317, 102, 300, 158, ! 0, 0, 18, 278, 88, 156, 102, 301, 287, 0, ! 0, 19, 168, 60, 302, 288, 0, 0, 19, 168, ! 10, 168, 60, 303, 288, 0, 0, 20, 60, 304, ! 288, 0, 21, 56, 0, 22, 56, 0, 23, 56, ! 0, 23, 152, 56, 0, 111, 316, 88, 179, 102, ! 56, 0, 111, 316, 88, 179, 60, 318, 102, 56, ! 0, 111, 316, 88, 179, 60, 318, 60, 318, 102, ! 56, 0, 111, 316, 88, 179, 60, 318, 60, 318, ! 60, 321, 102, 56, 0, 24, 75, 152, 56, 0, ! 24, 138, 56, 0, 313, 288, 0, 313, 103, 0, ! 56, 0, 305, 0, 0, 0, 90, 54, 278, 306, ! 308, 307, 309, 0, 103, 0, 276, 103, 0, 1, ! 103, 0, 0, 0, 309, 91, 310, 312, 283, 0, ! 190, 0, 251, 0, 88, 10, 102, 0, 88, 327, ! 102, 0, 3, 60, 0, 53, 60, 0, 17, 88, ! 56, 0, 17, 88, 152, 56, 0, 17, 88, 54, ! 103, 0, 17, 88, 182, 0, 17, 88, 1, 56, ! 0, 17, 88, 54, 278, 276, 103, 0, 17, 88, ! 54, 278, 1, 103, 0, 0, 7, 0, 0, 152, ! 0, 1, 0, 0, 319, 0, 320, 0, 319, 55, ! 320, 0, 9, 88, 152, 102, 0, 9, 0, 321, ! 55, 9, 0, 0, 323, 0, 185, 0, 324, 0, ! 325, 10, 0, 324, 10, 0, 185, 10, 0, 10, ! 0, 93, 0, 324, 93, 0, 185, 93, 0, 324, ! 60, 0, 185, 60, 0, 326, 0, 327, 58, 213, ! 0, 325, 327, 0, 325, 327, 58, 213, 0, 325, ! 329, 0, 325, 329, 58, 213, 0, 324, 55, 0, ! 185, 55, 0, 187, 183, 0, 190, 183, 0, 192, ! 183, 0, 187, 274, 0, 187, 0, 189, 258, 0, ! 326, 0, 185, 0, 0, 0, 258, 0, 0, 92, ! 88, 332, 102, 0, 185, 0, 331, 0, 332, 55, ! 331, 0, 0, 75, 250, 333, 0, 65, 250, 333, ! 0, 270, 250, 333, 0, 41, 0, 334, 75, 0, ! 334, 76, 0, 334, 77, 0, 334, 73, 0, 334, ! 74, 0, 334, 65, 0, 334, 63, 0, 334, 64, ! 0, 334, 83, 0, 334, 55, 0, 334, 68, 0, ! 334, 69, 0, 334, 70, 0, 334, 67, 0, 334, ! 57, 0, 334, 58, 0, 334, 71, 0, 334, 72, ! 0, 334, 81, 0, 334, 82, 0, 334, 62, 0, ! 334, 61, 0, 334, 104, 0, 334, 59, 60, 0, ! 334, 66, 0, 334, 86, 0, 334, 78, 0, 334, ! 44, 0, 334, 89, 105, 0, 334, 38, 0, 334, ! 37, 0, 334, 38, 89, 105, 0, 334, 37, 89, ! 105, 0, 334, 311, 333, 0, 334, 1, 0 }; --- 315,566 ---- static const short yyrhs[] = { -1, 107, 0, 0, 108, 112, 0, 107, 112, 0, 0, ! 0, 25, 0, 26, 0, 0, 113, 114, 0, 130, ! 0, 129, 0, 123, 0, 121, 0, 111, 88, 180, 102, 56, 0, 115, 54, 107, 103, 0, 115, 54, ! 103, 0, 115, 109, 130, 110, 0, 115, 109, 129, 110, 0, 95, 0, 0, 45, 69, 117, 118, 70, ! 0, 120, 0, 118, 55, 120, 0, 221, 0, 221, ! 139, 0, 119, 0, 119, 58, 193, 0, 328, 0, ! 39, 122, 56, 0, 3, 0, 122, 55, 3, 0, ! 0, 116, 223, 54, 124, 56, 0, 0, 116, 224, ! 54, 125, 56, 0, 0, 116, 223, 60, 126, 56, ! 0, 0, 116, 224, 60, 127, 56, 0, 116, 223, ! 56, 0, 116, 224, 56, 0, 116, 259, 332, 198, ! 207, 128, 0, 116, 187, 184, 332, 198, 207, 128, ! 0, 116, 190, 259, 128, 0, 116, 1, 103, 0, ! 116, 1, 56, 0, 54, 0, 60, 0, 56, 0, ! 58, 0, 23, 0, 197, 56, 0, 190, 196, 56, ! 0, 190, 259, 56, 0, 187, 195, 56, 0, 187, ! 184, 56, 0, 190, 56, 0, 142, 56, 0, 187, ! 56, 0, 1, 56, 0, 1, 103, 0, 56, 0, ! 131, 135, 283, 0, 131, 134, 135, 283, 0, 131, ! 181, 283, 0, 131, 134, 56, 181, 283, 0, 131, ! 134, 181, 283, 0, 187, 184, 1, 0, 190, 259, ! 1, 0, 259, 1, 0, 187, 184, 332, 0, 190, ! 259, 332, 0, 259, 332, 0, 94, 0, 187, 88, ! 323, 102, 251, 332, 0, 187, 44, 251, 332, 0, ! 187, 184, 332, 0, 190, 259, 332, 0, 259, 332, ! 0, 23, 3, 0, 133, 0, 133, 58, 214, 0, ! 133, 88, 161, 102, 0, 133, 44, 0, 60, 136, ! 137, 0, 0, 0, 138, 0, 137, 55, 138, 0, ! 137, 1, 0, 88, 161, 102, 0, 44, 0, 140, ! 88, 161, 102, 0, 140, 44, 0, 269, 88, 161, ! 102, 0, 269, 44, 0, 263, 88, 161, 102, 0, ! 263, 44, 0, 3, 0, 4, 0, 53, 0, 3, ! 0, 53, 0, 99, 0, 98, 0, 100, 0, 45, ! 222, 150, 0, 45, 187, 184, 0, 5, 45, 222, ! 150, 0, 5, 45, 187, 184, 0, 144, 145, 150, ! 0, 53, 69, 146, 70, 0, 53, 69, 70, 0, ! 4, 69, 146, 70, 0, 0, 147, 0, 146, 55, ! 147, 0, 186, 0, 169, 0, 0, 97, 230, 149, ! 235, 236, 103, 0, 0, 148, 0, 0, 148, 151, ! 0, 74, 0, 73, 0, 81, 0, 82, 0, 104, ! 0, 160, 0, 169, 0, 44, 0, 88, 153, 102, ! 0, 44, 0, 88, 157, 102, 0, 0, 157, 0, ! 1, 0, 0, 312, 184, 332, 198, 207, 58, 158, ! 214, 0, 153, 0, 54, 103, 0, 54, 280, 277, ! 103, 0, 54, 280, 1, 103, 0, 290, 0, 169, ! 55, 169, 0, 169, 55, 1, 0, 160, 55, 169, ! 0, 160, 55, 1, 0, 169, 0, 160, 0, 174, ! 0, 0, 33, 163, 167, 0, 75, 167, 0, 65, ! 167, 0, 83, 167, 0, 152, 167, 0, 62, 139, ! 0, 11, 162, 0, 11, 88, 186, 102, 0, 28, ! 162, 0, 28, 88, 186, 102, 0, 177, 250, 0, ! 177, 250, 165, 0, 177, 164, 250, 0, 177, 164, ! 250, 165, 0, 177, 88, 186, 102, 0, 177, 88, ! 186, 102, 165, 0, 177, 164, 88, 186, 102, 0, ! 177, 164, 88, 186, 102, 165, 0, 178, 167, 0, ! 178, 89, 105, 167, 0, 178, 89, 153, 105, 167, ! 0, 88, 161, 102, 0, 54, 161, 103, 0, 88, ! 161, 102, 0, 44, 0, 88, 193, 102, 0, 58, ! 214, 0, 88, 186, 102, 0, 166, 88, 186, 102, ! 0, 168, 0, 166, 168, 0, 166, 54, 215, 219, ! 103, 0, 162, 0, 29, 88, 153, 102, 0, 30, ! 88, 153, 102, 0, 30, 88, 4, 102, 0, 167, ! 0, 169, 78, 169, 0, 169, 79, 169, 0, 169, ! 73, 169, 0, 169, 74, 169, 0, 169, 75, 169, ! 0, 169, 76, 169, 0, 169, 77, 169, 0, 169, ! 71, 169, 0, 169, 72, 169, 0, 169, 68, 169, ! 0, 169, 69, 169, 0, 169, 70, 169, 0, 169, ! 67, 169, 0, 169, 66, 169, 0, 169, 65, 169, ! 0, 169, 63, 169, 0, 169, 64, 169, 0, 169, ! 62, 169, 0, 169, 61, 169, 0, 169, 59, 318, ! 60, 169, 0, 169, 58, 169, 0, 169, 57, 169, ! 0, 92, 0, 92, 169, 0, 83, 330, 139, 0, ! 337, 0, 3, 0, 53, 0, 170, 0, 4, 0, ! 170, 0, 263, 0, 75, 172, 0, 65, 172, 0, ! 88, 172, 102, 0, 261, 0, 170, 0, 263, 0, ! 88, 172, 102, 0, 170, 0, 8, 0, 179, 0, ! 180, 0, 88, 153, 102, 0, 88, 1, 102, 0, ! 0, 88, 175, 284, 102, 0, 0, 174, 88, 161, ! 102, 176, 151, 0, 174, 44, 0, 174, 89, 153, ! 105, 0, 174, 81, 0, 174, 82, 0, 40, 0, ! 7, 88, 161, 102, 0, 265, 0, 47, 69, 186, ! 70, 88, 153, 102, 0, 48, 69, 186, 70, 88, ! 153, 102, 0, 49, 69, 186, 70, 88, 153, 102, ! 0, 50, 69, 186, 70, 88, 153, 102, 0, 46, ! 88, 153, 102, 0, 46, 88, 186, 102, 0, 272, ! 3, 0, 272, 337, 0, 264, 0, 264, 88, 161, ! 102, 0, 264, 44, 0, 182, 171, 0, 182, 262, ! 0, 182, 171, 88, 161, 102, 0, 182, 171, 44, ! 0, 182, 262, 88, 161, 102, 0, 182, 262, 44, ! 0, 182, 83, 6, 44, 0, 182, 6, 51, 83, ! 6, 44, 0, 38, 0, 272, 38, 0, 37, 0, ! 272, 178, 0, 42, 0, 43, 0, 9, 0, 180, ! 9, 0, 0, 174, 87, 0, 174, 86, 0, 193, ! 184, 56, 0, 187, 184, 56, 0, 193, 195, 56, ! 0, 187, 195, 56, 0, 190, 196, 56, 0, 187, ! 56, 0, 190, 56, 0, 255, 0, 259, 0, 44, ! 0, 185, 44, 0, 191, 275, 0, 252, 275, 0, ! 193, 275, 0, 191, 0, 252, 0, 191, 0, 188, ! 0, 190, 193, 0, 193, 189, 0, 190, 193, 189, ! 0, 190, 193, 192, 0, 190, 193, 192, 189, 0, ! 5, 0, 189, 194, 0, 189, 5, 0, 252, 0, ! 5, 0, 190, 7, 0, 190, 5, 0, 193, 0, ! 252, 193, 0, 193, 192, 0, 252, 193, 192, 0, ! 194, 0, 192, 194, 0, 216, 0, 6, 0, 269, ! 0, 27, 88, 153, 102, 0, 27, 88, 186, 102, ! 0, 31, 88, 153, 102, 0, 31, 88, 186, 102, ! 0, 6, 0, 7, 0, 216, 0, 199, 0, 195, ! 55, 201, 0, 203, 0, 196, 55, 201, 0, 205, ! 0, 197, 55, 201, 0, 0, 111, 88, 180, 102, ! 0, 0, 184, 332, 198, 207, 58, 200, 214, 0, ! 184, 332, 198, 207, 0, 0, 184, 332, 198, 207, ! 58, 202, 214, 0, 184, 332, 198, 207, 0, 0, ! 259, 332, 198, 207, 58, 204, 214, 0, 259, 332, ! 198, 207, 0, 0, 259, 332, 198, 207, 58, 206, ! 214, 0, 259, 332, 198, 207, 0, 0, 208, 0, ! 209, 0, 208, 209, 0, 32, 88, 88, 210, 102, ! 102, 0, 211, 0, 210, 55, 211, 0, 0, 212, ! 0, 212, 88, 3, 102, 0, 212, 88, 3, 55, ! 161, 102, 0, 212, 88, 161, 102, 0, 139, 0, ! 5, 0, 6, 0, 7, 0, 139, 0, 213, 55, ! 139, 0, 169, 0, 54, 103, 0, 54, 215, 103, ! 0, 54, 215, 55, 103, 0, 1, 0, 214, 0, ! 215, 55, 214, 0, 89, 169, 105, 214, 0, 215, ! 55, 19, 169, 60, 214, 0, 139, 60, 214, 0, ! 215, 55, 139, 60, 214, 0, 0, 12, 139, 54, ! 217, 248, 220, 103, 0, 12, 139, 54, 103, 0, ! 0, 12, 54, 218, 248, 220, 103, 0, 12, 54, ! 103, 0, 12, 139, 0, 12, 270, 0, 229, 235, ! 236, 103, 0, 229, 0, 0, 55, 0, 0, 55, ! 0, 35, 0, 221, 5, 0, 221, 6, 0, 221, ! 7, 0, 221, 35, 0, 221, 144, 56, 0, 221, ! 139, 0, 221, 270, 0, 221, 143, 0, 221, 144, ! 54, 0, 221, 144, 60, 0, 222, 0, 221, 141, ! 0, 0, 0, 223, 225, 230, 0, 224, 226, 230, ! 0, 221, 54, 0, 228, 0, 227, 0, 0, 60, ! 0, 60, 231, 0, 232, 0, 231, 55, 232, 0, ! 233, 0, 234, 233, 0, 269, 0, 31, 88, 153, ! 102, 0, 31, 88, 186, 102, 0, 36, 0, 5, ! 0, 234, 36, 0, 234, 5, 0, 54, 0, 0, ! 237, 0, 236, 36, 60, 237, 0, 236, 36, 60, ! 0, 238, 0, 237, 238, 0, 237, 56, 0, 239, ! 56, 0, 239, 103, 0, 132, 60, 0, 132, 54, ! 0, 187, 240, 0, 190, 241, 0, 259, 332, 198, ! 207, 0, 60, 169, 0, 1, 0, 187, 88, 323, ! 102, 251, 0, 187, 44, 251, 0, 0, 242, 0, ! 240, 55, 243, 0, 0, 245, 0, 241, 55, 247, ! 0, 244, 0, 245, 0, 246, 0, 247, 0, 255, ! 332, 198, 207, 0, 255, 332, 198, 207, 58, 214, ! 0, 4, 60, 169, 207, 0, 259, 332, 198, 207, ! 0, 259, 332, 198, 207, 58, 214, 0, 3, 60, ! 169, 207, 0, 60, 169, 207, 0, 255, 332, 198, ! 207, 0, 255, 332, 198, 207, 58, 214, 0, 4, ! 60, 169, 207, 0, 259, 332, 198, 207, 0, 259, ! 332, 198, 207, 58, 214, 0, 3, 60, 169, 207, ! 0, 60, 169, 207, 0, 249, 0, 248, 55, 249, ! 0, 139, 0, 139, 58, 169, 0, 312, 273, 0, ! 312, 0, 88, 186, 102, 89, 153, 105, 0, 0, ! 251, 7, 0, 7, 0, 252, 7, 0, 0, 254, ! 153, 0, 75, 252, 255, 0, 65, 252, 255, 0, ! 75, 255, 0, 65, 255, 0, 271, 251, 255, 0, ! 258, 0, 266, 0, 257, 0, 267, 266, 0, 258, ! 88, 161, 102, 251, 0, 258, 88, 323, 102, 251, ! 0, 258, 44, 251, 0, 258, 88, 1, 102, 251, ! 0, 258, 89, 253, 105, 0, 258, 89, 105, 0, ! 88, 255, 102, 0, 267, 266, 0, 266, 0, 75, ! 252, 259, 0, 65, 252, 259, 0, 75, 259, 0, ! 65, 259, 0, 271, 251, 259, 0, 173, 0, 75, ! 252, 259, 0, 65, 252, 259, 0, 75, 260, 0, ! 65, 260, 0, 271, 251, 259, 0, 261, 0, 173, ! 88, 161, 102, 251, 0, 173, 88, 323, 102, 251, ! 0, 173, 44, 251, 0, 173, 88, 1, 102, 251, ! 0, 88, 260, 102, 0, 173, 89, 253, 105, 0, ! 173, 89, 105, 0, 267, 171, 0, 267, 170, 0, ! 263, 0, 272, 263, 0, 193, 88, 161, 102, 0, ! 193, 88, 172, 102, 0, 193, 185, 0, 4, 0, ! 143, 0, 268, 0, 267, 268, 0, 4, 51, 0, ! 143, 51, 0, 256, 0, 272, 256, 0, 257, 0, ! 272, 256, 0, 267, 75, 0, 272, 267, 75, 0, ! 51, 0, 75, 251, 273, 0, 75, 251, 0, 65, ! 251, 273, 0, 65, 251, 0, 271, 251, 0, 271, ! 251, 273, 0, 274, 0, 89, 153, 105, 0, 274, ! 89, 253, 105, 0, 75, 252, 275, 0, 75, 275, ! 0, 75, 252, 0, 75, 0, 65, 252, 275, 0, ! 65, 275, 0, 65, 252, 0, 65, 0, 271, 251, ! 0, 271, 251, 275, 0, 276, 0, 88, 275, 102, ! 0, 85, 0, 276, 88, 323, 102, 251, 0, 276, ! 44, 251, 0, 276, 89, 253, 105, 0, 276, 89, ! 105, 0, 88, 324, 102, 251, 0, 166, 251, 0, ! 185, 251, 0, 89, 253, 105, 0, 89, 105, 0, ! 289, 0, 278, 0, 277, 289, 0, 277, 278, 0, ! 1, 56, 0, 0, 0, 281, 0, 282, 0, 281, ! 282, 0, 34, 213, 56, 0, 284, 0, 1, 284, ! 0, 54, 279, 103, 0, 54, 279, 280, 277, 103, ! 0, 54, 279, 280, 277, 1, 103, 0, 54, 279, ! 280, 1, 103, 0, 0, 0, 13, 286, 279, 155, ! 287, 288, 0, 284, 0, 279, 290, 0, 284, 0, ! 290, 0, 183, 0, 153, 56, 0, 0, 285, 14, ! 291, 288, 0, 285, 0, 0, 0, 15, 292, 279, ! 155, 293, 159, 0, 0, 0, 16, 294, 288, 15, ! 295, 154, 56, 0, 0, 0, 0, 315, 296, 279, ! 156, 56, 297, 318, 102, 298, 159, 0, 0, 0, ! 0, 316, 299, 279, 156, 56, 300, 318, 102, 301, ! 159, 0, 0, 18, 279, 88, 157, 102, 302, 288, ! 0, 0, 19, 169, 60, 303, 289, 0, 0, 19, ! 169, 10, 169, 60, 304, 289, 0, 0, 20, 60, ! 305, 289, 0, 21, 56, 0, 22, 56, 0, 23, ! 56, 0, 23, 153, 56, 0, 111, 317, 88, 180, ! 102, 56, 0, 111, 317, 88, 180, 60, 319, 102, ! 56, 0, 111, 317, 88, 180, 60, 319, 60, 319, ! 102, 56, 0, 111, 317, 88, 180, 60, 319, 60, ! 319, 60, 322, 102, 56, 0, 24, 75, 153, 56, ! 0, 24, 139, 56, 0, 314, 289, 0, 314, 103, ! 0, 56, 0, 306, 0, 0, 0, 90, 54, 279, ! 307, 309, 308, 310, 0, 103, 0, 277, 103, 0, ! 1, 103, 0, 0, 0, 310, 91, 311, 313, 284, ! 0, 191, 0, 252, 0, 88, 10, 102, 0, 88, ! 329, 102, 0, 3, 60, 0, 53, 60, 0, 4, ! 60, 0, 17, 88, 56, 0, 17, 88, 153, 56, ! 0, 17, 88, 54, 103, 0, 17, 88, 183, 0, ! 17, 88, 1, 56, 0, 17, 88, 54, 279, 277, ! 103, 0, 17, 88, 54, 279, 1, 103, 0, 0, ! 7, 0, 0, 153, 0, 1, 0, 0, 320, 0, ! 321, 0, 320, 55, 321, 0, 9, 88, 153, 102, ! 0, 9, 0, 322, 55, 9, 0, 0, 324, 0, ! 186, 0, 325, 0, 326, 10, 0, 325, 10, 0, ! 186, 10, 0, 10, 0, 93, 0, 325, 93, 0, ! 186, 93, 0, 325, 60, 0, 186, 60, 0, 327, ! 0, 329, 58, 214, 0, 326, 328, 0, 326, 331, ! 0, 326, 331, 58, 214, 0, 325, 55, 0, 186, ! 55, 0, 188, 184, 0, 191, 184, 0, 193, 184, ! 0, 188, 275, 0, 188, 0, 190, 259, 0, 329, ! 0, 329, 58, 214, 0, 327, 0, 186, 0, 0, ! 0, 259, 0, 0, 92, 88, 334, 102, 0, 186, ! 0, 333, 0, 334, 55, 333, 0, 0, 75, 251, ! 335, 0, 65, 251, 335, 0, 271, 251, 335, 0, ! 41, 0, 336, 75, 0, 336, 76, 0, 336, 77, ! 0, 336, 73, 0, 336, 74, 0, 336, 65, 0, ! 336, 63, 0, 336, 64, 0, 336, 83, 0, 336, ! 55, 0, 336, 68, 0, 336, 69, 0, 336, 70, ! 0, 336, 67, 0, 336, 57, 0, 336, 58, 0, ! 336, 71, 0, 336, 72, 0, 336, 81, 0, 336, ! 82, 0, 336, 62, 0, 336, 61, 0, 336, 104, ! 0, 336, 59, 60, 0, 336, 66, 0, 336, 86, ! 0, 336, 78, 0, 336, 44, 0, 336, 89, 105, ! 0, 336, 38, 0, 336, 37, 0, 336, 38, 89, ! 105, 0, 336, 37, 89, 105, 0, 336, 312, 335, ! 0, 336, 1, 0 }; *************** *** 566,643 **** #if YYDEBUG != 0 static const short yyrline[] = { 0, ! 291, 292, 306, 308, 309, 313, 318, 322, 324, 327, ! 330, 334, 337, 339, 341, 342, 345, 347, 349, 352, ! 357, 362, 365, 369, 372, 376, 392, 401, 404, 409, ! 411, 415, 421, 421, 424, 424, 427, 427, 442, 442, ! 447, 452, 469, 492, 502, 503, 506, 507, 508, 509, ! 510, 513, 516, 519, 524, 529, 535, 537, 538, 557, ! 558, 559, 562, 576, 589, 592, 595, 598, 600, 602, ! 606, 612, 617, 622, 629, 640, 647, 649, 651, 655, ! 663, 665, 667, 669, 673, 686, 709, 712, 714, 715, ! 718, 724, 730, 732, 734, 736, 739, 743, 749, 751, ! 752, 755, 757, 760, 762, 763, 766, 769, 771, 773, ! 777, 782, 785, 789, 794, 797, 801, 804, 807, 841, ! 857, 860, 864, 867, 871, 873, 875, 877, 879, 883, ! 885, 888, 893, 897, 902, 906, 909, 910, 914, 933, ! 940, 943, 946, 948, 950, 954, 958, 961, 963, 967, ! 970, 973, 982, 985, 988, 990, 992, 994, 1001, 1012, ! 1032, 1034, 1036, 1041, 1043, 1045, 1047, 1049, 1052, 1054, ! 1056, 1059, 1061, 1065, 1071, 1074, 1081, 1084, 1086, 1094, ! 1103, 1109, 1115, 1117, 1119, 1132, 1134, 1136, 1138, 1155, ! 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, ! 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, ! 1198, 1200, 1207, 1209, 1226, 1229, 1230, 1231, 1234, 1236, ! 1239, 1241, 1242, 1244, 1248, 1250, 1251, 1256, 1276, 1277, ! 1278, 1280, 1282, 1284, 1292, 1313, 1318, 1325, 1332, 1334, ! 1343, 1348, 1371, 1415, 1416, 1419, 1422, 1425, 1428, 1430, ! 1433, 1472, 1479, 1481, 1483, 1485, 1487, 1489, 1504, 1519, ! 1530, 1542, 1549, 1598, 1600, 1604, 1606, 1610, 1613, 1618, ! 1620, 1624, 1637, 1638, 1644, 1655, 1663, 1669, 1674, 1676, ! 1681, 1688, 1690, 1694, 1698, 1704, 1707, 1709, 1711, 1713, ! 1721, 1723, 1725, 1728, 1730, 1732, 1734, 1739, 1745, 1747, ! 1758, 1761, 1763, 1766, 1781, 1784, 1786, 1788, 1792, 1795, ! 1803, 1804, 1805, 1806, 1810, 1814, 1828, 1846, 1847, 1848, ! 1851, 1853, 1856, 1858, 1861, 1863, 1866, 1869, 1873, 1890, ! 1892, 1910, 1916, 1917, 1923, 1931, 1933, 1942, 1950, 1952, ! 1963, 1966, 1970, 1973, 1977, 1982, 1985, 1989, 1992, 1994, ! 1996, 1998, 2005, 2007, 2008, 2009, 2013, 2016, 2020, 2022, ! 2025, 2028, 2031, 2037, 2040, 2043, 2045, 2047, 2049, 2053, ! 2057, 2061, 2064, 2067, 2071, 2074, 2076, 2080, 2131, 2146, ! 2148, 2151, 2153, 2157, 2158, 2160, 2162, 2164, 2168, 2177, ! 2180, 2182, 2184, 2190, 2192, 2195, 2200, 2203, 2206, 2215, ! 2226, 2231, 2231, 2233, 2236, 2238, 2242, 2244, 2248, 2276, ! 2307, 2309, 2331, 2355, 2357, 2361, 2387, 2396, 2424, 2427, ! 2434, 2445, 2454, 2458, 2471, 2474, 2476, 2481, 2483, 2487, ! 2495, 2499, 2502, 2504, 2515, 2520, 2528, 2531, 2532, 2543, ! 2546, 2547, 2558, 2560, 2563, 2565, 2568, 2573, 2577, 2583, ! 2588, 2592, 2596, 2602, 2606, 2609, 2614, 2618, 2621, 2624, ! 2633, 2635, 2639, 2642, 2647, 2650, 2654, 2663, 2666, 2670, ! 2673, 2681, 2683, 2688, 2691, 2693, 2695, 2697, 2701, 2704, ! 2718, 2721, 2726, 2729, 2731, 2733, 2735, 2737, 2739, 2741, ! 2745, 2751, 2754, 2756, 2758, 2760, 2764, 2767, 2770, 2772, ! 2774, 2776, 2780, 2783, 2786, 2788, 2790, 2792, 2794, 2796, ! 2798, 2802, 2808, 2814, 2816, 2820, 2823, 2825, 2829, 2831, ! 2834, 2836, 2842, 2845, 2859, 2861, 2865, 2867, 2871, 2874, ! 2880, 2886, 2889, 2891, 2893, 2895, 2899, 2903, 2907, 2910, ! 2915, 2918, 2920, 2922, 2924, 2926, 2928, 2930, 2932, 2936, ! 2940, 2944, 2948, 2949, 2951, 2953, 2955, 2957, 2959, 2961, ! 2963, 2965, 2973, 2975, 2976, 2977, 2980, 2987, 2997, 2999, ! 3004, 3006, 3009, 3023, 3026, 3029, 3033, 3037, 3041, 3047, ! 3050, 3054, 3056, 3059, 3065, 3068, 3071, 3074, 3087, 3090, ! 3095, 3101, 3106, 3109, 3114, 3118, 3121, 3127, 3132, 3135, ! 3140, 3149, 3153, 3156, 3162, 3172, 3179, 3185, 3210, 3210, ! 3242, 3242, 3258, 3258, 3262, 3266, 3269, 3274, 3281, 3290, ! 3299, 3308, 3311, 3317, 3319, 3323, 3325, 3328, 3332, 3335, ! 3338, 3346, 3350, 3356, 3358, 3360, 3364, 3366, 3369, 3382, ! 3387, 3395, 3399, 3402, 3404, 3408, 3411, 3413, 3415, 3421, ! 3425, 3429, 3432, 3433, 3439, 3441, 3444, 3446, 3450, 3455, ! 3458, 3468, 3475, 3476, 3483, 3489, 3494, 3498, 3503, 3510, ! 3514, 3518, 3523, 3534, 3548, 3551, 3553, 3555, 3557, 3559, ! 3563, 3565, 3573, 3590, 3592, 3594, 3596, 3598, 3602, 3604, ! 3607, 3629, 3635, 3642, 3645, 3649, 3654, 3656, 3663, 3666, ! 3668, 3670, 3676, 3680, 3683, 3685, 3687, 3689, 3691, 3693, ! 3695, 3697, 3699, 3701, 3703, 3705, 3707, 3709, 3711, 3713, ! 3715, 3717, 3719, 3721, 3723, 3725, 3727, 3729, 3731, 3733, ! 3735, 3737, 3739, 3741, 3743, 3745, 3748, 3750 }; --- 569,647 ---- #if YYDEBUG != 0 static const short yyrline[] = { 0, ! 292, 293, 307, 309, 310, 314, 319, 323, 325, 328, ! 331, 335, 338, 340, 342, 343, 346, 348, 350, 353, ! 358, 363, 366, 370, 373, 377, 387, 391, 401, 403, ! 406, 411, 413, 417, 423, 423, 426, 426, 429, 429, ! 444, 444, 449, 454, 471, 494, 504, 505, 508, 509, ! 510, 511, 512, 515, 518, 521, 526, 531, 537, 539, ! 540, 559, 560, 561, 564, 578, 591, 594, 597, 600, ! 602, 604, 608, 614, 619, 624, 631, 642, 649, 651, ! 653, 657, 665, 667, 669, 671, 675, 688, 711, 714, ! 716, 717, 720, 726, 732, 734, 736, 738, 741, 745, ! 751, 753, 754, 757, 759, 762, 764, 765, 768, 771, ! 773, 775, 779, 784, 787, 789, 793, 798, 801, 805, ! 808, 811, 845, 861, 864, 868, 871, 875, 877, 879, ! 881, 883, 887, 889, 892, 897, 902, 907, 912, 915, ! 918, 922, 941, 948, 951, 954, 956, 958, 962, 966, ! 969, 971, 975, 978, 981, 990, 993, 996, 998, 1000, ! 1002, 1009, 1020, 1040, 1042, 1044, 1049, 1051, 1053, 1055, ! 1057, 1060, 1062, 1064, 1067, 1069, 1073, 1079, 1082, 1089, ! 1092, 1094, 1102, 1111, 1117, 1123, 1125, 1127, 1140, 1142, ! 1144, 1146, 1163, 1166, 1168, 1170, 1172, 1174, 1176, 1178, ! 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, ! 1200, 1202, 1204, 1206, 1208, 1215, 1217, 1234, 1237, 1238, ! 1239, 1242, 1244, 1247, 1249, 1250, 1252, 1254, 1258, 1260, ! 1261, 1264, 1268, 1288, 1289, 1290, 1292, 1294, 1296, 1304, ! 1325, 1330, 1337, 1344, 1346, 1355, 1360, 1383, 1427, 1428, ! 1431, 1434, 1437, 1440, 1442, 1445, 1484, 1491, 1493, 1495, ! 1497, 1499, 1501, 1516, 1531, 1542, 1554, 1561, 1610, 1612, ! 1616, 1618, 1622, 1625, 1630, 1632, 1636, 1649, 1650, 1656, ! 1667, 1675, 1681, 1686, 1688, 1693, 1700, 1702, 1706, 1710, ! 1716, 1719, 1721, 1723, 1725, 1733, 1735, 1737, 1740, 1742, ! 1744, 1746, 1751, 1757, 1759, 1770, 1773, 1775, 1778, 1793, ! 1796, 1798, 1800, 1804, 1807, 1815, 1816, 1817, 1818, 1822, ! 1826, 1840, 1858, 1859, 1860, 1863, 1865, 1868, 1870, 1873, ! 1875, 1878, 1881, 1885, 1902, 1904, 1922, 1928, 1929, 1935, ! 1943, 1945, 1954, 1962, 1964, 1975, 1978, 1982, 1985, 1989, ! 1994, 1997, 2001, 2004, 2006, 2008, 2010, 2017, 2019, 2020, ! 2021, 2025, 2028, 2032, 2034, 2037, 2040, 2043, 2049, 2052, ! 2055, 2057, 2059, 2061, 2065, 2069, 2073, 2076, 2079, 2083, ! 2086, 2088, 2092, 2143, 2158, 2160, 2163, 2165, 2169, 2170, ! 2172, 2174, 2176, 2180, 2189, 2192, 2194, 2196, 2202, 2204, ! 2207, 2212, 2215, 2218, 2227, 2238, 2243, 2243, 2245, 2248, ! 2250, 2254, 2256, 2260, 2288, 2319, 2321, 2343, 2367, 2369, ! 2373, 2399, 2408, 2470, 2473, 2480, 2491, 2500, 2504, 2517, ! 2520, 2522, 2527, 2529, 2533, 2541, 2545, 2548, 2550, 2561, ! 2566, 2574, 2577, 2578, 2589, 2592, 2593, 2604, 2606, 2609, ! 2611, 2614, 2619, 2623, 2629, 2634, 2638, 2642, 2648, 2652, ! 2655, 2660, 2664, 2667, 2670, 2679, 2681, 2685, 2688, 2693, ! 2696, 2700, 2709, 2712, 2716, 2719, 2727, 2729, 2734, 2737, ! 2739, 2741, 2743, 2747, 2750, 2764, 2767, 2772, 2775, 2777, ! 2779, 2781, 2783, 2785, 2787, 2791, 2797, 2800, 2802, 2804, ! 2806, 2810, 2813, 2816, 2818, 2820, 2822, 2826, 2829, 2832, ! 2834, 2836, 2838, 2840, 2842, 2846, 2852, 2858, 2860, 2864, ! 2867, 2869, 2873, 2875, 2878, 2880, 2886, 2889, 2903, 2905, ! 2909, 2911, 2915, 2918, 2924, 2930, 2933, 2935, 2937, 2939, ! 2943, 2947, 2951, 2954, 2959, 2962, 2964, 2966, 2968, 2970, ! 2972, 2974, 2976, 2980, 2984, 2988, 2992, 2993, 2995, 2997, ! 2999, 3001, 3003, 3005, 3007, 3009, 3017, 3019, 3020, 3021, ! 3024, 3031, 3041, 3043, 3048, 3050, 3053, 3067, 3070, 3073, ! 3077, 3081, 3085, 3091, 3094, 3098, 3100, 3103, 3109, 3112, ! 3115, 3118, 3131, 3134, 3139, 3145, 3150, 3153, 3158, 3162, ! 3165, 3171, 3176, 3179, 3184, 3193, 3197, 3200, 3206, 3216, ! 3223, 3229, 3254, 3254, 3286, 3286, 3302, 3302, 3306, 3310, ! 3313, 3318, 3325, 3334, 3343, 3352, 3355, 3361, 3363, 3367, ! 3369, 3372, 3376, 3379, 3382, 3390, 3394, 3400, 3402, 3404, ! 3408, 3410, 3413, 3426, 3431, 3439, 3441, 3445, 3448, 3450, ! 3454, 3457, 3459, 3461, 3467, 3471, 3475, 3478, 3479, 3485, ! 3487, 3490, 3492, 3496, 3501, 3504, 3514, 3521, 3522, 3529, ! 3535, 3540, 3544, 3549, 3556, 3560, 3564, 3569, 3580, 3594, ! 3597, 3599, 3601, 3603, 3607, 3609, 3617, 3634, 3636, 3638, ! 3640, 3642, 3646, 3649, 3653, 3655, 3658, 3680, 3686, 3693, ! 3696, 3700, 3705, 3707, 3714, 3717, 3719, 3721, 3727, 3731, ! 3734, 3736, 3738, 3740, 3742, 3744, 3746, 3748, 3750, 3752, ! 3754, 3756, 3758, 3760, 3762, 3764, 3766, 3768, 3770, 3772, ! 3774, 3776, 3778, 3780, 3782, 3784, 3786, 3788, 3790, 3792, ! 3794, 3796, 3799, 3801 }; *************** *** 657,700 **** "END_OF_SAVED_INPUT","')'","'}'","'!'","']'","program","extdefs","@1",".hush_warning", ".warning_ok","asm_keyword","lang_extdef","@2","extdef","extern_lang_string", ! "template_header","@3","template_parm_list","template_parm","overloaddef","ov_identifiers", ! "template_def","@4","@5","@6","@7","fn_tmpl_end","datadef","fndef","fn.def1", ! "fn.def2","return_id","return_init","base_init",".set_base_init","member_init_list", ! "member_init","identifier","notype_identifier","identifier_defn","explicit_instantiation", ! "template_type","template_type_name","tmpl.2","template_arg_list","template_arg", ! "template_instantiate_once","@8","template_instantiation","template_instantiate_some", ! "unop","expr","paren_expr_or_null","paren_cond_or_null","xcond","condition", ! "@9","already_scoped_stmt","nontrivial_exprlist","nonnull_exprlist","unary_expr", ! "@10","new_placement","new_initializer","regcast_or_absdcl","cast_expr","sub_cast_expr", ! "expr_no_commas","notype_unqualified_id","unqualified_id","expr_or_declarator", ! "direct_notype_declarator","primary","@11","@12","new","delete","boolean.literal", ! "string","nodecls","object","decl","declarator","fcast_or_absdcl","type_id", ! "typed_declspecs","typed_declspecs1","reserved_declspecs","declmods","typed_typespecs", ! "reserved_typespecquals","typespec","typespecqual_reserved","initdecls","notype_initdecls", ! "nomods_initdecls","maybeasm","initdcl0","@13","initdcl","@14","notype_initdcl0", ! "@15","nomods_initdcl0","@16","maybe_attribute","attributes","attribute","attribute_list", ! "attrib","any_word","identifiers_or_typenames","init","initlist","structsp", ! "@17","@18","maybecomma","maybecomma_warn","aggr","specialization","named_class_head_sans_basetype", ! "named_class_head_sans_basetype_defn","do_xref","do_xref_defn","named_class_head", ! "unnamed_class_head","class_head","maybe_base_class_list","base_class_list", ! "base_class","base_class.1","base_class_access_list","left_curly","opt.component_decl_list", ! "component_decl_list","component_decl","component_decl_1","components","notype_components", ! "component_declarator0","component_declarator","after_type_component_declarator0", ! "notype_component_declarator0","after_type_component_declarator","notype_component_declarator", ! "enumlist","enumerator","new_type_id","type_quals","nonempty_type_quals","nonmomentary_expr", ! "@19","after_type_declarator","qualified_type_name","nested_type","direct_after_type_declarator", ! "notype_declarator","complex_notype_declarator","complex_direct_notype_declarator", ! "qualified_id","notype_qualified_id","overqualified_id","functional_cast","type_name", ! "nested_name_specifier","nested_name_specifier_1","complete_type_name","complex_type_name", ! "ptr_to_mem","global_scope","new_declarator","direct_new_declarator","absdcl", ! "direct_abstract_declarator","stmts","errstmt",".pushlevel","maybe_label_decls", ! "label_decls","label_decl","compstmt_or_error","compstmt","simple_if","@20", ! "@21","implicitly_scoped_stmt","stmt","simple_stmt","@22","@23","@24","@25", ! "@26","@27","@28","@29","@30","@31","@32","@33","@34","@35","@36","try_block", ! "@37","@38","ansi_try_stmts","handler_seq","@39","type_specifier_seq","handler_args", ! "label_colon","forhead.1","forhead.2","maybe_type_qual","xexpr","asm_operands", ! "nonnull_asm_operands","asm_operand","asm_clobbers","parmlist","complex_parmlist", ! "parms","parms_comma","named_parm","parm","see_typename","bad_parm","maybe_raises", ! "ansi_raise_identifier","ansi_raise_identifiers","conversion_declarator","operator", ! "operator_name","" }; #endif --- 661,705 ---- "END_OF_SAVED_INPUT","')'","'}'","'!'","']'","program","extdefs","@1",".hush_warning", ".warning_ok","asm_keyword","lang_extdef","@2","extdef","extern_lang_string", ! "template_header","@3","template_parm_list","template_type_parm","template_parm", ! "overloaddef","ov_identifiers","template_def","@4","@5","@6","@7","fn_tmpl_end", ! "datadef","fndef","fn.def1","fn.def2","return_id","return_init","base_init", ! ".set_base_init","member_init_list","member_init","identifier","notype_identifier", ! "identifier_defn","explicit_instantiation","template_type","template_type_name", ! "tmpl.2","template_arg_list","template_arg","template_instantiate_once","@8", ! "template_instantiation","template_instantiate_some","unop","expr","paren_expr_or_null", ! "paren_cond_or_null","xcond","condition","@9","already_scoped_stmt","nontrivial_exprlist", ! "nonnull_exprlist","unary_expr","@10","new_placement","new_initializer","regcast_or_absdcl", ! "cast_expr","sub_cast_expr","expr_no_commas","notype_unqualified_id","unqualified_id", ! "expr_or_declarator","direct_notype_declarator","primary","@11","@12","new", ! "delete","boolean.literal","string","nodecls","object","decl","declarator","fcast_or_absdcl", ! "type_id","typed_declspecs","typed_declspecs1","reserved_declspecs","declmods", ! "typed_typespecs","reserved_typespecquals","typespec","typespecqual_reserved", ! "initdecls","notype_initdecls","nomods_initdecls","maybeasm","initdcl0","@13", ! "initdcl","@14","notype_initdcl0","@15","nomods_initdcl0","@16","maybe_attribute", ! "attributes","attribute","attribute_list","attrib","any_word","identifiers_or_typenames", ! "init","initlist","structsp","@17","@18","maybecomma","maybecomma_warn","aggr", ! "specialization","named_class_head_sans_basetype","named_class_head_sans_basetype_defn", ! "do_xref","do_xref_defn","named_class_head","unnamed_class_head","class_head", ! "maybe_base_class_list","base_class_list","base_class","base_class.1","base_class_access_list", ! "left_curly","opt.component_decl_list","component_decl_list","component_decl", ! "component_decl_1","components","notype_components","component_declarator0", ! "component_declarator","after_type_component_declarator0","notype_component_declarator0", ! "after_type_component_declarator","notype_component_declarator","enumlist","enumerator", ! "new_type_id","type_quals","nonempty_type_quals","nonmomentary_expr","@19","after_type_declarator", ! "qualified_type_name","nested_type","direct_after_type_declarator","notype_declarator", ! "complex_notype_declarator","complex_direct_notype_declarator","qualified_id", ! "notype_qualified_id","overqualified_id","functional_cast","type_name","nested_name_specifier", ! "nested_name_specifier_1","complete_type_name","complex_type_name","ptr_to_mem", ! "global_scope","new_declarator","direct_new_declarator","absdcl","direct_abstract_declarator", ! "stmts","errstmt",".pushlevel","maybe_label_decls","label_decls","label_decl", ! "compstmt_or_error","compstmt","simple_if","@20","@21","implicitly_scoped_stmt", ! "stmt","simple_stmt","@22","@23","@24","@25","@26","@27","@28","@29","@30","@31", ! "@32","@33","@34","@35","@36","try_block","@37","@38","ansi_try_stmts","handler_seq", ! "@39","type_specifier_seq","handler_args","label_colon","forhead.1","forhead.2", ! "maybe_type_qual","xexpr","asm_operands","nonnull_asm_operands","asm_operand", ! "asm_clobbers","parmlist","complex_parmlist","parms","parms_comma","named_parm", ! "full_parm","parm","see_typename","bad_parm","maybe_raises","ansi_raise_identifier", ! "ansi_raise_identifiers","conversion_declarator","operator","operator_name", ! "" }; #endif *************** *** 703,778 **** 106, 106, 108, 107, 107, 109, 110, 111, 111, 113, 112, 114, 114, 114, 114, 114, 114, 114, 114, 114, ! 115, 117, 116, 118, 118, 119, 119, 119, 120, 121, ! 121, 123, 122, 124, 122, 125, 122, 126, 122, 122, ! 122, 122, 122, 122, 122, 122, 127, 127, 127, 127, ! 127, 128, 128, 128, 128, 128, 128, 128, 128, 128, ! 128, 128, 129, 129, 129, 129, 129, 129, 129, 129, ! 130, 130, 130, 130, 131, 131, 131, 131, 131, 132, ! 133, 133, 133, 133, 134, 135, 136, 136, 136, 136, ! 137, 137, 137, 137, 137, 137, 137, 137, 138, 138, ! 138, 139, 139, 140, 140, 140, 141, 141, 141, 141, ! 142, 143, 143, 144, 145, 145, 146, 146, 148, 147, ! 149, 149, 150, 150, 151, 151, 151, 151, 151, 152, ! 152, 153, 153, 154, 154, 155, 155, 155, 157, 156, ! 156, 158, 158, 158, 158, 159, 159, 159, 159, 160, ! 160, 161, 162, 161, 161, 161, 161, 161, 161, 161, ! 161, 161, 161, 161, 161, 161, 161, 161, 161, 161, ! 161, 161, 161, 161, 163, 163, 164, 164, 164, 164, ! 165, 165, 166, 166, 166, 167, 167, 167, 167, 168, ! 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, ! 168, 168, 168, 168, 168, 168, 168, 168, 168, 168, ! 168, 168, 168, 168, 169, 169, 169, 169, 170, 170, ! 171, 171, 171, 171, 172, 172, 172, 173, 173, 173, ! 173, 173, 173, 174, 173, 175, 173, 173, 173, 173, ! 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, ! 173, 173, 173, 173, 173, 173, 173, 173, 173, 173, ! 173, 173, 173, 176, 176, 177, 177, 178, 178, 179, ! 179, 180, 181, 181, 182, 182, 182, 182, 182, 182, ! 182, 183, 183, 184, 184, 185, 185, 185, 185, 185, ! 186, 186, 187, 187, 187, 187, 187, 188, 188, 188, ! 189, 189, 189, 189, 190, 190, 190, 190, 191, 191, ! 192, 192, 192, 192, 192, 192, 192, 193, 193, 193, ! 194, 194, 195, 195, 196, 196, 197, 197, 199, 198, ! 198, 201, 200, 200, 203, 202, 202, 205, 204, 204, ! 206, 206, 207, 207, 208, 209, 209, 210, 210, 210, ! 210, 210, 211, 211, 211, 211, 212, 212, 213, 213, ! 213, 213, 213, 214, 214, 214, 214, 214, 214, 216, ! 215, 215, 217, 215, 215, 215, 215, 215, 215, 218, ! 218, 219, 219, 220, 220, 220, 220, 220, 221, 222, ! 222, 222, 222, 222, 222, 223, 224, 225, 226, 226, ! 227, 228, 228, 229, 229, 229, 230, 230, 231, 231, ! 232, 232, 232, 233, 233, 233, 233, 234, 235, 235, ! 235, 235, 236, 236, 236, 237, 237, 237, 237, 238, ! 238, 238, 238, 238, 238, 238, 239, 239, 239, 240, ! 240, 240, 241, 241, 242, 242, 243, 243, 243, 244, ! 244, 244, 244, 245, 245, 245, 246, 246, 246, 246, ! 247, 247, 248, 248, 249, 249, 249, 250, 250, 251, ! 251, 253, 252, 254, 254, 254, 254, 254, 254, 255, ! 255, 256, 257, 257, 257, 257, 257, 257, 257, 257, ! 257, 258, 258, 258, 258, 258, 258, 259, 259, 259, ! 259, 259, 259, 260, 260, 260, 260, 260, 260, 260, ! 260, 261, 262, 263, 263, 264, 264, 264, 265, 265, ! 266, 266, 267, 267, 268, 268, 269, 269, 270, 270, ! 271, 272, 272, 272, 272, 272, 272, 272, 273, 273, ! 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, ! 274, 275, 275, 275, 275, 275, 275, 275, 275, 275, ! 275, 275, 276, 276, 276, 276, 277, 278, 279, 279, ! 280, 280, 281, 282, 282, 283, 283, 283, 283, 285, ! 286, 284, 287, 287, 288, 288, 289, 289, 290, 289, ! 289, 291, 292, 289, 293, 294, 289, 295, 296, 297, ! 289, 298, 299, 300, 289, 301, 289, 302, 289, 303, ! 289, 304, 289, 289, 289, 289, 289, 289, 289, 289, ! 289, 289, 289, 289, 289, 289, 289, 306, 307, 305, ! 308, 308, 308, 309, 310, 309, 311, 311, 312, 312, ! 313, 313, 314, 314, 314, 315, 315, 315, 315, 316, ! 316, 317, 317, 317, 318, 318, 319, 319, 320, 321, ! 321, 322, 322, 322, 323, 323, 323, 323, 323, 323, ! 323, 323, 323, 323, 324, 324, 324, 324, 324, 324, ! 325, 325, 326, 326, 326, 326, 326, 326, 327, 327, ! 328, 329, 329, 330, 330, 331, 332, 332, 333, 333, ! 333, 333, 334, 335, 335, 335, 335, 335, 335, 335, ! 335, 335, 335, 335, 335, 335, 335, 335, 335, 335, ! 335, 335, 335, 335, 335, 335, 335, 335, 335, 335, ! 335, 335, 335, 335, 335, 335, 335, 335 }; --- 708,784 ---- 106, 106, 108, 107, 107, 109, 110, 111, 111, 113, 112, 114, 114, 114, 114, 114, 114, 114, 114, 114, ! 115, 117, 116, 118, 118, 119, 119, 120, 120, 120, ! 121, 122, 122, 124, 123, 125, 123, 126, 123, 127, ! 123, 123, 123, 123, 123, 123, 123, 123, 128, 128, ! 128, 128, 128, 129, 129, 129, 129, 129, 129, 129, ! 129, 129, 129, 129, 130, 130, 130, 130, 130, 130, ! 130, 130, 131, 131, 131, 131, 132, 132, 132, 132, ! 132, 133, 134, 134, 134, 134, 135, 136, 137, 137, ! 137, 137, 138, 138, 138, 138, 138, 138, 138, 138, ! 139, 139, 139, 140, 140, 141, 141, 141, 142, 142, ! 142, 142, 143, 144, 144, 144, 145, 146, 146, 147, ! 147, 149, 148, 150, 150, 151, 151, 152, 152, 152, ! 152, 152, 153, 153, 154, 154, 155, 155, 156, 156, ! 156, 158, 157, 157, 159, 159, 159, 159, 160, 160, ! 160, 160, 161, 161, 162, 163, 162, 162, 162, 162, ! 162, 162, 162, 162, 162, 162, 162, 162, 162, 162, ! 162, 162, 162, 162, 162, 162, 162, 164, 164, 165, ! 165, 165, 165, 166, 166, 167, 167, 167, 168, 168, ! 168, 168, 169, 169, 169, 169, 169, 169, 169, 169, ! 169, 169, 169, 169, 169, 169, 169, 169, 169, 169, ! 169, 169, 169, 169, 169, 169, 169, 170, 170, 170, ! 170, 171, 171, 172, 172, 172, 172, 172, 173, 173, ! 173, 173, 174, 174, 174, 174, 174, 174, 175, 174, ! 176, 174, 174, 174, 174, 174, 174, 174, 174, 174, ! 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, ! 174, 174, 174, 174, 174, 174, 174, 174, 177, 177, ! 178, 178, 179, 179, 180, 180, 181, 182, 182, 183, ! 183, 183, 183, 183, 183, 183, 184, 184, 185, 185, ! 186, 186, 186, 186, 186, 187, 187, 188, 188, 188, ! 188, 188, 189, 189, 189, 190, 190, 190, 190, 191, ! 191, 191, 191, 192, 192, 193, 193, 193, 193, 193, ! 193, 193, 194, 194, 194, 195, 195, 196, 196, 197, ! 197, 198, 198, 200, 199, 199, 202, 201, 201, 204, ! 203, 203, 206, 205, 205, 207, 207, 208, 208, 209, ! 210, 210, 211, 211, 211, 211, 211, 212, 212, 212, ! 212, 213, 213, 214, 214, 214, 214, 214, 215, 215, ! 215, 215, 215, 215, 217, 216, 216, 218, 216, 216, ! 216, 216, 216, 216, 219, 219, 220, 220, 221, 221, ! 221, 221, 221, 222, 223, 223, 223, 223, 223, 223, ! 224, 225, 226, 227, 227, 228, 229, 229, 230, 230, ! 230, 231, 231, 232, 232, 233, 233, 233, 234, 234, ! 234, 234, 235, 236, 236, 236, 236, 237, 237, 237, ! 238, 238, 238, 238, 239, 239, 239, 239, 239, 239, ! 239, 240, 240, 240, 241, 241, 241, 242, 242, 243, ! 243, 244, 244, 244, 245, 245, 245, 245, 246, 246, ! 246, 247, 247, 247, 247, 248, 248, 249, 249, 250, ! 250, 250, 251, 251, 252, 252, 254, 253, 255, 255, ! 255, 255, 255, 255, 256, 256, 257, 258, 258, 258, ! 258, 258, 258, 258, 258, 258, 259, 259, 259, 259, ! 259, 259, 260, 260, 260, 260, 260, 260, 261, 261, ! 261, 261, 261, 261, 261, 262, 263, 264, 264, 265, ! 265, 265, 266, 266, 267, 267, 268, 268, 269, 269, ! 270, 270, 271, 271, 272, 273, 273, 273, 273, 273, ! 273, 273, 274, 274, 275, 275, 275, 275, 275, 275, ! 275, 275, 275, 275, 275, 276, 276, 276, 276, 276, ! 276, 276, 276, 276, 276, 276, 277, 277, 277, 277, ! 278, 279, 280, 280, 281, 281, 282, 283, 283, 284, ! 284, 284, 284, 286, 287, 285, 288, 288, 289, 289, ! 290, 290, 291, 290, 290, 292, 293, 290, 294, 295, ! 290, 296, 297, 298, 290, 299, 300, 301, 290, 302, ! 290, 303, 290, 304, 290, 305, 290, 290, 290, 290, ! 290, 290, 290, 290, 290, 290, 290, 290, 290, 290, ! 290, 307, 308, 306, 309, 309, 309, 310, 311, 310, ! 312, 312, 313, 313, 314, 314, 314, 315, 315, 315, ! 316, 316, 316, 316, 317, 317, 318, 318, 318, 319, ! 319, 320, 320, 321, 322, 322, 323, 323, 323, 324, ! 324, 324, 324, 324, 324, 324, 324, 324, 324, 325, ! 325, 325, 325, 325, 326, 326, 327, 327, 327, 327, ! 327, 327, 328, 328, 329, 329, 330, 331, 331, 332, ! 332, 333, 334, 334, 335, 335, 335, 335, 336, 337, ! 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, ! 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, ! 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, ! 337, 337, 337, 337 }; *************** *** 780,2704 **** 0, 1, 0, 2, 2, 0, 0, 1, 1, 0, 2, 1, 1, 1, 1, 5, 4, 3, 4, 4, ! 1, 0, 5, 1, 3, 2, 4, 1, 3, 1, ! 3, 0, 5, 0, 5, 0, 5, 0, 5, 3, ! 3, 6, 7, 4, 3, 3, 1, 1, 1, 1, ! 1, 2, 3, 3, 3, 3, 2, 2, 2, 2, ! 2, 1, 3, 4, 3, 5, 4, 3, 3, 2, ! 3, 3, 2, 1, 6, 4, 3, 3, 2, 2, ! 1, 3, 4, 2, 3, 0, 0, 1, 3, 2, ! 3, 1, 4, 2, 4, 2, 4, 2, 1, 1, ! 1, 1, 1, 1, 1, 1, 3, 3, 4, 4, ! 3, 4, 4, 0, 1, 3, 1, 1, 0, 6, ! 0, 1, 0, 2, 1, 1, 1, 1, 1, 1, ! 1, 1, 3, 1, 3, 0, 1, 1, 0, 8, ! 1, 2, 4, 4, 1, 3, 3, 3, 3, 1, ! 1, 1, 0, 3, 2, 2, 2, 2, 2, 2, ! 4, 2, 4, 2, 3, 3, 4, 4, 5, 5, ! 6, 2, 4, 5, 3, 3, 3, 1, 3, 2, ! 3, 4, 1, 2, 5, 1, 4, 4, 4, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ! 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, ! 3, 3, 1, 2, 3, 1, 1, 1, 1, 1, ! 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, ! 1, 3, 3, 0, 4, 0, 6, 2, 4, 2, ! 2, 1, 4, 1, 7, 7, 7, 7, 4, 4, ! 2, 2, 1, 4, 2, 2, 2, 5, 3, 5, ! 3, 4, 6, 1, 2, 1, 2, 1, 1, 1, ! 2, 0, 2, 2, 3, 3, 3, 3, 3, 2, ! 2, 1, 1, 1, 2, 2, 2, 2, 1, 1, ! 1, 1, 2, 2, 3, 3, 4, 1, 2, 2, ! 1, 1, 2, 2, 1, 2, 2, 3, 1, 2, ! 1, 1, 1, 4, 4, 4, 4, 1, 1, 1, ! 1, 3, 1, 3, 1, 3, 0, 4, 0, 7, ! 4, 0, 7, 4, 0, 7, 4, 0, 7, 4, ! 0, 1, 1, 2, 6, 1, 3, 0, 1, 4, ! 6, 4, 1, 1, 1, 1, 1, 3, 1, 2, ! 3, 4, 1, 1, 3, 4, 6, 3, 5, 0, ! 7, 4, 0, 6, 3, 2, 2, 4, 1, 0, ! 1, 0, 1, 1, 2, 2, 2, 2, 3, 2, ! 2, 2, 3, 3, 1, 2, 0, 0, 3, 3, ! 2, 1, 1, 0, 1, 2, 1, 3, 1, 2, ! 1, 4, 4, 1, 1, 2, 2, 1, 0, 1, ! 4, 3, 1, 2, 2, 2, 2, 2, 2, 2, ! 2, 4, 2, 1, 5, 3, 0, 1, 3, 0, ! 1, 3, 1, 1, 1, 1, 4, 6, 4, 4, ! 6, 4, 3, 4, 6, 4, 4, 6, 4, 3, ! 1, 3, 1, 3, 2, 1, 6, 0, 2, 1, ! 2, 0, 2, 3, 3, 2, 2, 3, 1, 1, ! 1, 2, 5, 5, 3, 5, 4, 3, 3, 2, ! 1, 3, 3, 2, 2, 3, 1, 3, 3, 2, ! 2, 3, 1, 5, 5, 3, 5, 3, 3, 4, ! 3, 2, 2, 1, 2, 4, 4, 2, 1, 1, ! 1, 2, 2, 2, 1, 2, 1, 2, 2, 3, ! 1, 3, 2, 3, 2, 2, 3, 1, 3, 4, ! 3, 2, 2, 1, 3, 2, 2, 1, 2, 3, ! 1, 3, 1, 5, 3, 4, 3, 4, 2, 2, ! 3, 2, 1, 1, 2, 2, 2, 0, 0, 1, ! 1, 2, 3, 1, 2, 3, 5, 6, 5, 0, ! 0, 6, 1, 2, 1, 1, 1, 2, 0, 4, ! 1, 0, 0, 6, 0, 0, 7, 0, 0, 0, ! 10, 0, 0, 0, 10, 0, 7, 0, 5, 0, ! 7, 0, 4, 2, 2, 2, 3, 6, 8, 10, ! 12, 4, 3, 2, 2, 1, 1, 0, 0, 7, ! 1, 2, 2, 0, 0, 5, 1, 1, 3, 3, ! 2, 2, 3, 4, 4, 3, 4, 6, 6, 0, ! 1, 0, 1, 1, 0, 1, 1, 3, 4, 1, ! 3, 0, 1, 1, 1, 2, 2, 2, 1, 1, ! 2, 2, 2, 2, 1, 3, 2, 4, 2, 4, ! 2, 2, 2, 2, 2, 2, 1, 2, 1, 1, ! 0, 0, 1, 0, 4, 1, 1, 3, 0, 3, ! 3, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, ! 2, 3, 2, 2, 4, 4, 3, 2 }; static const short yydefact[] = { 3, ! 10, 10, 5, 0, 4, 0, 217, 519, 302, 312, ! 470, 0, 8, 9, 0, 0, 384, 0, 703, 0, ! 531, 218, 62, 0, 0, 691, 0, 74, 21, 0, ! 11, 6, 0, 15, 14, 13, 12, 272, 0, 520, ! 114, 226, 497, 0, 292, 0, 291, 305, 0, 325, ! 311, 0, 395, 397, 398, 403, 402, 379, 301, 525, ! 481, 0, 225, 227, 480, 0, 521, 313, 468, 0, ! 0, 216, 60, 61, 523, 0, 0, 99, 100, 101, ! 373, 376, 0, 527, 0, 377, 0, 0, 0, 30, ! 0, 302, 0, 22, 0, 0, 395, 0, 0, 0, ! 0, 495, 0, 0, 0, 494, 0, 0, 0, 226, ! 0, 0, 0, 225, 227, 468, 0, 3, 0, 0, ! 0, 0, 397, 398, 694, 0, 86, 81, 272, 0, ! 0, 58, 524, 121, 468, 0, 472, 59, 0, 0, ! 0, 0, 0, 321, 282, 479, 283, 491, 0, 468, ! 304, 303, 57, 293, 0, 323, 0, 298, 318, 319, ! 294, 307, 309, 320, 0, 52, 385, 386, 387, 388, ! 401, 105, 104, 106, 390, 396, 392, 114, 391, 404, ! 404, 418, 0, 471, 306, 70, 0, 73, 529, 513, ! 482, 522, 0, 526, 0, 738, 734, 733, 731, 713, ! 718, 719, 0, 725, 724, 710, 711, 709, 728, 717, ! 714, 715, 716, 720, 721, 707, 708, 704, 705, 706, ! 730, 722, 723, 712, 729, 0, 726, 637, 305, 638, ! 699, 470, 229, 270, 0, 0, 0, 0, 153, 266, ! 264, 242, 268, 269, 0, 0, 0, 0, 0, 0, ! 0, 126, 125, 0, 127, 128, 0, 0, 213, 129, ! 0, 115, 0, 186, 0, 190, 183, 118, 228, 152, ! 0, 0, 230, 231, 0, 117, 289, 305, 290, 514, ! 253, 244, 0, 0, 0, 395, 375, 0, 370, 528, ! 0, 130, 131, 0, 0, 0, 0, 29, 0, 108, ! 404, 122, 107, 0, 493, 0, 492, 100, 101, 215, ! 224, 0, 501, 223, 0, 500, 508, 509, 0, 0, ! 18, 10, 0, 7, 7, 46, 45, 694, 0, 32, ! 40, 36, 34, 41, 38, 327, 80, 87, 84, 0, ! 0, 272, 0, 0, 0, 568, 63, 574, 65, 111, ! 506, 0, 669, 670, 151, 0, 150, 664, 687, 0, ! 289, 305, 290, 0, 663, 665, 692, 675, 0, 511, ! 0, 0, 0, 477, 0, 476, 0, 0, 0, 468, ! 68, 56, 71, 0, 55, 468, 0, 472, 490, 0, ! 295, 296, 0, 53, 69, 54, 72, 300, 299, 310, ! 694, 326, 393, 389, 394, 405, 399, 400, 434, 0, ! 0, 437, 440, 0, 0, 423, 0, 694, 308, 0, ! 0, 341, 469, 496, 530, 0, 0, 727, 732, 468, ! 468, 0, 468, 737, 0, 0, 0, 160, 0, 0, ! 162, 0, 0, 0, 0, 0, 0, 0, 0, 159, ! 156, 155, 157, 0, 0, 0, 0, 214, 0, 113, ! 158, 0, 0, 184, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 238, 240, 241, 274, ! 273, 0, 0, 0, 0, 0, 164, 466, 0, 172, ! 271, 220, 0, 691, 219, 256, 257, 0, 284, 548, ! 544, 553, 0, 472, 468, 468, 468, 286, 551, 0, ! 518, 288, 0, 287, 255, 0, 251, 265, 267, 515, ! 0, 252, 110, 109, 463, 382, 461, 372, 0, 314, ! 0, 0, 315, 316, 317, 31, 0, 24, 690, 305, ! 0, 689, 28, 119, 112, 499, 498, 502, 0, 17, ! 20, 19, 327, 51, 47, 49, 50, 48, 44, 0, ! 0, 0, 0, 341, 102, 92, 103, 0, 85, 88, ! 0, 0, 0, 363, 0, 359, 82, 0, 0, 64, ! 67, 575, 569, 468, 468, 668, 682, 674, 672, 548, ! 544, 0, 683, 468, 686, 688, 684, 0, 685, 468, ! 667, 681, 673, 671, 666, 693, 677, 679, 0, 510, ! 473, 475, 474, 0, 0, 489, 0, 341, 322, 485, ! 0, 0, 0, 488, 0, 478, 297, 324, 341, 327, ! 415, 0, 414, 406, 407, 409, 0, 411, 433, 429, ! 428, 217, 519, 468, 0, 662, 694, 430, 438, 443, ! 444, 694, 694, 431, 441, 694, 0, 378, 425, 424, ! 426, 427, 327, 696, 305, 697, 0, 0, 0, 340, ! 342, 343, 736, 735, 699, 699, 699, 0, 0, 0, ! 518, 0, 0, 519, 0, 154, 0, 0, 0, 0, ! 0, 0, 233, 232, 0, 181, 116, 217, 519, 218, ! 0, 0, 364, 380, 0, 212, 211, 654, 653, 0, ! 209, 208, 206, 207, 205, 204, 203, 200, 201, 202, ! 198, 199, 193, 194, 195, 196, 197, 191, 192, 0, ! 0, 0, 0, 0, 0, 166, 178, 0, 0, 165, ! 468, 468, 0, 468, 465, 538, 0, 0, 0, 0, ! 259, 0, 261, 0, 512, 547, 546, 543, 542, 690, ! 0, 0, 562, 0, 0, 559, 285, 560, 549, 468, ! 662, 472, 548, 544, 0, 0, 468, 228, 0, 514, ! 0, 0, 0, 383, 0, 382, 149, 148, 147, 146, ! 0, 23, 390, 396, 0, 16, 341, 33, 37, 35, ! 39, 0, 0, 90, 0, 94, 0, 98, 0, 96, ! 0, 360, 0, 83, 66, 0, 576, 0, 570, 571, ! 507, 504, 547, 543, 548, 544, 480, 0, 468, 549, ! 548, 544, 0, 228, 0, 514, 505, 0, 0, 676, ! 331, 468, 468, 468, 487, 337, 341, 0, 0, 417, ! 416, 410, 0, 0, 436, 341, 0, 77, 0, 327, ! 327, 0, 327, 0, 341, 0, 695, 0, 0, 338, ! 344, 701, 700, 702, 243, 161, 0, 0, 163, 187, ! 189, 188, 249, 250, 0, 0, 0, 0, 235, 0, ! 0, 0, 0, 182, 0, 236, 239, 176, 175, 168, ! 0, 167, 180, 0, 0, 535, 533, 0, 536, 472, ! 173, 0, 0, 262, 0, 0, 545, 541, 552, 468, ! 561, 550, 555, 0, 557, 0, 548, 544, 516, 517, ! 0, 254, 464, 462, 374, 0, 25, 0, 0, 0, ! 42, 91, 89, 0, 0, 0, 0, 361, 357, 0, ! 0, 217, 580, 592, 595, 0, 568, 0, 0, 0, ! 0, 0, 0, 218, 626, 0, 650, 0, 587, 0, ! 0, 305, 0, 564, 585, 591, 563, 586, 627, 0, ! 598, 602, 572, 547, 543, 482, 549, 517, 678, 680, ! 329, 486, 483, 484, 335, 334, 0, 0, 408, 341, ! 341, 76, 453, 468, 217, 519, 0, 439, 445, 446, ! 694, 694, 341, 341, 442, 0, 432, 698, 328, 348, ! 0, 0, 0, 0, 0, 0, 368, 0, 0, 365, ! 185, 210, 123, 0, 169, 170, 177, 179, 534, 532, ! 539, 537, 0, 174, 0, 258, 260, 558, 468, 556, ! 371, 27, 0, 43, 93, 97, 95, 362, 0, 573, ! 567, 579, 641, 568, 568, 568, 0, 0, 0, 612, ! 614, 615, 616, 0, 0, 0, 642, 568, 651, 0, ! 588, 280, 694, 0, 281, 0, 694, 0, 694, 0, ! 0, 577, 566, 565, 589, 625, 624, 568, 568, 0, ! 0, 332, 412, 413, 452, 449, 435, 0, 0, 341, ! 327, 327, 447, 450, 354, 355, 356, 353, 0, 346, ! 349, 339, 0, 0, 0, 0, 366, 0, 0, 123, ! 237, 0, 171, 540, 263, 554, 120, 358, 0, 0, ! 0, 583, 0, 0, 568, 643, 0, 646, 0, 0, ! 608, 0, 617, 0, 623, 628, 0, 276, 327, 278, ! 279, 327, 0, 0, 0, 275, 277, 578, 568, 0, ! 0, 330, 336, 0, 75, 341, 341, 460, 341, 341, ! 0, 0, 348, 0, 0, 245, 246, 247, 248, 0, ! 369, 124, 467, 134, 0, 581, 593, 584, 596, 647, ! 645, 0, 644, 141, 0, 305, 0, 0, 0, 613, ! 622, 0, 0, 590, 138, 0, 137, 0, 333, 459, ! 456, 454, 457, 448, 451, 347, 345, 217, 0, 367, ! 0, 568, 0, 0, 0, 0, 606, 694, 610, 609, ! 0, 631, 0, 629, 655, 0, 599, 603, 0, 0, ! 0, 350, 352, 135, 582, 569, 594, 145, 132, 0, ! 0, 649, 0, 648, 568, 327, 0, 633, 632, 634, ! 0, 0, 656, 657, 618, 0, 0, 455, 458, 0, ! 142, 0, 0, 597, 607, 341, 611, 630, 0, 655, ! 0, 0, 0, 0, 351, 0, 0, 133, 0, 635, ! 0, 0, 619, 658, 600, 604, 144, 143, 139, 0, ! 659, 0, 0, 0, 0, 0, 0, 0, 660, 0, ! 620, 601, 605, 140, 0, 0, 636, 0, 0, 639, ! 640, 661, 621, 0, 0, 0 }; ! static const short yydefgoto[] = { 1344, ! 1, 2, 119, 561, 977, 3, 4, 31, 32, 33, ! 299, 547, 548, 34, 91, 35, 570, 572, 571, 573, ! 569, 36, 37, 38, 411, 128, 129, 130, 338, 579, ! 580, 535, 581, 176, 39, 40, 41, 134, 261, 262, ! 302, 805, 303, 1141, 263, 978, 1271, 1206, 1226, 1227, ! 1326, 1267, 292, 786, 264, 444, 496, 750, 265, 266, ! 267, 293, 269, 506, 311, 43, 270, 456, 1043, 271, ! 272, 273, 274, 131, 275, 979, 401, 516, 770, 980, ! 45, 161, 981, 47, 162, 439, 163, 143, 155, 49, ! 628, 144, 1110, 402, 1184, 156, 1111, 50, 1031, 680, ! 681, 682, 1129, 1130, 1131, 960, 713, 714, 51, 539, ! 288, 903, 795, 52, 53, 54, 55, 180, 181, 56, ! 57, 58, 407, 644, 645, 646, 647, 183, 414, 415, ! 416, 417, 658, 664, 659, 1018, 660, 661, 1019, 1020, ! 536, 537, 497, 776, 59, 371, 372, 145, 60, 61, ! 146, 147, 113, 63, 507, 280, 281, 282, 65, 283, ! 67, 68, 179, 69, 284, 755, 756, 767, 519, 983, ! 984, 1151, 828, 829, 830, 347, 985, 986, 1074, 1242, ! 1153, 987, 988, 1179, 1075, 1243, 1076, 1244, 1108, 1286, ! 1324, 1109, 1287, 1325, 1275, 1219, 1277, 1162, 989, 1222, ! 1280, 1254, 1298, 1320, 1217, 1328, 990, 991, 992, 1090, ! 720, 1282, 1283, 1284, 1330, 364, 772, 366, 367, 368, ! 369, 107, 618, 1169, 676, 677, 434, 71, 72 }; ! static const short yypact[] = { 71, ! 88,-32768,-32768, 2859,-32768, 188,-32768, 266, 64,-32768, ! -32768, 555,-32768,-32768, 140, 146,-32768, 235,-32768, 1989, ! -32768, 237,-32768, 1666, 1666,-32768, 1814,-32768,-32768, 222, ! -32768, 285, 3383,-32768,-32768,-32768,-32768, 201, 286, 315, ! -32768,-32768, 80, 1865,-32768, 4890,-32768, 846, 619,-32768, ! -32768, 142,-32768,-32768,-32768,-32768,-32768, 316, 1575,-32768, ! -32768, 675,-32768,-32768,-32768, 347,-32768,-32768,-32768, 215, ! 3638,-32768,-32768,-32768,-32768, 8393, 4228,-32768, 266, 237, ! 284, 340, 315,-32768, 215,-32768, 215, 8393, 8393,-32768, ! 623,-32768, 237,-32768, 2940, 4475, 399, 215, 8393, 266, ! 2258,-32768, 410, 245, 2258,-32768, 420, 2904, 2904, 296, ! 325, 80, 331, 345, 348,-32768, 444, 361, 2291, 262, ! 2940, 9527, 664, 847, 375, 475,-32768, 382, 149, 119, ! 119,-32768,-32768, 387,-32768, 6095, 390,-32768, 3062, 3062, ! 4178, 1327, 637,-32768,-32768, 242,-32768,-32768, 347,-32768, ! -32768,-32768,-32768, 846, 688,-32768, 1462,-32768,-32768,-32768, ! 959, 730,-32768,-32768, 2940,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768,-32768, 315, 871,-32768, 443, ! 443,-32768, 2169,-32768, 730,-32768, 469, 861,-32768,-32768, ! -32768,-32768, 3286,-32768, 155,-32768, 419, 499,-32768,-32768, ! -32768,-32768, 463,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768, 485,-32768,-32768, 730, 1575, ! 342, 504,-32768,-32768, 3906, 9334, 542, 573,-32768,-32768, ! -32768,-32768,-32768,-32768, 577, 588, 616, 643, 646, 420, ! 9085,-32768,-32768, 9085,-32768,-32768, 9085, 6659, 4696,-32768, ! 41,-32768, 9085,-32768, 8480,-32768,-32768, 9696,-32768, 898, ! 3155, 8563,-32768, 678, 713,-32768, 1174, 2042, 3006,-32768, ! 157,-32768, 393, 808, 2940, 399,-32768, 420, 622,-32768, ! 630, 666, 9604, 647, 656, 674, 780,-32768, 4228,-32768, ! 443,-32768,-32768, 282,-32768, 195,-32768,-32768,-32768,-32768, ! -32768, 2258,-32768,-32768, 2258,-32768,-32768,-32768, 3286, 42, ! -32768, 686, 4228,-32768,-32768,-32768,-32768, 375, 732,-32768, ! -32768,-32768,-32768,-32768,-32768, 589,-32768, 209,-32768, 6749, ! 8650,-32768, 119, 119, 745,-32768,-32768,-32768,-32768,-32768, ! 803, 721,-32768,-32768, 666, 726, 9604, 74, 2165, 9527, ! 2165, 3271, 3772, 742,-32768, 143, 9420, 763, 776,-32768, ! 749, 8650, 3372,-32768, 3372,-32768, 3542, 3542, 748,-32768, ! -32768,-32768, 861, 2940,-32768,-32768, 6197, 751,-32768, 4114, ! 959, 846, 2940,-32768,-32768,-32768, 861,-32768,-32768,-32768, ! 375,-32768,-32768,-32768,-32768, 764,-32768,-32768,-32768, 8650, ! 39, 1890, 9437, 72, 1839,-32768, 269, 375, 730, 3218, ! 759, 832,-32768,-32768,-32768, 794, 801,-32768,-32768,-32768, ! -32768, 229,-32768,-32768, 8650, 504, 6659,-32768, 191, 6659, ! -32768, 8650, 8737, 9085, 8393, 3218, 3218, 3218, 3218,-32768, ! -32768,-32768,-32768, 767, 790, 745, 812,-32768, 8393,-32768, ! -32768, 2485, 6659,-32768, 8650, 8650, 6839, 8650, 8650, 8650, ! 8650, 8650, 8650, 8650, 8650, 8650, 8650, 8650, 8650, 8650, ! 8650, 8650, 8650, 8650, 8650, 8650,-32768,-32768,-32768,-32768, ! -32768, 8650, 8650, 8650, 8393, 997, 558, 225, 7388,-32768, ! -32768, 266, 873, 920,-32768, 477, 543, 631,-32768, 99, ! 99,-32768, 3482, 817, 848, 894,-32768,-32768, 539, 7863, ! 1305,-32768, 252,-32768,-32768, 8650,-32768,-32768,-32768,-32768, ! 174,-32768,-32768,-32768, 893, 905,-32768,-32768, 420,-32768, ! 7211, 7301,-32768,-32768,-32768,-32768, 320,-32768,-32768, 4012, ! 142,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 897,-32768, ! -32768,-32768, 589,-32768,-32768,-32768,-32768,-32768,-32768, 907, ! 927, 939, 942, 832,-32768,-32768, 237, 8650, 945,-32768, ! 559, 563, 567,-32768, 6299, 9673,-32768, 906, 119,-32768, ! -32768,-32768, 36,-32768,-32768,-32768,-32768,-32768,-32768, 2346, ! 2346, 3148,-32768,-32768,-32768,-32768,-32768, 7954,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768,-32768, 944, 949, 6749,-32768, ! -32768,-32768,-32768, 3372, 3372,-32768, 4114, 832,-32768, 803, ! 908, 912, 913,-32768, 911,-32768, 959,-32768, 832, 589, ! -32768, 930,-32768, 962,-32768,-32768, 916,-32768, 9673,-32768, ! -32768, 961, 639,-32768, 8650, 4879, 375, 970,-32768,-32768, ! -32768, 594, 596, 971,-32768, 375, 969,-32768,-32768,-32768, ! -32768,-32768, 535,-32768, 4103,-32768, 210, 444, 943, 976, ! 832,-32768,-32768,-32768, 424, 424, 424, 933, 934, 8824, ! 894, 935, 938, 141, 940,-32768, 950, 951, 974, 975, ! 985, 986,-32768,-32768, 955,-32768,-32768, 998, 849, 509, ! 8650, 1003,-32768, 991, 968, 9673, 9673,-32768,-32768, 1004, ! 9714, 9731, 9747, 4614, 4486, 2373, 3583, 1046, 1046, 1046, ! 1055, 1055, 800, 800, 540, 540, 540,-32768,-32768, 973, ! 966, 977, 980, 984, 3218, 558,-32768, 6749, 8650,-32768, ! -32768,-32768, 8650,-32768,-32768, 983, 9085, 982, 995, 1035, ! -32768, 8650,-32768, 8650,-32768, 467,-32768, 467,-32768, 70, ! 989, 990,-32768, 988, 3218, 803,-32768, 803, 719,-32768, ! 1540, 993, 8045, 8045, 5119, 994, 8480, 296, 1000, 348, ! 808, 1001, 8650, 420, 996, 905,-32768, 9673,-32768, 9673, ! 4228,-32768, 428, 1040, 316,-32768, 832,-32768,-32768,-32768, ! -32768, 732, 1005,-32768, 209,-32768, 8650,-32768, 8650,-32768, ! 8650,-32768, 24,-32768,-32768, 420,-32768, 5723, 1071,-32768, ! 803, 803, 2634, 2634, 2729, 2729,-32768, 347,-32768, 2804, ! 8132, 8132, 5993, 317, 1007, 412, 803, 6749, 6749,-32768, ! 1048,-32768,-32768,-32768,-32768, 1052, 832, 8393, 764,-32768, ! -32768,-32768, 8650, 8650, 68, 9579, 1009,-32768, 1369, 589, ! 589, 2412, 731, 2580, 832, 3218,-32768, 60, 1025,-32768, ! -32768,-32768,-32768,-32768,-32768,-32768, 9168, 9168,-32768,-32768, ! -32768,-32768,-32768,-32768, 1027, 1038, 1047, 1053,-32768, 9555, ! 6749, 6389, 1033,-32768, 8650,-32768,-32768,-32768,-32768, 536, ! 1041,-32768,-32768, 1042, 265, 273, 273, 1049, 273,-32768, ! -32768, 9085, 1139,-32768, 1044, 1051,-32768,-32768,-32768,-32768, ! -32768,-32768, 803, 1056,-32768, 1050, 8219, 8219,-32768,-32768, ! 821,-32768, 9673,-32768,-32768, 1057,-32768, 435, 2169, 732, ! -32768,-32768,-32768, 1059, 1061, 1063, 6479,-32768,-32768, 705, ! 354, 1099,-32768,-32768,-32768, 1084,-32768, 8650, 1114, 1119, ! 1120, 8306, 329, 524,-32768, 1127, 1177, 1129,-32768, 4142, ! 9510, 2148, 5029,-32768,-32768, 1178,-32768,-32768,-32768, 7491, ! -32768,-32768,-32768, 2634, 2634,-32768, 2804, 1719,-32768,-32768, ! -32768, 803, 803, 803,-32768, 1130, 1089, 1092,-32768, 9579, ! 9579,-32768,-32768,-32768, 1136, 899, 8650,-32768,-32768,-32768, ! 375, 375, 832, 832,-32768, 1978,-32768,-32768,-32768, 569, ! 6749, 8650, 8650, 8650, 8650, 6749,-32768, 8650, 1137,-32768, ! -32768, 4942, 387, 8650,-32768, 536,-32768,-32768,-32768,-32768, ! -32768,-32768, 1094,-32768, 1159,-32768,-32768, 803,-32768,-32768, ! -32768,-32768, 83,-32768,-32768,-32768,-32768,-32768, 420,-32768, ! -32768,-32768,-32768,-32768,-32768, 745, 6569, 1117, 5185,-32768, ! -32768,-32768,-32768, 1151, 8650, 1152,-32768,-32768,-32768, 1122, ! -32768,-32768, 31, 750,-32768, 787, 375, 8911, 34, 900, ! 362,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 6749, ! 6749,-32768,-32768,-32768,-32768,-32768, 68, 8650, 8650, 9579, ! 589, 589, 1153, 1154,-32768,-32768,-32768,-32768, 330,-32768, ! 1126,-32768, 1113, 1115, 1121, 1131,-32768, 9627, 6749, 387, ! -32768, 1111,-32768,-32768,-32768, 803,-32768,-32768, 582, 582, ! 7773,-32768, 1204, 1165, 1138,-32768, 1166,-32768, 8393, 8650, ! -32768, 7593,-32768, 1168,-32768,-32768, 444,-32768, 589,-32768, ! -32768, 589, 9251, 9251, 6929,-32768,-32768,-32768, 745, 7019, ! 7019,-32768,-32768, 6749,-32768, 9579, 9579,-32768, 832, 832, ! 6749, 6749, 569, 1142, 8998,-32768,-32768,-32768,-32768, 6749, ! -32768,-32768,-32768,-32768, 8393,-32768,-32768,-32768,-32768,-32768, ! -32768, 5813,-32768,-32768, 1144, 257, 2940, 9650, 7593,-32768, ! -32768, 5271, 53,-32768,-32768, 1176,-32768, 1191,-32768,-32768, ! -32768, 1190, 1192,-32768,-32768,-32768,-32768, 380, 1149,-32768, ! 1156, 745, 7683, 585, 423, 5411,-32768, 375,-32768,-32768, ! 434,-32768, 5515,-32768, 1245, 1208,-32768,-32768, 6749, 6749, ! 8650,-32768,-32768,-32768,-32768, 48,-32768,-32768,-32768, 8650, ! 1209,-32768, 1213,-32768, 745, 589, 7593,-32768,-32768,-32768, ! 1183, 8, 1217,-32768,-32768, 7109, 7109,-32768,-32768, 1173, ! -32768, 5903, 1184,-32768,-32768, 832,-32768, 1187, 8650, 1245, ! 1223, 1245, 1188, 1189,-32768, 498, 5619,-32768, 1222,-32768, ! 1195, 239,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 1201, ! -32768, 1283, 1237, 7683, 7683, 6749, 4122, 745,-32768, 436, ! -32768,-32768,-32768,-32768, 1196, 1199,-32768, 1294, 1248,-32768, ! -32768,-32768,-32768, 1306, 1307,-32768 }; static const short yypgoto[] = {-32768, ! 1193,-32768,-32768, 992, 18, 1303,-32768,-32768,-32768,-32768, ! -32768,-32768, 513,-32768,-32768,-32768,-32768,-32768,-32768,-32768, ! -756, 1200, 1202,-32768,-32768,-32768,-32768, 1181,-32768,-32768, ! 503, 0,-32768, 771,-32768, 3899, -26,-32768, 1226, 867, ! -998,-32768, -84, 187,-32768, 196,-32768, 179, 150, -1074, ! -32768, -350, 929, 118, 753,-32768,-32768, -703, 2564, 926, ! -251, 2283, 2895, 822, 618, 425,-32768,-32768,-32768,-32768, ! -248,-32768, -108, -83,-32768, 255, 17, -273, 82, 21, ! -121, -120, -3, 1868, 46, 1413, -98, -418, 352,-32768, ! -160,-32768,-32768, 207,-32768,-32768,-32768,-32768,-32768, 66, ! -32768, 653,-32768, 144,-32768,-32768, 394, 756, 29,-32768, ! -32768,-32768, 546, -261, 37, 1302, 1310,-32768,-32768,-32768, ! -32768,-32768, -116,-32768, 479, -614,-32768, 531, 395, 471, ! -409,-32768,-32768,-32768,-32768,-32768,-32768, 941,-32768, 474, ! 809, 553, 860, 1539, 1625, -357,-32768, 2462, -63, 20, ! -32768, 4399, -90, 441,-32768, 3481,-32768,-32768, 4001, -4, ! 154, -311, 1345, 3650, 789, -169,-32768, 4093,-32768, -1136, ! -924, -335, 92,-32768, 532, -92, -128,-32768,-32768,-32768, ! -1121, -930, -1102,-32768,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768, -24,-32768,-32768,-32768,-32768,-32768, ! -281, 67,-32768, 76,-32768, -343, -132,-32768,-32768, -289, ! -286,-32768,-32768, 40, 490,-32768, -18,-32768, -247 }; ! #define YYLAST 9826 static const short yytable[] = { 66, ! 46, 348, 348, 365, 521, 670, 194, 85, 320, 552, ! 593, 82, 553, 464, 359, 85, 96, 313, 316, 103, ! 103, 30, 103, 290, 44, 178, 583, 422, 66, 122, ! 635, 84, 862, 391, 194, 529, 532, 551, 349, 149, ! 95, 66, 912, 633, 1140, 344, 231, 85, 1208, 350, ! 501, 175, 1104, 121, 85, 951, 97, 1224, 1103, 1107, ! 142, 501, 399, 400, 408, 195, 85, 1300, 501, 826, ! -1, 84, 85, 96, 423, 1246, 164, 552, 957, 596, ! 617, 826, 85, 596, 1215, 1253, 1168, -2, 521, 1176, ! 149, 85, 650, 85, 648, 459, 103, 285, 651, 306, ! 103, 188, 100, 103, 103, 11, 310, 667, 77, 1301, ! 460, 300, 1255, 286, 66, 46, 149, 66, 667, 345, ! 1265, -694, 187, 135, 597, 187, 958, -694, 597, 598, ! 1241, -690, 360, 598, 149, 149, 149, 328, 827, 44, ! 1268, 1140, 509, 559, 78, 79, 167, 168, 169, 21, ! 1291, 93, 611, 1295, 1256, 1307, 774, 276, 8, 187, ! 149, 1029, 599, 510, 336, 691, 599, 136, 137, 294, ! 296, 706, 346, 511, 668, 574, 170, 359, 66, 413, ! 276, 383, 164, 512, 554, 1147, 513, 514, 103, 164, ! 164, 75, 21, 1064, 80, 171, 397, 612, 100, 392, ! 525, 534, 613, 412, 342, 421, 1045, 93, 127, 76, ! 240, 575, 8, 164, 348, 348, 592, 358, 8, 192, ! 194, 1268, 1268, 126, 21, 85, 432, 88, 100, 425, ! 419, 1220, 100, 89, 509, 614, 639, 90, 192, 172, ! 173, 174, 891, 73, 526, 359, 498, 93, 100, 450, ! 590, 591, 576, 356, 365, 8, 192, 164, 589, 21, ! 127, 577, 159, 160, 876, 359, 85, 93, 12, 425, ! 508, 637, 432, 432, 523, 21, 100, 93, 690, 423, ! 149, 93, 529, 291, 295, 386, 313, 316, 1250, 751, ! 74, 17, 399, 400, 85, 360, 578, 93, 1322, 752, ! 509, 533, 192, 189, 93, 99, 164, 103, 509, 117, ! 103, 877, 867, 753, 103, 1104, 75, 326, 85, 96, ! 400, 1103, 1104, 21, 671, 93, 189, 705, 1103, 387, ! 388, 78, 308, 1062, 76, 648, 459, 751, 118, 457, ! 1323, 132, 1143, 95, 690, 100, 1297, 752, 192, 7, ! 8, 555, 690, 421, 149, 66, 149, 149, 523, 97, ! -226, 753, 66, 360, 327, 133, 1048, 563, 149, 182, ! 149, 672, 149, 149, 801, 603, 1104, 607, 609, 149, ! 549, 309, 1103, 360, 1193, 149, 287, 19, 149, 802, ! 164, 359, 21, 289, 93, 7, 8, -221, 359, 22, ! 421, 85, 807, 1085, -226, -226, 430, 149, 66, 1071, ! 66, 413, 7, 100, 421, 85, 431, 1071, -221, 164, ! 164, 189, 78, 308, 936, 339, 317, 100, 657, 26, ! 423, 1194, 318, 19, 1261, 412, 192, 934, 8, 340, ! 640, 85, 85, 85, 85, 22, -503, 164, 549, -222, ! 19, 112, 234, 455, -121, -227, 1072, 673, 588, 192, ! 348, 712, 22, 321, 1178, 642, 187, 114, 358, 341, ! 100, 498, 309, 184, 21, 26, 93, 337, 1071, 857, ! 359, 1262, -26, 301, 189, 21, 359, 93, 430, 1071, ! 1338, 85, 26, 432, 370, 301, 825, -26, 431, -227, ! -227, 674, 406, 583, 632, 432, 432, 426, 523, 360, ! 509, 552, 875, -222, 553, 66, 360, 21, 689, 93, ! 761, 692, 428, 365, 178, 1272, 698, 699, 700, 701, ! 702, 510, 112, 112, 359, 464, 1278, 1339, 399, 551, ! 276, 511, 529, 532, 715, 149, 85, 648, 114, 114, ! 803, 512, 688, 1071, 513, 514, 420, 78, 79, 13, ! 14, 1094, 1053, 1100, 762, 112, 609, 621, -101, 878, ! 84, 78, 308, 1125, 1126, 1127, 744, 99, 164, 747, ! 421, 114, 780, 1087, 712, 192, 763, 427, -79, 429, ! 629, 435, 99, 748, -79, 149, 149, 838, 360, 638, ! 1317, 747, 816, 838, 360, 21, 818, 80, 81, 740, ! 820, 742, 743, 13, 14, 748, 670, 485, 486, 149, ! 149, 309, 149, 749, 1044, 1204, 781, 782, 1269, 442, ! 764, 1078, 455, 7, 502, 455, 648, 693, 695, 812, ! 697, 691, 85, 792, 111, 749, 817, -282, 365, -283, ! 819, 838, 360, -282, 821, -283, 446, 421, 455, 359, ! 443, 192, 719, 359, 445, 164, 882, 883, 884, 1205, ! 432, 19, 1270, 165, 166, 186, 192, 297, 298, 359, ! 432, 432, 432, 22, 447, 187, 501, 187, 741, 75, ! 421, 384, 385, 851, 758, 813, 868, -694, 864, -694, ! -694, 870, 871, 164, 856, 873, -694, 76, 691, 1023, ! 1024, 448, 1024, 26, 449, 7, 502, 330, 503, 331, ! 541, 359, 100, 332, 538, 423, 314, 194, -694, -694, ! -694, 540, -694, 587, -694, 159, 160, 358, 1149, 1150, ! 85, 12, 393, 394, 313, 316, 1049, 1050, 543, 1052, ! 313, 316, 1166, 19, 564, 13, 14, 544, 111, 1069, ! 1070, 432, 509, 432, 17, 22, 187, 8, 641, 21, ! 85, 93, 1180, 1181, 432, 545, 85, 360, 66, 66, ! 66, 360, 546, 510, -78, 565, 941, 566, 560, 567, ! -78, 568, 70, 511, 642, 504, 85, 360, 346, 643, ! 87, 112, 112, 512, 384, 1170, 513, 514, 98, 423, ! 527, 8, 104, 104, 21, 104, 93, 114, 114, 1212, ! -689, 70, 594, 7, 8, 959, 911, 595, 149, 149, ! 149, 149, 104, 619, 70, 149, 838, 838, 838, 360, ! 87, 393, 1171, 610, 240, 528, 678, 98, 19, 626, ! 158, 159, 160, 620, 85, 634, 715, 12, 21, 98, ! 93, 19, 358, 679, 149, 98, 914, 103, 703, 66, ! 413, 85, 950, 22, 482, 483, 484, 485, 486, 925, ! 17, 926, 549, 104, 98, 13, 14, 421, 421, 104, ! 421, 704, -327, 104, 412, 425, 104, 104, 683, 75, ! 333, 1039, 334, 26, 1012, 684, 335, 70, -100, 104, ! 70, 432, 432, 706, 432, -327, -327, 76, -327, 8, ! 860, 773, 1006, 759, 403, 760, 404, 104, 104, 104, ! 405, 1013, 66, 66, 954, 775, 955, 777, 956, 1008, ! 1027, 487, 691, 85, 66, 413, 642, 1152, 918, 75, ! 793, 861, 806, 104, 384, 1177, 1039, 674, 1119, 794, ! 1189, 1190, 808, 398, 159, 160, 21, 76, 93, 412, ! 12, 70, 1086, 1332, 1333, 149, 66, 149, 488, 489, ! 455, 104, 809, 490, 491, 492, 493, 438, 441, 149, ! 149, 192, 149, 17, 810, 314, 1093, 811, 1099, 815, ! 8, 848, 10, 11, 1303, 1304, 849, 824, 12, 852, ! 164, 639, 850, 853, 854, 855, 859, 858, 98, 104, ! 863, 66, 413, 15, 869, 872, 112, 16, 874, 1128, ! 879, 17, 112, 880, 885, 886, 889, 552, 455, 890, ! 1336, 892, 114, 895, 896, 902, 412, 21, 114, 93, ! 1152, 893, 894, 1007, 897, 898, 899, -99, 1223, 98, ! 1121, 1122, 901, 905, 355, 104, 104, 70, 1148, 904, ! 907, 920, 531, 104, 906, 1115, 1116, 923, 924, 908, ! 112, 909, 313, 316, 745, 910, 922, 98, 1123, 1124, ! 929, 930, 931, 838, 192, 939, 114, 935, 945, 948, ! 104, 940, 942, 104, 826, 1001, 952, 104, 998, 1005, ! 1014, 98, 1030, 1152, 1032, 1296, 478, 479, 480, 481, ! 482, 483, 484, 485, 486, 1033, 98, 480, 481, 482, ! 483, 484, 485, 486, 1034, 1041, 1172, 789, 421, 421, ! 1035, 913, 1046, 1047, 1055, 1056, 1152, 104, 70, 104, ! 104, 70, 1057, 1051, 1060, 70, 1185, 1059, 1073, 1061, ! 1065, 104, 1066, 104, 1067, 104, 104, 1084, 838, 838, ! 838, 1077, 104, 1080, 1081, 1082, 451, 100, 104, 452, ! 1088, 104, 453, 1089, 1091, 1188, 421, 1112, 461, 421, ! 1113, 1105, 1128, 1114, 98, 1118, 1139, 500, 1144, 1337, ! 104, 70, 1145, 70, 1159, 359, 1163, 1165, 98, 1167, ! 1191, 1192, 149, 1195, 1196, 1203, 1197, 509, 1209, 111, ! 1210, 1213, 1198, 1221, 21, 845, 93, 1133, 1134, 1135, ! 1136, 1257, 1199, 1248, 98, 98, 98, 98, 510, 1142, ! 1211, 999, 1000, 1237, 164, 1247, 1258, 1259, 511, 1260, ! 1263, 1230, 1231, 1281, 1232, 1233, 457, 1264, 512, 112, ! 112, 513, 514, 1285, 1294, 112, 112, 112, 1071, 355, ! 1299, 1302, 1157, 111, 1305, 114, 114, 1310, 1313, 1319, ! 1164, 114, 114, 114, 98, 1308, 104, 1276, 1327, 1315, ! 1316, 1329, 1331, 421, 1037, 1040, 1321, 1340, 104, 104, ! 1341, 70, 1342, 1343, 5, 1345, 1346, 789, 791, 343, ! 322, -468, 1239, 947, -468, 355, 562, 953, 324, 531, ! 325, 804, 85, 360, 304, 707, 1202, 381, 1207, 765, ! 1228, 1158, 1096, 881, 123, 949, 1236, 1009, 104, 87, ! 823, 946, 124, 1063, 1026, 1025, 944, 796, 777, -694, ! 1040, -694, -694, 665, 1214, 746, 86, 1292, -694, -468, ! 993, 1309, -468, 355, -468, 1028, 1312, 0, 0, 696, ! 455, 1015, 1016, 0, -468, 1214, 1214, 1314, 1290, 0, ! -694, -694, 382, 0, -694, 0, -694, 0, 104, 104, ! 70, 0, -468, -468, 0, 0, 791, -468, 0, 0, ! 1214, 314, 0, 0, 0, 0, -468, 0, 549, 19, ! 0, 0, 104, 104, 0, 104, 48, 0, 187, 21, ! 355, 22, 355, 355, 1132, 0, 0, 0, 1017, 1137, ! 0, 0, 48, 139, 0, 98, 0, 0, 0, 0, ! 0, 0, 0, 140, 70, 48, 0, 0, 355, 0, ! 0, 26, 0, 314, 355, 0, 141, 0, 154, 314, ! 111, 0, 395, 104, 0, 1293, 0, 0, 0, 0, ! 0, 185, 0, 104, 104, 104, 0, 0, 0, 0, ! 0, 719, 719, 229, -694, 0, -694, -694, 278, 48, ! 0, 0, 0, -694, 1311, 0, 0, 0, 0, 0, ! 278, 278, 0, 1182, 1183, 314, 355, 0, 154, 0, ! 0, 278, 0, 0, 0, -694, -694, 396, 0, -694, ! 0, -694, 112, 0, 0, 0, 0, 0, 0, 0, ! 0, 48, 1201, 98, 154, 0, 355, 0, 114, 0, ! 0, 0, 0, 8, 92, 10, 11, 0, 362, 353, ! 0, 12, 0, 187, 104, 0, 104, 0, 0, 0, ! 0, 0, 0, 98, 0, 0, 15, 104, 0, 98, ! 16, 791, 791, 791, 17, 0, 0, 1229, 8, 531, ! 10, 184, 0, 0, 1234, 1235, 12, 0, 0, 98, ! 21, 0, 93, 1240, 0, 48, 0, 112, 112, 112, ! 0, 15, 0, 98, 0, 16, 0, 193, 0, 17, ! 0, 0, 0, 114, 114, 114, 0, 0, 355, 0, ! 0, 104, 104, 104, 104, 21, 0, 93, 104, 791, ! 791, 791, 354, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 185, 0, 0, 0, 0, 98, 101, 105, ! 0, 0, 1288, 1289, 319, 0, 0, 104, 0, 0, ! 104, 0, 70, 0, 98, 0, 0, 0, 7, 100, ! 278, 0, 11, 351, 0, 0, 0, 355, 0, 0, ! 0, 0, 921, 229, 0, 0, 0, 0, 390, 0, ! 355, 185, 355, 0, 0, 230, 0, 0, 0, 0, ! 279, 0, 0, 0, 104, 104, 19, 104, 451, 452, ! 0, 550, 279, 279, 0, 845, 21, 0, 22, 1334, ! 0, 0, 0, 279, 0, 791, 791, 0, -508, 0, ! 24, 0, 312, 315, 0, 48, 98, 70, 0, 0, ! 25, 0, 0, -508, -508, 355, 0, 355, 26, 355, ! -508, 0, 0, 27, 0, 0, 0, 0, 0, 0, ! 363, 0, -508, 373, 375, 0, 451, 452, 104, 70, ! 104, 0, 154, -508, -508, 185, -508, 0, -508, 550, ! 0, 0, 104, 104, 0, 104, 0, 0, 0, 0, ! 0, 314, 111, 0, 0, 0, 0, 0, 0, 362, ! 0, 0, 0, 0, 0, 0, -508, -508, 0, 0, ! -508, -508, 451, 452, 70, 0, 7, 100, 0, 0, ! -508, 0, 0, 0, 0, 154, 0, 48, 0, 0, ! 0, 0, 675, 0, 0, 0, 0, 0, 0, 409, ! 0, 7, 8, 92, 10, 11, 0, 1054, 0, 278, ! 12, 0, 278, 0, 19, 0, 0, 278, 675, 675, ! 675, 675, 451, 452, 21, 15, 22, 7, 8, 16, ! 0, 278, 0, 17, -420, 278, 0, 0, 108, 19, ! 0, 0, 279, 0, 0, 0, 791, 0, 109, 21, ! 0, 22, 652, 653, 669, 230, 26, 0, 410, 0, ! 0, 27, 0, 24, 0, 19, 0, 278, 229, 0, ! 0, 0, 0, 25, 0, 21, 0, 22, 627, 0, ! 138, 26, 0, 363, 630, 550, 27, 0, 0, 139, ! 19, 0, 362, 654, 0, 0, 0, 0, 228, 140, ! 21, -420, 22, 277, 0, 0, 0, 26, 0, 655, ! 0, 0, 141, 0, 139, 277, 277, 0, 0, 0, ! 0, 791, 791, 791, 140, 0, 277, 0, 685, 686, ! 0, 687, 26, 0, 0, 0, 0, 656, 409, 0, ! 7, 8, 92, 10, 11, 0, 0, 0, 0, 12, ! 0, 363, 8, 92, 10, 11, 0, 0, 0, 0, ! 12, 624, 625, 361, 15, 104, 0, 0, 16, 0, ! 0, 363, 17, -421, 550, 15, 0, 0, 19, 16, ! 362, 0, 0, 17, 0, 0, 355, 0, 21, 0, ! 22, 0, 0, 669, 0, 0, 0, 410, 0, 21, ! 0, 93, 24, 0, 279, 100, 0, 159, 160, 0, ! 0, 0, 25, 12, 778, 779, 0, 94, 0, 778, ! 26, 279, 0, 0, 279, 27, 0, 0, 550, 279, ! 279, 279, 279, 279, 0, 0, 17, 0, 0, 0, ! -421, 0, 0, 279, 0, 509, 0, 279, 0, 0, ! 0, 0, 21, 0, 93, 0, 0, 0, 451, 452, ! 0, 0, 0, 0, 0, 0, 510, 0, 0, 0, ! 0, 0, 0, 0, 0, 98, 511, 0, 0, 279, ! 230, 0, 0, 355, 0, 277, 512, 0, 0, 520, ! 514, 0, 831, 832, 766, 768, 0, 363, 228, 0, ! 0, 0, 840, 0, 363, 0, 0, 0, 847, 0, ! 7, 8, 158, 159, 160, 0, 0, 675, 0, 12, ! 0, 915, 0, 0, 0, 0, 361, 7, 8, 409, ! 0, 7, 8, 92, 10, 11, 0, 0, 0, 0, ! 12, 0, 17, 0, 0, 0, 0, 675, 19, 355, ! 0, 509, 865, 550, 0, 15, 0, 362, 21, 16, ! 22, 0, 0, 17, -419, 19, 0, 0, 509, 19, ! 0, 0, 139, 550, 0, 21, 0, 22, 0, 21, ! 0, 22, 140, 0, 833, 834, 363, 0, 410, 600, ! 26, 0, 363, 24, 361, 1098, 0, 0, 0, 601, ! 982, 0, 0, 25, 0, 0, 0, 26, 0, 512, ! 0, 26, 602, 514, 361, 362, 27, 0, 0, 0, ! 7, 100, 0, 0, 184, 0, 0, 0, 0, 0, ! 278, -419, 0, 0, 0, 0, 0, 0, 0, 0, ! 363, 0, 0, 0, 0, 0, 48, 277, 675, 916, ! 917, 6, 919, 7, 8, 9, 10, 11, 19, 0, ! 0, 0, 12, 0, 277, 0, 0, 277, 21, 0, ! 22, 0, 277, 277, 277, 277, 277, 15, 933, 0, ! 0, 16, 24, 0, 0, 17, 277, 0, 0, 0, ! 277, 19, 25, 0, 0, 323, 0, 0, 0, 0, ! 26, 21, 0, 22, 0, 27, 23, 0, 7, 8, ! 0, 0, 11, 0, 0, 24, 0, 0, 268, 0, ! 0, 48, 277, 228, 0, 25, 0, 0, 0, 279, ! 0, 0, 0, 26, 0, 0, 0, 997, 27, 0, ! 361, 268, 0, 0, 28, 0, 19, 361, 0, 509, ! 1002, 1003, 1004, 154, 0, 982, 21, 0, 22, 279, ! 0, 0, 982, 0, 0, 363, 0, 766, 768, 363, ! 600, 0, 0, 0, 1015, 100, 0, 0, 357, 0, ! 601, 0, 0, 0, 0, 363, 0, 0, 26, 0, ! 512, 0, 0, 602, 514, 0, 0, 0, 48, 474, ! 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, ! 485, 486, 19, 0, 0, 0, 0, 0, 0, 994, ! 995, 0, 21, 0, 22, 994, 995, 363, 1058, 361, ! 0, 1017, 0, 0, 0, 361, 24, 0, 0, 0, ! 0, 0, 279, 0, 0, 584, 25, 708, 709, 982, ! 10, 436, 233, 234, 26, 235, 12, 0, 0, 27, ! 279, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 236, 237, 238, 16, 0, 239, 0, 17, ! 0, 240, 241, 361, 242, 19, 243, 244, 0, 0, ! 245, 246, 247, 248, 249, 21, 0, 710, 585, 0, ! 0, 458, 0, 0, 0, 0, 250, 0, 0, 251, ! 0, 0, 1117, 0, 0, 0, 0, 252, 253, 254, ! 0, 766, 768, 982, 0, 255, 256, 257, 0, 0, ! 0, 1216, 258, 711, 982, 0, 259, 0, 0, 0, ! 409, 0, 7, 8, 92, 10, 11, 278, 260, 0, ! 0, 12, 1216, 1216, 0, 0, 0, 1146, 0, 0, ! 374, 376, 379, 0, 0, 0, 15, 0, 0, 0, ! 16, 0, 277, 0, 17, -422, 0, 1216, 0, 0, ! 19, 0, 586, 357, 982, 0, 0, 0, 0, 0, ! 21, 982, 22, 0, 982, 0, 7, 8, 0, 410, ! 184, 0, 277, 0, 24, 0, 0, 0, 361, 0, ! 0, 0, 361, 0, 25, 982, 0, 0, 982, 0, ! 0, 0, 26, 0, 0, 982, 0, 27, 361, 357, ! 0, 0, 0, 0, 19, 0, 0, 509, 0, 0, ! 0, 0, -422, 0, 21, 0, 22, 0, 0, 982, ! 0, 0, 649, 0, 0, 0, 0, 0, 600, 0, ! 0, 0, 0, 0, 982, 0, 0, 0, 601, 0, ! 361, 0, 0, 0, 0, 0, 26, 357, 512, 982, ! 0, 602, 514, 0, 0, 277, 0, 0, 0, 0, ! 0, 7, 8, 0, 0, 11, 982, 982, 0, 550, ! 0, 268, 0, 277, 586, 0, 0, 716, 717, 0, ! 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, ! 731, 732, 733, 734, 735, 736, 737, 738, 739, 19, ! 0, 0, 509, 0, 357, 0, 357, 357, 0, 21, ! 0, 22, 0, 230, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 835, 0, 0, 0, 624, 625, 279, ! 0, 0, 357, 836, 230, 230, 7, 8, 357, 0, ! 423, 26, 0, 512, 0, 0, 602, 514, 0, 0, ! 0, 0, 0, 798, 800, 0, 0, 0, 0, 230, ! 0, 0, 0, 0, 622, 0, 623, 0, 374, 376, ! 515, 515, 515, 0, 19, 0, 0, 509, 0, 0, ! 0, 636, 0, 0, 21, 0, 22, 0, 0, 6, ! 357, 7, 8, 9, 10, 11, 0, 586, 600, 0, ! 12, 0, 0, 662, 0, 0, 0, 0, 601, 0, ! 0, 0, 0, 13, 14, 15, 26, 0, 512, 16, ! 357, 602, 514, 17, 0, 0, 0, 18, 42, 19, ! 0, 586, 0, 20, 0, 0, 7, 100, 0, 21, ! 11, 22, 0, 0, 23, 0, 0, 0, 42, 42, ! 0, 110, 515, 24, 515, 515, 515, 42, 0, 0, ! 0, 0, 0, 25, 0, 0, 0, 866, 42, 0, ! 42, 26, 7, 8, 19, 0, 27, 0, 0, 0, ! 0, 363, 28, 29, 21, 0, 22, 0, 0, 0, ! 190, 0, 0, 0, 0, 0, 0, 0, 108, 0, ! 0, 0, 357, 0, 0, 0, 0, 0, 109, 0, ! 19, 0, 0, 0, 0, 0, 26, 0, 0, 42, ! 21, 27, 22, 900, 0, 42, 0, 190, 0, 42, ! 0, 0, 110, 110, 139, 0, 0, 0, 0, 8, ! 0, 10, 184, 42, 140, 42, 42, 12, 0, 0, ! 0, 0, 26, 0, 0, 0, 228, 141, 0, 0, ! 586, 357, 15, 42, 42, 110, 16, 0, 0, 0, ! 17, 0, 277, 190, 357, 0, 357, 228, 228, 509, ! 0, 0, 0, 0, 0, 0, 21, 0, 93, 42, ! 0, 374, 376, 379, 7, 8, 0, 0, 11, 379, ! 510, 0, 228, 515, 515, 943, 515, 42, 0, 0, ! 511, 0, 0, 787, 0, 622, 623, 42, 636, 0, ! 512, 0, 0, 513, 514, 0, 0, 0, 0, 357, ! 0, 357, 19, 357, 0, 0, 0, 0, 0, 0, ! 0, 0, 21, 515, 22, 0, 0, 379, 0, 0, ! 0, 0, 0, 0, 0, 0, 139, 0, 0, 0, ! 586, 586, 0, 0, 0, 0, 140, 0, 0, 0, ! 0, 0, 0, 0, 26, 1010, 1011, 0, 0, 141, ! 7, 8, 92, 10, 11, 0, 0, 353, 8, 12, ! 10, 11, 0, 515, 515, 515, 12, 0, 0, 505, ! 0, 787, 0, 0, 15, 0, 0, 190, 16, 42, ! 0, 15, 17, 586, 586, 16, 0, 1042, 19, 17, ! 0, 509, 0, 0, 361, 0, 0, 0, 21, 0, ! 22, 0, 0, 0, 0, 21, 42, 93, 494, 42, ! 0, 0, 835, 42, 0, 0, 0, 0, 0, 0, ! 0, 8, 836, 10, 11, 0, 0, 0, 0, 12, ! 26, 0, 512, 0, 0, 602, 514, 0, 515, 586, ! 354, 0, 495, 0, 15, 0, 0, 0, 16, 0, ! 1079, 0, 17, 42, 42, 42, 42, 0, 0, 0, ! 0, 42, 0, 0, 0, 0, 0, 42, 21, 42, ! 93, 110, 110, 7, 8, 158, 159, 160, 42, 0, ! 0, 0, 12, 0, 42, 0, 0, 42, 7, 100, ! 0, 0, 423, 0, 622, 623, 374, 376, 0, 1120, ! 0, 636, 374, 376, 379, 17, 42, 42, 0, 42, ! 0, 19, 0, 586, 509, 0, 0, 0, 586, 0, ! 1138, 21, 0, 22, 0, 0, 19, 0, 0, 515, ! 1021, 515, 0, 0, 0, 600, 21, 0, 22, 0, ! 0, 0, 515, 0, 0, 601, 787, 787, 787, 0, ! 24, 0, 0, 26, 0, 512, 0, 0, 608, 514, ! 25, 0, 0, 0, 0, 0, 0, 0, 26, 0, ! 0, 0, 0, 27, 7, 8, 0, 0, 184, 0, ! 357, 0, 0, 120, 0, 7, 8, 92, 10, 11, ! 0, 0, 586, 586, 12, 0, 515, 515, 515, 515, ! 1186, 1187, 505, 515, 787, 787, 787, 0, 0, 15, ! 0, 0, 19, 16, 788, 0, 0, 17, 0, 0, ! 0, 586, 21, 19, 22, 0, 0, 0, 0, 0, ! 0, 0, 0, 21, 0, 22, 139, 0, 0, 0, ! 0, 0, 1218, 0, 42, 0, 140, 24, 0, 0, ! 0, 0, 0, 0, 26, 622, 623, 25, 636, 141, ! 0, 0, 0, 0, 0, 26, 586, 0, 0, 0, ! 27, 0, 0, 586, 586, 0, 0, 357, 0, 0, ! 0, 0, 586, 0, 64, 8, 92, 10, 11, 0, ! 0, 353, 0, 12, 42, 42, 110, 0, 0, 0, ! 787, 787, 844, 0, 64, 64, 0, 115, 15, 0, ! 0, 0, 16, 64, 0, 0, 17, 0, 42, 42, ! 0, 42, 0, 0, 64, 509, 64, 0, 0, 0, ! 0, 0, 21, 0, 93, 0, 0, 0, 0, 0, ! 0, 586, 586, 357, 7, 8, 510, 0, 11, 0, ! 110, 0, 0, 0, 0, 0, 511, 515, 515, 379, ! 515, 0, 0, 0, 0, 0, 512, 0, 0, 513, ! 514, 0, 0, 0, 354, 64, 0, 0, 0, 0, ! 0, 64, 19, 0, 788, 64, 0, 0, 115, 115, ! 0, 0, 21, 0, 22, 0, 0, 0, 0, 64, ! 0, 64, 64, 0, 0, 0, 377, 0, 586, 0, ! 0, 0, 0, 0, 0, 0, 378, 0, 0, 64, ! 64, 115, 0, 0, 26, 0, 0, 0, 0, 141, ! 0, 0, 0, 0, 374, 376, 379, 0, 196, 0, ! 0, 8, 0, 10, 11, 64, 0, 0, 0, 12, ! 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, ! 485, 486, 0, 64, 15, 0, 0, 0, 16, 0, ! 0, 0, 17, 64, 197, 198, 116, 788, 788, 0, ! 0, 199, 0, 0, 0, 0, 0, 0, 21, 0, ! 93, 0, 200, 150, 201, 202, 203, 0, 204, 205, ! 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, ! 216, 217, 218, 219, 220, 221, 0, 0, 222, 223, ! 224, 0, 0, 225, 0, 0, 226, 42, 42, 110, ! 110, 0, 190, 0, 42, 844, 844, 844, 0, 0, ! 0, 227, 0, 0, 150, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 116, 116, 0, ! 0, 0, 0, 42, 530, 64, 42, 0, 42, 0, ! 150, 0, 0, 0, -301, 8, -301, 10, 184, 0, ! 0, 788, 788, 12, 0, 0, 0, 0, 150, 150, ! 380, 0, 64, 0, 0, 64, 0, 0, 15, 64, ! 0, 0, 16, 0, 0, 0, 17, 0, 0, 0, ! 0, 0, -301, 0, 150, 509, 0, 0, 582, 0, ! 0, 0, 21, 0, 93, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 190, 510, 0, 0, 64, ! 64, 64, 64, 42, 0, 0, 511, 64, 0, 0, ! 0, 0, 0, 64, -301, 64, 512, 115, 115, 513, ! 514, 0, 0, 0, 64, 0, 0, 0, 0, 0, ! 64, 0, 0, 64, 42, 42, 42, 0, 0, 0, ! 433, 0, 0, 0, 0, 0, 0, 0, 42, 42, ! 0, 42, 64, 64, 0, 64, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, ! 83, 10, 436, 233, 234, 0, 235, 12, 0, 0, ! 42, 0, 83, 83, 0, 83, 517, 517, 517, 0, ! 0, 0, 15, 236, 150, 0, 16, 0, 239, 0, ! 17, 0, 240, 241, 0, 242, 19, 243, 244, 0, ! 177, 245, 246, 247, 248, 249, 21, 0, 22, 0, ! 0, 0, 0, 0, 0, 0, 0, 250, 0, 0, ! 251, 0, 0, 0, 0, 0, 0, 0, 252, 253, ! 254, 0, 0, 0, 0, 0, 255, 256, 257, 0, ! 0, 0, 844, 437, 0, 0, 0, 0, 0, 83, ! 790, 83, 83, 83, 0, 0, 83, 83, 604, 260, ! 604, 604, 517, 0, 7, 8, 158, 159, 160, 0, ! 0, 0, 150, 12, 150, 0, 380, 380, 0, 0, ! 64, 0, 0, 150, 0, 0, 0, 0, 0, 150, ! 0, 0, 150, 0, 148, 0, 17, 0, 0, 0, ! 0, 0, 19, 0, 0, 509, 0, 0, 0, 0, ! 0, 150, 21, 0, 22, 0, 191, 844, 844, 844, ! 0, 0, 0, 0, 0, 0, 600, 0, 0, 0, ! 64, 64, 115, 0, 0, 191, 601, 0, 846, 0, ! 0, 83, 0, 0, 26, 148, 512, 0, 0, 602, ! 514, 0, 0, 0, 64, 64, 100, 64, 159, 160, ! 0, 42, 0, 0, 12, 0, 7, 8, 0, 0, ! 423, 148, 0, 0, 0, 8, 92, 10, 11, 83, ! 0, 1335, 0, 12, 0, 0, 115, 17, 0, 148, ! 148, 148, 0, 0, 7, 8, 509, 754, 15, 389, ! 0, 0, 16, 21, 19, 93, 17, 0, 0, 517, ! 517, 0, 517, 0, 21, 148, 22, 510, 0, 517, ! 790, 0, 21, 83, 93, 83, 83, 511, 139, 0, ! 7, 8, 19, 0, 0, 0, 0, 512, 140, 0, ! 513, 514, 21, 0, 22, 191, 26, 1092, 0, 604, ! 0, 141, 0, 0, 83, 0, 139, 0, 0, 0, ! 83, 0, 0, 83, 0, 0, 140, 83, 19, 0, ! 0, 0, 0, 0, 26, 0, 0, 0, 21, 141, ! 22, 8, 92, 10, 11, 0, 0, 0, 0, 12, ! 0, 0, 377, 0, 0, 0, 0, 0, 0, 604, ! 604, 839, 378, 0, 15, 0, 0, 839, 16, 0, ! 26, 0, 17, 790, 790, 141, 0, 0, 0, 0, ! 0, 530, 0, 150, 150, 0, 150, 0, 21, 0, ! 93, 0, 0, 191, 0, 148, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 582, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 380, 0, 0, 0, 0, ! 0, 0, 0, 64, 64, 115, 115, 0, 0, 0, ! 64, 846, 846, 846, 517, 0, 0, 0, 0, 0, ! 83, 0, 0, 0, 433, 433, 433, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, ! 0, 0, 64, 0, 64, 0, 0, 0, 0, 148, ! 0, 148, 148, 0, 0, 0, 0, 790, 790, 518, ! 522, 524, 0, 148, 0, 148, 0, 148, 148, 0, ! 0, 0, 0, 0, 148, 0, 0, 0, 0, 0, ! 148, 0, 0, 148, 0, 0, 83, 0, 0, 0, ! 0, 0, 62, 0, 0, 0, 83, 0, 83, 83, ! 0, 0, 148, 0, 0, 517, 0, 517, 0, 0, ! 0, 0, 102, 106, 0, 0, 0, 0, 517, 64, ! 0, 125, 517, 517, 517, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 157, 0, 0, 0, 0, 177, ! 0, 605, 0, 518, 522, 524, 0, 0, 0, 0, ! 64, 64, 64, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 64, 64, 0, 64, 8, 151, ! 10, 152, 604, 604, 839, 839, 12, 0, 0, 604, ! 839, 839, 839, 0, 0, 0, 0, 0, 0, 305, ! 0, 15, 0, 307, 0, 16, 64, 0, 0, 17, ! 0, 0, 0, 0, 0, 0, 0, 62, 150, 0, ! 329, 0, 0, 191, 0, 21, 0, 93, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 102, 106, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 148, 473, 474, 475, 476, 477, 478, 479, 480, 481, ! 482, 483, 484, 485, 486, 754, 754, 0, 754, 0, ! 0, 0, 0, 83, 0, 0, 0, 0, 846, 0, ! 0, 418, 0, 83, 83, 83, 517, 517, 0, 0, ! 0, 424, 0, 0, 0, 0, 0, 0, 0, 0, ! 148, 148, 837, 769, 0, 771, 0, 0, 837, 0, ! 0, 0, 771, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 148, 148, 0, 148, 0, 150, ! 0, 150, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 522, 604, 604, 0, 604, 0, 0, 0, ! 0, 0, 0, 846, 846, 846, 837, 0, 0, 0, ! 0, 0, 0, 0, 83, 0, 83, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 83, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 769, 771, 0, 0, 64, 7, 8, ! 771, 10, 436, 233, 234, 0, 235, 12, 0, 0, ! 556, 0, 0, 557, 0, 0, 0, 558, 0, 0, ! 0, 0, 15, 236, 237, 238, 16, 0, 239, 0, ! 17, 0, 240, 241, 0, 242, 19, 243, 244, 0, ! 0, 245, 246, 247, 248, 249, 21, 380, 22, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 606, 0, ! 0, 0, 0, 0, 0, 616, 0, 522, 0, 0, ! 83, 305, 0, 307, 0, 0, 255, 256, 257, 0, ! 0, 0, 0, 258, 0, 0, 0, 259, 424, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 663, 666, 0, 418, 83, 83, 0, 83, 0, 0, ! 0, 0, 380, 380, 380, 0, 0, 0, 0, 0, ! 0, 0, 0, 148, 148, 148, 148, 0, 996, 0, ! 148, 837, 837, 837, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 927, 0, ! 928, 0, 0, 0, 0, 0, 150, 0, 0, 148, ! 0, 932, 0, 0, 0, 0, 769, 771, 0, 0, ! 0, 7, 8, 92, 10, 11, 0, 0, 353, 0, ! 12, 0, 7, 8, 151, 10, 152, 0, 0, 0, ! 0, 12, 0, 0, 0, 15, 0, 0, 0, 16, ! 0, 0, 0, 17, 0, 0, 15, 0, 0, 19, ! 16, 0, 0, 0, 17, 927, 928, 0, 769, 21, ! 19, 22, 932, 0, 769, 771, 0, 0, 0, 0, ! 21, 191, 22, 377, 0, 153, 0, 0, 0, 0, ! 0, 0, 0, 378, 24, 0, 0, 0, 0, 0, ! 0, 26, 0, 0, 25, 0, 141, 0, 0, 0, ! 0, 354, 26, 0, 0, 0, 0, 27, 0, 0, ! 148, 0, 148, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 148, 148, 0, 148, 102, 106, ! 467, 0, 468, 469, 470, 471, 472, 473, 474, 475, ! 476, 477, 478, 479, 480, 481, 482, 483, 484, 485, ! 486, 0, 556, 557, 0, 558, 0, 0, 0, 1101, ! 769, 962, 8, 92, 10, 232, 233, 234, 0, 235, ! 12, 963, 0, 964, 965, 966, 967, 968, 969, 970, ! 971, 972, 973, 13, 14, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 974, 346, 0, 975, 0, 927, 928, 0, 932, ! 250, 0, 0, 251, 0, 0, 0, 0, 837, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 976, 454, ! 259, 7, 8, 92, 10, 232, 233, 234, 353, 235, ! 12, 1102, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 509, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, -234, 837, 837, 837, 0, 0, 0, 0, ! 250, 0, 0, 937, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 938, 1160, 0, 0, 0, 0, 255, ! 256, 257, 0, 512, 0, 0, 785, 514, 0, 0, ! 259, 354, 0, 0, 0, 0, 0, 148, 0, 0, ! 0, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 305, 307, 0, 0, 0, 0, 0, 424, 0, ! 0, 465, 466, 467, 1161, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, ! 483, 484, 485, 486, 0, 0, 0, 1022, 0, 0, ! 1022, 1251, 418, 962, 8, 92, 10, 232, 233, 234, ! 0, 235, 12, 963, 0, 964, 965, 966, 967, 968, ! 969, 970, 971, 972, 973, 13, 14, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 974, 346, 0, 975, 0, 0, 0, ! 0, 0, 250, 0, 0, 251, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 254, 0, 418, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 258, 0, ! 976, 0, 259, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 1252, 260, 0, 0, 0, 0, 1097, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 556, 557, 0, 558, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 1273, 0, 962, 8, 92, 10, 232, 233, 234, ! 0, 235, 12, 963, 418, 964, 965, 966, 967, 968, ! 969, 970, 971, 972, 973, 13, 14, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 974, 346, 0, 975, 0, 0, 0, ! 0, 0, 250, 0, 0, 251, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 254, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 258, 0, ! 976, 0, 259, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 1274, 260, 1273, 0, 962, 8, 92, ! 10, 232, 233, 234, 0, 235, 12, 963, 0, 964, ! 965, 966, 967, 968, 969, 970, 971, 972, 973, 13, ! 14, 15, 236, 237, 238, 16, 0, 239, 0, 17, ! 0, 240, 241, 0, 242, 19, 243, 244, 0, 0, ! 245, 246, 247, 248, 249, 21, 0, 974, 346, 0, ! 975, 0, 0, 0, 0, 0, 250, 0, 0, 251, ! 0, 0, 0, 0, 0, 0, 0, 252, 253, 254, ! 0, 0, 0, 0, 0, 255, 256, 257, 0, 0, ! 0, 0, 258, 0, 976, 0, 259, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 1279, 260, 1273, ! 0, 962, 8, 92, 10, 232, 233, 234, 0, 235, ! 12, 963, 0, 964, 965, 966, 967, 968, 969, 970, ! 971, 972, 973, 13, 14, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 974, 346, 0, 975, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 976, 0, ! 259, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 1318, 260, 961, 0, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 0, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 346, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 1245, 259, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 260, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 346, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 1306, 259, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 260, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 346, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 454, 259, 7, 8, 92, 10, 232, ! 233, 234, 353, 235, 12, 0, 260, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 509, 0, 245, 246, ! 247, 248, 249, 21, 0, 22, -234, 0, 0, 0, ! 0, 0, 0, 0, 250, 0, 0, 841, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 842, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 512, 0, 0, ! 843, 514, 0, 0, 259, 354, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 352, 260, 7, 8, 92, ! 10, 232, 233, 234, 353, 235, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 236, 237, 238, 16, 0, 239, 0, 17, ! 0, 240, 241, 0, 242, 19, 243, 244, 0, 0, ! 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 250, 0, 0, 251, ! 0, 0, 0, 0, 0, 0, 0, 252, 253, 254, ! 0, 0, 0, 0, 0, 255, 256, 257, 0, 0, ! 0, 0, 258, 0, 0, 0, 259, 354, 0, 0, ! 0, 0, 0, 0, 0, 0, -662, 631, 260, 7, ! 8, 92, 10, 232, 233, 234, 353, 235, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 15, 236, 237, 238, 16, 0, 239, ! 0, 17, 0, 240, 241, 0, 242, 19, 243, 244, ! 0, 0, 245, 246, 247, 248, 249, 21, 0, 22, ! 0, 0, 0, 0, 0, 0, 0, 0, 250, 0, ! 0, 251, 0, 0, 0, 0, 0, 0, 0, 252, ! 253, 254, 0, 0, 0, 0, 0, 255, 256, 257, ! 0, 0, 0, 0, 258, 0, 0, 0, 259, 354, ! 0, 0, 0, 0, 0, 0, 0, 0, -662, 584, ! 260, 708, 709, 0, 10, 436, 233, 234, 0, 235, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 710, 585, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 711, 0, 584, ! 259, 708, 709, 0, 10, 436, 233, 234, 0, 235, ! 12, 822, 260, 0, 0, 0, 0, 1038, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 710, 585, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 584, ! 259, 708, 709, 0, 10, 436, 233, 234, 0, 235, ! 12, -381, 260, 0, 0, 0, 0, 1038, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 710, 585, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 1154, ! 259, 7, 8, 92, 10, 232, 233, 234, 0, 235, ! 12, 1068, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, 1155, 0, 1156, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 454, ! 259, 7, 8, 0, 10, 232, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, -234, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 584, ! 259, 7, 8, 0, 10, 436, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, 585, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 718, ! 259, 7, 8, 0, 10, 436, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, 0, 0, 0, 0, 0, 0, -652, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 454, ! 259, 7, 8, 0, 10, 232, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, -234, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 1173, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 1174, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 1175, 0, 0, 1225, ! 259, 7, 8, 0, 10, 232, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, ! 0, 22, 0, 0, -136, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 718, ! 259, 7, 8, 0, 10, 436, 233, 234, 0, 235, ! 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 251, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 254, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 0, 0, 0, 258, 0, 0, 0, ! 259, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! -652, 797, 260, 7, 8, 0, 10, 436, 233, 234, ! 0, 235, 12, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 250, 0, 0, 251, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 254, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 258, 0, ! 0, 799, 259, 7, 8, 0, 10, 436, 233, 234, ! 0, 235, 12, 0, 260, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 250, 0, 0, 251, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 254, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 258, 0, ! 7, 8, 259, 10, 436, 233, 234, 0, 235, 12, ! 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 15, 236, 237, 238, 16, 0, ! 239, 0, 17, 0, 240, 241, 0, 242, 19, 243, ! 244, 0, 0, 245, 246, 247, 248, 249, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 250, ! 0, 0, 251, 0, 0, 0, 0, 0, 0, 0, ! 252, 253, 254, 0, 0, 0, 0, 0, 255, 256, ! 257, 0, 0, 0, 0, 258, 0, 0, 0, 259, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 260, 757, 962, 8, 92, 10, 232, 233, 234, ! 0, 235, 12, 963, 0, 964, 965, 966, 967, 968, ! 969, 970, 971, 972, 973, 13, 14, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 974, 346, 0, 975, 0, 0, 0, ! 0, 0, 250, 0, 0, 251, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 254, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 258, 0, ! 976, 0, 259, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 1106, 260, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 0, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 346, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 0, 259, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 260, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 1266, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 0, 259, 962, 8, 92, 10, 232, ! 233, 234, 0, 235, 12, 963, 260, 964, 965, 966, ! 967, 968, 969, 970, 971, 972, 973, 13, 14, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 974, 0, 0, 975, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 976, 0, 259, 7, 8, 92, 10, 232, ! 233, 234, 353, 235, 12, 0, 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 509, 0, 245, 246, ! 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, ! 0, 0, 0, 0, 250, 0, 0, 783, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 784, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 512, 0, 0, ! 785, 514, 0, 0, 259, 354, 7, 8, 92, 10, ! 232, 233, 234, 353, 235, 12, 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 15, 236, 237, 238, 16, 0, 239, 0, 17, 0, ! 240, 241, 0, 242, 19, 243, 244, 509, 0, 245, ! 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, ! 0, 0, 0, 0, 0, 250, 0, 0, 841, 0, ! 0, 0, 0, 0, 0, 0, 252, 253, 842, 0, ! 0, 0, 0, 0, 255, 256, 257, 0, 512, 0, ! 0, 843, 514, 0, 0, 259, 354, 7, 8, 0, ! 10, 232, 233, 234, 0, 235, 12, 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 236, 237, 238, 16, 0, 239, 0, 17, ! 0, 240, 241, 0, 242, 19, 243, 244, 509, 0, ! 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 250, 0, 0, 783, ! 0, 0, 0, 0, 0, 0, 0, 252, 253, 784, ! 0, 0, 0, 0, 0, 255, 256, 257, 0, 512, ! 0, 0, 785, 514, 7, 8, 0, 10, 232, 233, ! 234, 0, 235, 12, 0, 0, 0, 0, 260, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 15, 236, ! 237, 238, 16, 0, 239, 0, 17, 0, 240, 241, ! 0, 242, 19, 243, 244, 509, 0, 245, 246, 247, ! 248, 249, 21, 0, 22, 0, 0, 0, 0, 0, ! 0, 0, 0, 250, 0, 0, 841, 0, 0, 0, ! 0, 0, 0, 0, 252, 253, 842, 0, 0, 0, ! 0, 0, 255, 256, 257, 0, 512, 0, 0, 843, ! 514, 7, 8, 0, 10, 232, 233, 234, 0, 235, ! 12, 0, 0, 0, 0, 260, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 236, 237, 238, 16, ! 0, 239, 0, 17, 0, 240, 241, 0, 242, 19, ! 243, 244, 509, 0, 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, ! 250, 0, 0, 937, 0, 0, 0, 0, 0, 0, ! 0, 252, 253, 938, 0, 0, 0, 0, 0, 255, ! 256, 257, 0, 512, 0, 0, 785, 514, 7, 8, ! 0, 10, 436, 233, 234, 0, 235, 12, 0, 0, ! 0, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 236, 237, 238, 16, 0, 239, 0, ! 17, 0, 240, 241, 0, 242, 19, 243, 244, 0, ! 0, 245, 246, 247, 248, 249, 21, 0, 22, 0, ! 0, 1083, 0, 0, 0, 0, 0, 250, 0, 0, ! 251, 0, 0, 0, 0, 0, 0, 0, 252, 253, ! 254, 0, 0, 0, 0, 0, 255, 256, 257, 0, ! 0, 0, 0, 258, 0, 7, 8, 259, 10, 232, ! 233, 234, 0, 235, 12, 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 0, 7, 8, 259, 10, 436, 233, 234, 0, ! 235, 12, 0, 0, 0, 0, 260, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 15, 236, 237, 238, ! 16, 0, 239, 0, 17, 0, 240, 241, 0, 242, ! 19, 243, 244, 0, 0, 245, 246, 247, 248, 249, ! 21, 0, 22, 462, 0, 0, 0, 0, 0, 0, ! 0, 250, 0, 0, 251, 0, 0, 0, 0, 0, ! 0, 0, 252, 253, 254, 0, 0, 0, 0, 0, ! 255, 256, 257, 0, 0, 7, 8, 463, 10, 436, ! 233, 234, 0, 235, 12, 0, 0, 0, 0, 0, ! 0, 0, 0, 260, 0, 0, 0, 0, 0, 15, ! 236, 237, 238, 16, 0, 239, 0, 17, 0, 240, ! 241, 0, 242, 19, 243, 244, 0, 0, 245, 246, ! 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, ! 0, 0, 0, 0, 250, 0, 0, 251, 0, 0, ! 0, 0, 0, 0, 0, 252, 253, 254, 0, 0, ! 0, 0, 0, 255, 256, 257, 0, 0, 0, 0, ! 258, 499, 7, 8, 0, 10, 436, 233, 234, 0, ! 235, 12, 0, 0, 0, 0, 260, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 15, 236, 237, 238, ! 16, 0, 239, 0, 17, 0, 240, 241, 0, 242, ! 19, 243, 244, 0, 0, 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, ! 0, 250, 0, 0, 251, 0, 0, 0, 0, 0, ! 0, 0, 252, 253, 254, 0, 0, 0, 0, 0, ! 255, 256, 257, 0, 0, 0, 0, 258, 0, 7, ! 694, 259, 10, 436, 233, 234, 0, 235, 12, 0, ! 0, 0, 0, 260, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 15, 236, 237, 238, 16, 0, 239, ! 0, 17, 0, 240, 241, 0, 242, 19, 243, 244, ! 0, 0, 245, 246, 247, 248, 249, 21, 0, 22, ! 0, 0, 0, 0, 0, 0, 0, 0, 250, 0, ! 0, 251, 0, 0, 0, 0, 0, 0, 0, 252, ! 253, 254, 0, 0, 0, 0, 0, 255, 256, 257, ! 0, 0, 0, 0, 258, 0, 7, 8, 259, 10, ! 436, 233, 234, 0, 235, 12, 0, 0, 0, 0, ! 260, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 15, 236, 237, 238, 16, 0, 239, 0, 17, 0, ! 240, 241, 0, 242, 19, 243, 244, 0, 0, 245, ! 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, ! 0, 0, 0, 0, 0, 250, 0, 0, 887, 0, ! 0, 0, 0, 0, 0, 0, 252, 253, 888, 0, ! 0, 0, 0, 0, 255, 256, 257, 0, 0, 0, ! 0, 258, 0, 7, 8, 259, 10, 436, 233, 234, ! 0, 235, 12, 0, 0, 0, 0, 260, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 250, 0, 0, 1173, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 1174, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 0, 0, 1175, 0, ! 1238, 8, 259, 10, 436, 233, 234, 0, 235, 12, ! 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 15, 236, 237, 238, 16, 0, ! 239, 0, 17, 0, 240, 241, 0, 242, 19, 243, ! 244, 0, 0, 245, 246, 247, 248, 249, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 250, ! 0, 0, 251, 0, 0, 0, 0, 0, 0, 0, ! 252, 253, 254, 0, 0, 0, 0, 0, 255, 256, ! 257, 0, 0, 0, 0, 258, 0, 7, 8, 259, ! 10, 436, 233, 234, 0, 235, 12, 0, 0, 0, ! 0, 260, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 236, 237, 238, 16, 0, 239, 0, 17, ! 0, 240, 241, 0, 242, 19, 243, 244, 0, 0, ! 245, 246, 247, 248, 249, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 250, 0, 0, 251, ! 0, 0, 0, 0, 0, 0, 0, 252, 253, 254, ! 0, 0, 0, 0, 0, 255, 256, 257, 0, 0, ! 7, 8, 258, 10, 436, 233, 234, 0, 235, 12, ! 0, 0, 0, 0, 0, 0, 0, 0, 260, 0, ! 0, 0, 0, 0, 15, 236, 237, 238, 16, 0, ! 239, 0, 17, 0, 240, 241, 0, 242, 19, 243, ! 244, 0, 0, 245, 246, 247, 248, 249, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 250, ! 0, 0, 887, 0, 0, 0, 0, 0, 0, 0, ! 252, 253, 888, 0, 0, 0, 0, 0, 255, 256, ! 257, 0, 0, 7, 8, 258, 10, 232, 233, 234, ! 0, 235, 12, 0, 0, 0, 0, 0, 0, 0, ! 0, 260, 0, 0, 0, 0, 0, 15, 236, 237, ! 238, 16, 0, 239, 0, 17, 0, 240, 241, 0, ! 242, 19, 243, 244, 0, 0, 245, 246, 247, 248, ! 249, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 250, 0, 0, 1173, 0, 0, 0, 0, ! 0, 0, 0, 252, 253, 1174, 0, 0, 0, 0, ! 0, 255, 256, 257, 0, 0, 7, 8, 1175, 10, ! 436, 233, 234, 0, 235, 12, 0, 0, 0, 0, ! 0, 0, 0, 0, 260, 0, 0, 0, 0, 0, ! 15, 236, 0, 0, 16, 0, 239, 0, 17, 0, ! 240, 241, 0, 242, 19, 243, 244, 0, 0, 245, ! 246, 247, 248, 249, 21, 0, 22, 0, 0, 0, ! 0, 0, 0, 0, 0, 250, 0, 0, 251, 0, ! 0, 0, 0, 0, 0, 0, 252, 253, 254, 0, ! 0, 0, 0, 0, 255, 256, 257, 0, 0, 0, ! 0, 440, 7, 8, 92, 10, 11, 0, 0, 615, ! 0, 12, 0, 0, 0, 0, 0, 260, 0, 652, ! 8, 151, 10, 152, 0, 0, 15, 0, 12, 0, ! 16, 0, 0, 0, 17, 0, 0, 0, 0, 0, ! 19, 0, 0, 15, 0, 0, 0, 16, 0, 0, ! 21, 17, 22, 0, 0, 0, 0, 19, 0, 0, ! 0, 0, 0, 0, 24, 0, 0, 21, 0, 22, ! 0, 0, 0, 0, 25, 0, 655, 0, 0, 0, ! 0, 24, 26, 0, 0, 0, 0, 27, 0, 0, ! 0, 25, 7, 8, 151, 10, 152, 0, 0, 26, ! 0, 12, 0, 0, 27, 0, 0, 0, 0, 7, ! 8, 151, 10, 152, 0, 0, 15, 0, 12, 0, ! 16, 0, 0, 0, 17, 0, 0, 0, 0, 0, ! 19, 0, 0, 15, 0, 0, 0, 16, 0, 0, ! 21, 17, 22, 0, 0, 1095, 0, 19, 0, 0, ! 0, 0, 0, 0, 24, 0, 0, 21, 0, 22, ! 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, ! 0, 24, 26, 0, 0, 0, 0, 27, 0, 0, ! 0, 25, 0, 0, 0, 0, 0, 0, 0, 26, ! 679, 465, 466, 467, 27, 468, 469, 470, 471, 472, ! 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, ! 483, 484, 485, 486, 0, 465, 466, 467, 0, 468, ! 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, ! 479, 480, 481, 482, 483, 484, 485, 486, 542, 1036, ! 465, 466, 467, 0, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 465, 466, 467, 1200, 468, 469, 470, ! 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, ! 481, 482, 483, 484, 485, 486, 465, 466, 467, 1249, ! 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, ! 478, 479, 480, 481, 482, 483, 484, 485, 486, 465, ! 466, 467, 0, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, ! 485, 486, 465, 466, 467, 0, 468, 469, 470, 471, ! 472, 473, 474, 475, 476, 0, 478, 479, 480, 481, ! 482, 483, 484, 485, 486, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 470, 471, 472, 473, 474, 475, 476, ! 477, 478, 479, 480, 481, 482, 483, 484, 485, 486, ! 471, 472, 473, 474, 475, 476, 477, 478, 479, 480, ! 481, 482, 483, 484, 485, 486 }; static const short yycheck[] = { 4, ! 4, 130, 131, 136, 278, 415, 70, 12, 117, 299, ! 346, 12, 299, 265, 136, 20, 20, 108, 109, 24, ! 25, 4, 27, 87, 4, 52, 338, 188, 33, 33, ! 388, 12, 647, 154, 98, 284, 284, 299, 131, 44, ! 20, 46, 746, 387, 1043, 129, 71, 52, 1151, 134, ! 9, 52, 983, 33, 59, 812, 20, 1179, 983, 990, ! 44, 9, 161, 162, 181, 70, 71, 60, 9, 34, ! 0, 52, 77, 77, 7, 1212, 48, 367, 55, 10, ! 367, 34, 87, 10, 1159, 1222, 56, 0, 362, 56, ! 95, 96, 54, 98, 406, 55, 101, 77, 60, 104, ! 105, 62, 4, 108, 109, 7, 107, 36, 45, 102, ! 70, 95, 60, 77, 119, 119, 121, 122, 36, 1, ! 1242, 54, 92, 44, 55, 92, 103, 60, 55, 60, ! 1205, 58, 136, 60, 139, 140, 141, 121, 103, 119, ! 1243, 1140, 44, 102, 3, 4, 5, 6, 7, 51, ! 103, 53, 10, 1275, 102, 1292, 514, 76, 4, 92, ! 165, 102, 93, 65, 125, 439, 93, 88, 89, 88, ! 89, 102, 54, 75, 103, 336, 35, 299, 183, 183, ! 99, 142, 154, 85, 301, 103, 88, 89, 193, 161, ! 162, 51, 51, 950, 53, 54, 157, 55, 4, 154, ! 44, 286, 60, 183, 56, 188, 910, 53, 60, 69, ! 37, 3, 4, 185, 343, 344, 345, 136, 4, 66, ! 284, 1324, 1325, 23, 51, 230, 231, 88, 4, 75, ! 185, 1162, 4, 88, 44, 93, 397, 3, 85, 98, ! 99, 100, 102, 56, 88, 367, 271, 53, 4, 250, ! 343, 344, 44, 136, 387, 4, 103, 229, 342, 51, ! 60, 53, 6, 7, 55, 387, 271, 53, 12, 75, ! 275, 392, 277, 278, 279, 51, 4, 53, 88, 7, ! 285, 53, 531, 88, 89, 44, 377, 378, 1219, 65, ! 103, 35, 391, 392, 299, 299, 88, 53, 60, 75, ! 44, 285, 149, 75, 53, 69, 278, 312, 44, 88, ! 315, 102, 656, 89, 319, 1246, 51, 56, 323, 323, ! 419, 1246, 1253, 51, 56, 53, 75, 456, 1253, 88, ! 89, 3, 4, 948, 69, 647, 55, 65, 54, 258, ! 102, 56, 1046, 323, 88, 4, 1277, 75, 195, 3, ! 4, 70, 88, 336, 359, 360, 361, 362, 363, 323, ! 44, 89, 367, 367, 103, 51, 102, 328, 373, 54, ! 375, 103, 377, 378, 55, 359, 1307, 361, 362, 384, ! 299, 53, 1307, 387, 55, 390, 103, 41, 393, 70, ! 362, 513, 51, 54, 53, 3, 4, 102, 520, 53, ! 383, 406, 563, 75, 88, 89, 65, 412, 413, 56, ! 415, 415, 3, 4, 397, 420, 75, 56, 102, 391, ! 392, 75, 3, 4, 782, 44, 102, 4, 412, 83, ! 7, 102, 102, 41, 55, 415, 283, 781, 4, 58, ! 401, 446, 447, 448, 449, 53, 102, 419, 367, 102, ! 41, 27, 9, 258, 56, 44, 103, 418, 341, 306, ! 589, 462, 53, 103, 103, 31, 92, 27, 387, 88, ! 4, 496, 53, 7, 51, 83, 53, 3, 56, 640, ! 602, 102, 55, 97, 75, 51, 608, 53, 65, 56, ! 55, 496, 83, 498, 105, 97, 589, 70, 75, 88, ! 89, 420, 60, 815, 387, 510, 511, 89, 513, 513, ! 44, 801, 673, 102, 801, 520, 520, 51, 437, 53, ! 44, 440, 60, 656, 551, 103, 445, 446, 447, 448, ! 449, 65, 108, 109, 656, 787, 103, 102, 637, 801, ! 459, 75, 791, 791, 463, 550, 551, 859, 108, 109, ! 551, 85, 435, 56, 88, 89, 88, 3, 4, 25, ! 26, 980, 920, 982, 88, 141, 550, 372, 60, 678, ! 551, 3, 4, 5, 6, 7, 495, 69, 550, 44, ! 563, 141, 44, 60, 585, 432, 44, 89, 54, 105, ! 384, 88, 69, 58, 60, 600, 601, 602, 602, 393, ! 103, 44, 44, 608, 608, 51, 44, 53, 54, 492, ! 44, 494, 495, 25, 26, 58, 1026, 78, 79, 624, ! 625, 53, 627, 88, 89, 44, 88, 89, 44, 88, ! 88, 967, 437, 3, 4, 440, 948, 442, 443, 574, ! 445, 915, 647, 526, 27, 88, 88, 54, 781, 54, ! 88, 656, 656, 60, 88, 60, 69, 640, 463, 781, ! 88, 508, 467, 785, 88, 637, 685, 686, 687, 88, ! 675, 41, 88, 55, 56, 1, 523, 55, 56, 801, ! 685, 686, 687, 53, 69, 92, 9, 92, 493, 51, ! 673, 55, 56, 628, 499, 578, 657, 23, 60, 25, ! 26, 662, 663, 675, 639, 666, 32, 69, 982, 870, ! 871, 69, 873, 83, 69, 3, 4, 54, 6, 56, ! 55, 843, 4, 60, 103, 7, 109, 791, 54, 55, ! 56, 102, 58, 340, 60, 6, 7, 656, 1074, 1075, ! 745, 12, 55, 56, 835, 836, 916, 917, 102, 919, ! 841, 842, 1088, 41, 23, 25, 26, 102, 141, 55, ! 56, 766, 44, 768, 35, 53, 92, 4, 5, 51, ! 775, 53, 1108, 1109, 779, 102, 781, 781, 783, 784, ! 785, 785, 3, 65, 54, 54, 791, 56, 103, 58, ! 60, 60, 4, 75, 31, 83, 801, 801, 54, 36, ! 12, 377, 378, 85, 55, 56, 88, 89, 20, 7, ! 3, 4, 24, 25, 51, 27, 53, 377, 378, 1155, ! 58, 33, 102, 3, 4, 826, 745, 102, 833, 834, ! 835, 836, 44, 58, 46, 840, 841, 842, 843, 843, ! 52, 55, 56, 102, 37, 38, 88, 59, 41, 102, ! 5, 6, 7, 105, 859, 105, 775, 12, 51, 71, ! 53, 41, 781, 32, 869, 77, 749, 872, 102, 874, ! 874, 876, 807, 53, 75, 76, 77, 78, 79, 762, ! 35, 764, 801, 95, 96, 25, 26, 870, 871, 101, ! 873, 102, 32, 105, 874, 75, 108, 109, 105, 51, ! 54, 902, 56, 83, 865, 105, 60, 119, 60, 121, ! 122, 916, 917, 102, 919, 55, 56, 69, 58, 4, ! 5, 105, 857, 51, 54, 6, 56, 139, 140, 141, ! 60, 866, 937, 938, 817, 88, 819, 44, 821, 858, ! 875, 44, 1216, 948, 949, 949, 31, 1076, 753, 51, ! 58, 36, 56, 165, 55, 56, 957, 876, 60, 55, ! 1121, 1122, 56, 5, 6, 7, 51, 69, 53, 949, ! 12, 183, 973, 1324, 1325, 980, 981, 982, 81, 82, ! 785, 193, 56, 86, 87, 88, 89, 235, 236, 994, ! 995, 838, 997, 35, 56, 378, 980, 56, 982, 55, ! 4, 58, 6, 7, 1286, 1287, 58, 102, 12, 102, ! 982, 1172, 619, 102, 102, 105, 55, 88, 230, 231, ! 60, 1026, 1026, 27, 55, 55, 602, 31, 60, 1030, ! 88, 35, 608, 58, 102, 102, 102, 1327, 843, 102, ! 1327, 102, 602, 70, 70, 55, 1026, 51, 608, 53, ! 1179, 102, 102, 858, 70, 70, 102, 60, 1167, 271, ! 1021, 1022, 60, 60, 136, 277, 278, 279, 1069, 102, ! 105, 89, 284, 285, 102, 1010, 1011, 83, 44, 103, ! 656, 102, 1173, 1174, 88, 102, 105, 299, 1023, 1024, ! 102, 102, 105, 1098, 941, 102, 656, 105, 103, 60, ! 312, 102, 102, 315, 34, 58, 102, 319, 102, 58, ! 102, 323, 88, 1242, 88, 1276, 71, 72, 73, 74, ! 75, 76, 77, 78, 79, 88, 338, 73, 74, 75, ! 76, 77, 78, 79, 88, 103, 1097, 520, 1121, 1122, ! 88, 748, 102, 102, 6, 102, 1275, 359, 360, 361, ! 362, 363, 102, 105, 105, 367, 1117, 102, 60, 103, ! 102, 373, 102, 375, 102, 377, 378, 972, 1173, 1174, ! 1175, 88, 384, 60, 56, 56, 251, 4, 390, 254, ! 54, 393, 257, 7, 56, 1120, 1169, 58, 263, 1172, ! 102, 14, 1193, 102, 406, 60, 60, 272, 105, 1328, ! 412, 413, 44, 415, 88, 1327, 56, 56, 420, 88, ! 58, 58, 1217, 88, 102, 105, 102, 44, 15, 602, ! 56, 56, 102, 56, 51, 608, 53, 1032, 1033, 1034, ! 1035, 56, 102, 1217, 446, 447, 448, 449, 65, 1044, ! 103, 848, 849, 102, 1216, 102, 56, 58, 75, 58, ! 102, 1186, 1187, 9, 1189, 1190, 1175, 102, 85, 835, ! 836, 88, 89, 56, 56, 841, 842, 843, 56, 341, ! 88, 55, 1077, 656, 102, 835, 836, 91, 56, 58, ! 1085, 841, 842, 843, 496, 102, 498, 1248, 88, 102, ! 102, 9, 56, 1276, 901, 902, 102, 102, 510, 511, ! 102, 513, 9, 56, 2, 0, 0, 690, 520, 129, ! 118, 7, 1195, 801, 10, 387, 325, 815, 119, 531, ! 119, 551, 1327, 1327, 99, 459, 1140, 1, 1150, 508, ! 1181, 1077, 981, 681, 33, 805, 1193, 859, 550, 551, ! 585, 796, 33, 949, 874, 872, 794, 539, 44, 23, ! 957, 25, 26, 413, 1159, 496, 12, 1266, 32, 55, ! 829, 1296, 58, 435, 60, 876, 1300, -1, -1, 444, ! 1175, 3, 4, -1, 70, 1180, 1181, 1302, 1261, -1, ! 54, 55, 56, -1, 58, -1, 60, -1, 600, 601, ! 602, -1, 88, 89, -1, -1, 608, 93, -1, -1, ! 1205, 784, -1, -1, -1, -1, 102, -1, 1327, 41, ! -1, -1, 624, 625, -1, 627, 4, -1, 92, 51, ! 492, 53, 494, 495, 1031, -1, -1, -1, 60, 1036, ! -1, -1, 20, 65, -1, 647, -1, -1, -1, -1, ! -1, -1, -1, 75, 656, 33, -1, -1, 520, -1, ! -1, 83, -1, 836, 526, -1, 88, -1, 46, 842, ! 843, -1, 1, 675, -1, 1270, -1, -1, -1, -1, ! -1, 59, -1, 685, 686, 687, -1, -1, -1, -1, ! -1, 1286, 1287, 71, 23, -1, 25, 26, 76, 77, ! -1, -1, -1, 32, 1299, -1, -1, -1, -1, -1, ! 88, 89, -1, 1110, 1111, 888, 578, -1, 96, -1, ! -1, 99, -1, -1, -1, 54, 55, 56, -1, 58, ! -1, 60, 1098, -1, -1, -1, -1, -1, -1, -1, ! -1, 119, 1139, 745, 122, -1, 608, -1, 1098, -1, ! -1, -1, -1, 4, 5, 6, 7, -1, 136, 10, ! -1, 12, -1, 92, 766, -1, 768, -1, -1, -1, ! -1, -1, -1, 775, -1, -1, 27, 779, -1, 781, ! 31, 783, 784, 785, 35, -1, -1, 1184, 4, 791, ! 6, 7, -1, -1, 1191, 1192, 12, -1, -1, 801, ! 51, -1, 53, 1200, -1, 183, -1, 1173, 1174, 1175, ! -1, 27, -1, 815, -1, 31, -1, 69, -1, 35, ! -1, -1, -1, 1173, 1174, 1175, -1, -1, 690, -1, ! -1, 833, 834, 835, 836, 51, -1, 53, 840, 841, ! 842, 843, 93, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 230, -1, -1, -1, -1, 859, 24, 25, ! -1, -1, 1259, 1260, 116, -1, -1, 869, -1, -1, ! 872, -1, 874, -1, 876, -1, -1, -1, 3, 4, ! 258, -1, 7, 135, -1, -1, -1, 749, -1, -1, ! -1, -1, 757, 271, -1, -1, -1, -1, 150, -1, ! 762, 279, 764, -1, -1, 71, -1, -1, -1, -1, ! 76, -1, -1, -1, 916, 917, 41, 919, 783, 784, ! -1, 299, 88, 89, -1, 1098, 51, -1, 53, 1326, ! -1, -1, -1, 99, -1, 937, 938, -1, 10, -1, ! 65, -1, 108, 109, -1, 323, 948, 949, -1, -1, ! 75, -1, -1, 25, 26, 817, -1, 819, 83, 821, ! 32, -1, -1, 88, -1, -1, -1, -1, -1, -1, ! 136, -1, 44, 139, 140, -1, 841, 842, 980, 981, ! 982, -1, 360, 55, 56, 363, 58, -1, 60, 367, ! -1, -1, 994, 995, -1, 997, -1, -1, -1, -1, ! -1, 1174, 1175, -1, -1, -1, -1, -1, -1, 387, ! -1, -1, -1, -1, -1, -1, 88, 89, -1, -1, ! 92, 93, 887, 888, 1026, -1, 3, 4, -1, -1, ! 102, -1, -1, -1, -1, 413, -1, 415, -1, -1, ! -1, -1, 420, -1, -1, -1, -1, -1, -1, 1, ! -1, 3, 4, 5, 6, 7, -1, 922, -1, 437, ! 12, -1, 440, -1, 41, -1, -1, 445, 446, 447, ! 448, 449, 937, 938, 51, 27, 53, 3, 4, 31, ! -1, 459, -1, 35, 36, 463, -1, -1, 65, 41, ! -1, -1, 258, -1, -1, -1, 1098, -1, 75, 51, ! -1, 53, 3, 4, 56, 271, 83, -1, 60, -1, ! -1, 88, -1, 65, -1, 41, -1, 495, 496, -1, ! -1, -1, -1, 75, -1, 51, -1, 53, 380, -1, ! 56, 83, -1, 299, 386, 513, 88, -1, -1, 65, ! 41, -1, 520, 44, -1, -1, -1, -1, 71, 75, ! 51, 103, 53, 76, -1, -1, -1, 83, -1, 60, ! -1, -1, 88, -1, 65, 88, 89, -1, -1, -1, ! -1, 1173, 1174, 1175, 75, -1, 99, -1, 430, 431, ! -1, 433, 83, -1, -1, -1, -1, 88, 1, -1, 3, 4, 5, 6, 7, -1, -1, -1, -1, 12, ! -1, 367, 4, 5, 6, 7, -1, -1, -1, -1, ! 12, 377, 378, 136, 27, 1217, -1, -1, 31, -1, ! -1, 387, 35, 36, 602, 27, -1, -1, 41, 31, ! 608, -1, -1, 35, -1, -1, 1098, -1, 51, -1, ! 53, -1, -1, 56, -1, -1, -1, 60, -1, 51, ! -1, 53, 65, -1, 420, 4, -1, 6, 7, -1, ! -1, -1, 75, 12, 516, 517, -1, 69, -1, 521, ! 83, 437, -1, -1, 440, 88, -1, -1, 656, 445, ! 446, 447, 448, 449, -1, -1, 35, -1, -1, -1, ! 103, -1, -1, 459, -1, 44, -1, 463, -1, -1, ! -1, -1, 51, -1, 53, -1, -1, -1, 1173, 1174, ! -1, -1, -1, -1, -1, -1, 65, -1, -1, -1, ! -1, -1, -1, -1, -1, 1327, 75, -1, -1, 495, ! 496, -1, -1, 1195, -1, 258, 85, -1, -1, 88, ! 89, -1, 594, 595, 510, 511, -1, 513, 271, -1, ! -1, -1, 604, -1, 520, -1, -1, -1, 610, -1, ! 3, 4, 5, 6, 7, -1, -1, 745, -1, 12, ! -1, 749, -1, -1, -1, -1, 299, 3, 4, 1, ! -1, 3, 4, 5, 6, 7, -1, -1, -1, -1, ! 12, -1, 35, -1, -1, -1, -1, 775, 41, 1261, ! -1, 44, 654, 781, -1, 27, -1, 785, 51, 31, ! 53, -1, -1, 35, 36, 41, -1, -1, 44, 41, ! -1, -1, 65, 801, -1, 51, -1, 53, -1, 51, ! -1, 53, 75, -1, 600, 601, 602, -1, 60, 65, ! 83, -1, 608, 65, 367, 88, -1, -1, -1, 75, ! 828, -1, -1, 75, -1, -1, -1, 83, -1, 85, ! -1, 83, 88, 89, 387, 843, 88, -1, -1, -1, ! 3, 4, -1, -1, 7, -1, -1, -1, -1, -1, ! 858, 103, -1, -1, -1, -1, -1, -1, -1, -1, ! 656, -1, -1, -1, -1, -1, 874, 420, 876, 751, ! 752, 1, 754, 3, 4, 5, 6, 7, 41, -1, ! -1, -1, 12, -1, 437, -1, -1, 440, 51, -1, ! 53, -1, 445, 446, 447, 448, 449, 27, 780, -1, ! -1, 31, 65, -1, -1, 35, 459, -1, -1, -1, ! 463, 41, 75, -1, -1, 45, -1, -1, -1, -1, ! 83, 51, -1, 53, -1, 88, 56, -1, 3, 4, ! -1, -1, 7, -1, -1, 65, -1, -1, 76, -1, ! -1, 949, 495, 496, -1, 75, -1, -1, -1, 745, ! -1, -1, -1, 83, -1, -1, -1, 839, 88, -1, ! 513, 99, -1, -1, 94, -1, 41, 520, -1, 44, ! 852, 853, 854, 981, -1, 983, 51, -1, 53, 775, ! -1, -1, 990, -1, -1, 781, -1, 783, 784, 785, ! 65, -1, -1, -1, 3, 4, -1, -1, 136, -1, ! 75, -1, -1, -1, -1, 801, -1, -1, 83, -1, ! 85, -1, -1, 88, 89, -1, -1, -1, 1026, 67, ! 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, ! 78, 79, 41, -1, -1, -1, -1, -1, -1, 835, ! 836, -1, 51, -1, 53, 841, 842, 843, 930, 602, ! -1, 60, -1, -1, -1, 608, 65, -1, -1, -1, ! -1, -1, 858, -1, -1, 1, 75, 3, 4, 1077, ! 6, 7, 8, 9, 83, 11, 12, -1, -1, 88, ! 876, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, 656, 40, 41, 42, 43, -1, -1, ! 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, ! -1, 259, -1, -1, -1, -1, 62, -1, -1, 65, ! -1, -1, 1014, -1, -1, -1, -1, 73, 74, 75, ! -1, 937, 938, 1151, -1, 81, 82, 83, -1, -1, ! -1, 1159, 88, 89, 1162, -1, 92, -1, -1, -1, ! 1, -1, 3, 4, 5, 6, 7, 1175, 104, -1, ! -1, 12, 1180, 1181, -1, -1, -1, 1059, -1, -1, ! 139, 140, 141, -1, -1, -1, 27, -1, -1, -1, ! 31, -1, 745, -1, 35, 36, -1, 1205, -1, -1, ! 41, -1, 340, 341, 1212, -1, -1, -1, -1, -1, ! 51, 1219, 53, -1, 1222, -1, 3, 4, -1, 60, ! 7, -1, 775, -1, 65, -1, -1, -1, 781, -1, ! -1, -1, 785, -1, 75, 1243, -1, -1, 1246, -1, ! -1, -1, 83, -1, -1, 1253, -1, 88, 801, 387, ! -1, -1, -1, -1, 41, -1, -1, 44, -1, -1, ! -1, -1, 103, -1, 51, -1, 53, -1, -1, 1277, ! -1, -1, 410, -1, -1, -1, -1, -1, 65, -1, ! -1, -1, -1, -1, 1292, -1, -1, -1, 75, -1, ! 843, -1, -1, -1, -1, -1, 83, 435, 85, 1307, ! -1, 88, 89, -1, -1, 858, -1, -1, -1, -1, ! -1, 3, 4, -1, -1, 7, 1324, 1325, -1, 1327, ! -1, 459, -1, 876, 462, -1, -1, 465, 466, -1, ! 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, ! 478, 479, 480, 481, 482, 483, 484, 485, 486, 41, ! -1, -1, 44, -1, 492, -1, 494, 495, -1, 51, ! -1, 53, -1, 1159, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, 65, -1, -1, -1, 1173, 1174, 1175, ! -1, -1, 520, 75, 1180, 1181, 3, 4, 526, -1, ! 7, 83, -1, 85, -1, -1, 88, 89, -1, -1, ! -1, -1, -1, 541, 542, -1, -1, -1, -1, 1205, ! -1, -1, -1, -1, 373, -1, 375, -1, 377, 378, ! 277, 278, 279, -1, 41, -1, -1, 44, -1, -1, ! -1, 390, -1, -1, 51, -1, 53, -1, -1, 1, ! 578, 3, 4, 5, 6, 7, -1, 585, 65, -1, ! 12, -1, -1, 412, -1, -1, -1, -1, 75, -1, ! -1, -1, -1, 25, 26, 27, 83, -1, 85, 31, ! 608, 88, 89, 35, -1, -1, -1, 39, 4, 41, ! -1, 619, -1, 45, -1, -1, 3, 4, -1, 51, ! 7, 53, -1, -1, 56, -1, -1, -1, 24, 25, ! -1, 27, 359, 65, 361, 362, 363, 33, -1, -1, ! -1, -1, -1, 75, -1, -1, -1, 655, 44, -1, ! 46, 83, 3, 4, 41, -1, 88, -1, -1, -1, ! -1, 1327, 94, 95, 51, -1, 53, -1, -1, -1, ! 66, -1, -1, -1, -1, -1, -1, -1, 65, -1, ! -1, -1, 690, -1, -1, -1, -1, -1, 75, -1, ! 41, -1, -1, -1, -1, -1, 83, -1, -1, 95, ! 51, 88, 53, 711, -1, 101, -1, 103, -1, 105, ! -1, -1, 108, 109, 65, -1, -1, -1, -1, 4, ! -1, 6, 7, 119, 75, 121, 122, 12, -1, -1, ! -1, -1, 83, -1, -1, -1, 1159, 88, -1, -1, ! 748, 749, 27, 139, 140, 141, 31, -1, -1, -1, ! 35, -1, 1175, 149, 762, -1, 764, 1180, 1181, 44, ! -1, -1, -1, -1, -1, -1, 51, -1, 53, 165, ! -1, 600, 601, 602, 3, 4, -1, -1, 7, 608, ! 65, -1, 1205, 510, 511, 793, 513, 183, -1, -1, ! 75, -1, -1, 520, -1, 624, 625, 193, 627, -1, ! 85, -1, -1, 88, 89, -1, -1, -1, -1, 817, ! -1, 819, 41, 821, -1, -1, -1, -1, -1, -1, ! -1, -1, 51, 550, 53, -1, -1, 656, -1, -1, ! -1, -1, -1, -1, -1, -1, 65, -1, -1, -1, ! 848, 849, -1, -1, -1, -1, 75, -1, -1, -1, ! -1, -1, -1, -1, 83, 863, 864, -1, -1, 88, ! 3, 4, 5, 6, 7, -1, -1, 10, 4, 12, ! 6, 7, -1, 600, 601, 602, 12, -1, -1, 275, ! -1, 608, -1, -1, 27, -1, -1, 283, 31, 285, ! -1, 27, 35, 901, 902, 31, -1, 905, 41, 35, ! -1, 44, -1, -1, 1327, -1, -1, -1, 51, -1, ! 53, -1, -1, -1, -1, 51, 312, 53, 54, 315, ! -1, -1, 65, 319, -1, -1, -1, -1, -1, -1, ! -1, 4, 75, 6, 7, -1, -1, -1, -1, 12, ! 83, -1, 85, -1, -1, 88, 89, -1, 675, 957, ! 93, -1, 88, -1, 27, -1, -1, -1, 31, -1, ! 968, -1, 35, 359, 360, 361, 362, -1, -1, -1, ! -1, 367, -1, -1, -1, -1, -1, 373, 51, 375, ! 53, 377, 378, 3, 4, 5, 6, 7, 384, -1, ! -1, -1, 12, -1, 390, -1, -1, 393, 3, 4, ! -1, -1, 7, -1, 833, 834, 835, 836, -1, 1017, ! -1, 840, 841, 842, 843, 35, 412, 413, -1, 415, ! -1, 41, -1, 1031, 44, -1, -1, -1, 1036, -1, ! 1038, 51, -1, 53, -1, -1, 41, -1, -1, 766, ! 869, 768, -1, -1, -1, 65, 51, -1, 53, -1, ! -1, -1, 779, -1, -1, 75, 783, 784, 785, -1, ! 65, -1, -1, 83, -1, 85, -1, -1, 88, 89, ! 75, -1, -1, -1, -1, -1, -1, -1, 83, -1, ! -1, -1, -1, 88, 3, 4, -1, -1, 7, -1, ! 1098, -1, -1, 1, -1, 3, 4, 5, 6, 7, ! -1, -1, 1110, 1111, 12, -1, 833, 834, 835, 836, ! 1118, 1119, 508, 840, 841, 842, 843, -1, -1, 27, ! -1, -1, 41, 31, 520, -1, -1, 35, -1, -1, ! -1, 1139, 51, 41, 53, -1, -1, -1, -1, -1, ! -1, -1, -1, 51, -1, 53, 65, -1, -1, -1, ! -1, -1, 1160, -1, 550, -1, 75, 65, -1, -1, ! -1, -1, -1, -1, 83, 994, 995, 75, 997, 88, ! -1, -1, -1, -1, -1, 83, 1184, -1, -1, -1, ! 88, -1, -1, 1191, 1192, -1, -1, 1195, -1, -1, ! -1, -1, 1200, -1, 4, 4, 5, 6, 7, -1, ! -1, 10, -1, 12, 600, 601, 602, -1, -1, -1, ! 937, 938, 608, -1, 24, 25, -1, 27, 27, -1, ! -1, -1, 31, 33, -1, -1, 35, -1, 624, 625, ! -1, 627, -1, -1, 44, 44, 46, -1, -1, -1, ! -1, -1, 51, -1, 53, -1, -1, -1, -1, -1, ! -1, 1259, 1260, 1261, 3, 4, 65, -1, 7, -1, ! 656, -1, -1, -1, -1, -1, 75, 994, 995, 1098, ! 997, -1, -1, -1, -1, -1, 85, -1, -1, 88, ! 89, -1, -1, -1, 93, 95, -1, -1, -1, -1, ! -1, 101, 41, -1, 690, 105, -1, -1, 108, 109, ! -1, -1, 51, -1, 53, -1, -1, -1, -1, 119, ! -1, 121, 122, -1, -1, -1, 65, -1, 1326, -1, ! -1, -1, -1, -1, -1, -1, 75, -1, -1, 139, ! 140, 141, -1, -1, 83, -1, -1, -1, -1, 88, ! -1, -1, -1, -1, 1173, 1174, 1175, -1, 1, -1, ! -1, 4, -1, 6, 7, 165, -1, -1, -1, 12, ! 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, ! 78, 79, -1, 183, 27, -1, -1, -1, 31, -1, ! -1, -1, 35, 193, 37, 38, 27, 783, 784, -1, ! -1, 44, -1, -1, -1, -1, -1, -1, 51, -1, ! 53, -1, 55, 44, 57, 58, 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, -1, -1, 81, 82, ! 83, -1, -1, 86, -1, -1, 89, 833, 834, 835, ! 836, -1, 838, -1, 840, 841, 842, 843, -1, -1, ! -1, 104, -1, -1, 95, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 108, 109, -1, ! -1, -1, -1, 869, 284, 285, 872, -1, 874, -1, ! 121, -1, -1, -1, 3, 4, 5, 6, 7, -1, ! -1, 887, 888, 12, -1, -1, -1, -1, 139, 140, ! 141, -1, 312, -1, -1, 315, -1, -1, 27, 319, ! -1, -1, 31, -1, -1, -1, 35, -1, -1, -1, ! -1, -1, 41, -1, 165, 44, -1, -1, 338, -1, ! -1, -1, 51, -1, 53, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 941, 65, -1, -1, 359, ! 360, 361, 362, 949, -1, -1, 75, 367, -1, -1, ! -1, -1, -1, 373, 83, 375, 85, 377, 378, 88, ! 89, -1, -1, -1, 384, -1, -1, -1, -1, -1, ! 390, -1, -1, 393, 980, 981, 982, -1, -1, -1, ! 231, -1, -1, -1, -1, -1, -1, -1, 994, 995, ! -1, 997, 412, 413, -1, 415, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 3, 4, ! 12, 6, 7, 8, 9, -1, 11, 12, -1, -1, ! 1026, -1, 24, 25, -1, 27, 277, 278, 279, -1, ! -1, -1, 27, 28, 285, -1, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! 52, 46, 47, 48, 49, 50, 51, -1, 53, -1, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, 1098, 88, -1, -1, -1, -1, -1, 101, ! 520, 103, 104, 105, -1, -1, 108, 109, 359, 104, ! 361, 362, 363, -1, 3, 4, 5, 6, 7, -1, ! -1, -1, 373, 12, 375, -1, 377, 378, -1, -1, ! 550, -1, -1, 384, -1, -1, -1, -1, -1, 390, ! -1, -1, 393, -1, 44, -1, 35, -1, -1, -1, ! -1, -1, 41, -1, -1, 44, -1, -1, -1, -1, ! -1, 412, 51, -1, 53, -1, 66, 1173, 1174, 1175, ! -1, -1, -1, -1, -1, -1, 65, -1, -1, -1, ! 600, 601, 602, -1, -1, 85, 75, -1, 608, -1, ! -1, 193, -1, -1, 83, 95, 85, -1, -1, 88, ! 89, -1, -1, -1, 624, 625, 4, 627, 6, 7, ! -1, 1217, -1, -1, 12, -1, 3, 4, -1, -1, ! 7, 121, -1, -1, -1, 4, 5, 6, 7, 231, ! -1, 10, -1, 12, -1, -1, 656, 35, -1, 139, ! 140, 141, -1, -1, 3, 4, 44, 498, 27, 149, ! -1, -1, 31, 51, 41, 53, 35, -1, -1, 510, ! 511, -1, 513, -1, 51, 165, 53, 65, -1, 520, ! 690, -1, 51, 275, 53, 277, 278, 75, 65, -1, ! 3, 4, 41, -1, -1, -1, -1, 85, 75, -1, ! 88, 89, 51, -1, 53, 195, 83, 56, -1, 550, ! -1, 88, -1, -1, 306, -1, 65, -1, -1, -1, ! 312, -1, -1, 315, -1, -1, 75, 319, 41, -1, ! -1, -1, -1, -1, 83, -1, -1, -1, 51, 88, ! 53, 4, 5, 6, 7, -1, -1, -1, -1, 12, ! -1, -1, 65, -1, -1, -1, -1, -1, -1, 600, ! 601, 602, 75, -1, 27, -1, -1, 608, 31, -1, ! 83, -1, 35, 783, 784, 88, -1, -1, -1, -1, ! -1, 791, -1, 624, 625, -1, 627, -1, 51, -1, ! 53, -1, -1, 283, -1, 285, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 815, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 656, -1, -1, -1, -1, ! -1, -1, -1, 833, 834, 835, 836, -1, -1, -1, ! 840, 841, 842, 843, 675, -1, -1, -1, -1, -1, ! 432, -1, -1, -1, 685, 686, 687, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 869, ! -1, -1, 872, -1, 874, -1, -1, -1, -1, 359, ! -1, 361, 362, -1, -1, -1, -1, 887, 888, 277, ! 278, 279, -1, 373, -1, 375, -1, 377, 378, -1, ! -1, -1, -1, -1, 384, -1, -1, -1, -1, -1, ! 390, -1, -1, 393, -1, -1, 498, -1, -1, -1, ! -1, -1, 4, -1, -1, -1, 508, -1, 510, 511, ! -1, -1, 412, -1, -1, 766, -1, 768, -1, -1, ! -1, -1, 24, 25, -1, -1, -1, -1, 779, 949, ! -1, 33, 783, 784, 785, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 46, -1, -1, -1, -1, 551, ! -1, 359, -1, 361, 362, 363, -1, -1, -1, -1, ! 980, 981, 982, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 994, 995, -1, 997, 4, 5, ! 6, 7, 833, 834, 835, 836, 12, -1, -1, 840, ! 841, 842, 843, -1, -1, -1, -1, -1, -1, 101, ! -1, 27, -1, 105, -1, 31, 1026, -1, -1, 35, ! -1, -1, -1, -1, -1, -1, -1, 119, 869, -1, ! 122, -1, -1, 523, -1, 51, -1, 53, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 139, 140, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 550, 66, 67, 68, 69, 70, 71, 72, 73, 74, ! 75, 76, 77, 78, 79, 916, 917, -1, 919, -1, ! -1, -1, -1, 675, -1, -1, -1, -1, 1098, -1, ! -1, 183, -1, 685, 686, 687, 937, 938, -1, -1, ! -1, 193, -1, -1, -1, -1, -1, -1, -1, -1, ! 600, 601, 602, 511, -1, 513, -1, -1, 608, -1, ! -1, -1, 520, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 624, 625, -1, 627, -1, 980, ! -1, 982, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 550, 994, 995, -1, 997, -1, -1, -1, ! -1, -1, -1, 1173, 1174, 1175, 656, -1, -1, -1, ! -1, -1, -1, -1, 766, -1, 768, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 779, 65, 66, ! 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, ! 77, 78, 79, 601, 602, -1, -1, 1217, 3, 4, ! 608, 6, 7, 8, 9, -1, 11, 12, -1, -1, ! 312, -1, -1, 315, -1, -1, -1, 319, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, 1098, 53, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 360, -1, ! -1, -1, -1, -1, -1, 367, -1, 675, -1, -1, ! 872, 373, -1, 375, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, -1, 92, 390, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 412, 413, -1, 415, 916, 917, -1, 919, -1, -1, ! -1, -1, 1173, 1174, 1175, -1, -1, -1, -1, -1, ! -1, -1, -1, 833, 834, 835, 836, -1, 838, -1, ! 840, 841, 842, 843, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 766, -1, ! 768, -1, -1, -1, -1, -1, 1217, -1, -1, 869, ! -1, 779, -1, -1, -1, -1, 784, 785, -1, -1, ! -1, 3, 4, 5, 6, 7, -1, -1, 10, -1, ! 12, -1, 3, 4, 5, 6, 7, -1, -1, -1, ! -1, 12, -1, -1, -1, 27, -1, -1, -1, 31, ! -1, -1, -1, 35, -1, -1, 27, -1, -1, 41, ! 31, -1, -1, -1, 35, 833, 834, -1, 836, 51, ! 41, 53, 840, -1, 842, 843, -1, -1, -1, -1, ! 51, 941, 53, 65, -1, 56, -1, -1, -1, -1, ! -1, -1, -1, 75, 65, -1, -1, -1, -1, -1, ! -1, 83, -1, -1, 75, -1, 88, -1, -1, -1, ! -1, 93, 83, -1, -1, -1, -1, 88, -1, -1, ! 980, -1, 982, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 994, 995, -1, 997, 600, 601, ! 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, ! 79, -1, 624, 625, -1, 627, -1, -1, -1, 1, ! 938, 3, 4, 5, 6, 7, 8, 9, -1, 11, ! 12, 13, -1, 15, 16, 17, 18, 19, 20, 21, ! 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ! -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, ! 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, ! -1, 53, 54, -1, 56, -1, 994, 995, -1, 997, ! 62, -1, -1, 65, -1, -1, -1, -1, 1098, -1, ! -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, ! 82, 83, -1, -1, -1, -1, 88, -1, 90, 1, ! 92, 3, 4, 5, 6, 7, 8, 9, 10, 11, ! 12, 103, 104, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, ! -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, ! 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, ! -1, 53, 54, 1173, 1174, 1175, -1, -1, -1, -1, ! 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, ! -1, 73, 74, 75, 10, -1, -1, -1, -1, 81, ! 82, 83, -1, 85, -1, -1, 88, 89, -1, -1, ! 92, 93, -1, -1, -1, -1, -1, 1217, -1, -1, ! -1, -1, 104, -1, -1, -1, -1, -1, -1, -1, ! -1, 833, 834, -1, -1, -1, -1, -1, 840, -1, ! -1, 57, 58, 59, 60, 61, 62, 63, 64, 65, ! 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, ! 76, 77, 78, 79, -1, -1, -1, 869, -1, -1, ! 872, 1, 874, 3, 4, 5, 6, 7, 8, 9, -1, 11, 12, 13, -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, --- 786,2709 ---- 0, 1, 0, 2, 2, 0, 0, 1, 1, 0, 2, 1, 1, 1, 1, 5, 4, 3, 4, 4, ! 1, 0, 5, 1, 3, 1, 2, 1, 3, 1, ! 3, 1, 3, 0, 5, 0, 5, 0, 5, 0, ! 5, 3, 3, 6, 7, 4, 3, 3, 1, 1, ! 1, 1, 1, 2, 3, 3, 3, 3, 2, 2, ! 2, 2, 2, 1, 3, 4, 3, 5, 4, 3, ! 3, 2, 3, 3, 2, 1, 6, 4, 3, 3, ! 2, 2, 1, 3, 4, 2, 3, 0, 0, 1, ! 3, 2, 3, 1, 4, 2, 4, 2, 4, 2, ! 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, ! 4, 4, 3, 4, 3, 4, 0, 1, 3, 1, ! 1, 0, 6, 0, 1, 0, 2, 1, 1, 1, ! 1, 1, 1, 1, 1, 3, 1, 3, 0, 1, ! 1, 0, 8, 1, 2, 4, 4, 1, 3, 3, ! 3, 3, 1, 1, 1, 0, 3, 2, 2, 2, ! 2, 2, 2, 4, 2, 4, 2, 3, 3, 4, ! 4, 5, 5, 6, 2, 4, 5, 3, 3, 3, ! 1, 3, 2, 3, 4, 1, 2, 5, 1, 4, ! 4, 4, 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, ! 3, 3, 5, 3, 3, 1, 2, 3, 1, 1, ! 1, 1, 1, 1, 1, 2, 2, 3, 1, 1, ! 1, 3, 1, 1, 1, 1, 3, 3, 0, 4, ! 0, 6, 2, 4, 2, 2, 1, 4, 1, 7, ! 7, 7, 7, 4, 4, 2, 2, 1, 4, 2, ! 2, 2, 5, 3, 5, 3, 4, 6, 1, 2, ! 1, 2, 1, 1, 1, 2, 0, 2, 2, 3, ! 3, 3, 3, 3, 2, 2, 1, 1, 1, 2, ! 2, 2, 2, 1, 1, 1, 1, 2, 2, 3, ! 3, 4, 1, 2, 2, 1, 1, 2, 2, 1, ! 2, 2, 3, 1, 2, 1, 1, 1, 4, 4, ! 4, 4, 1, 1, 1, 1, 3, 1, 3, 1, ! 3, 0, 4, 0, 7, 4, 0, 7, 4, 0, ! 7, 4, 0, 7, 4, 0, 1, 1, 2, 6, ! 1, 3, 0, 1, 4, 6, 4, 1, 1, 1, ! 1, 1, 3, 1, 2, 3, 4, 1, 1, 3, ! 4, 6, 3, 5, 0, 7, 4, 0, 6, 3, ! 2, 2, 4, 1, 0, 1, 0, 1, 1, 2, ! 2, 2, 2, 3, 2, 2, 2, 3, 3, 1, ! 2, 0, 0, 3, 3, 2, 1, 1, 0, 1, ! 2, 1, 3, 1, 2, 1, 4, 4, 1, 1, ! 2, 2, 1, 0, 1, 4, 3, 1, 2, 2, ! 2, 2, 2, 2, 2, 2, 4, 2, 1, 5, ! 3, 0, 1, 3, 0, 1, 3, 1, 1, 1, ! 1, 4, 6, 4, 4, 6, 4, 3, 4, 6, ! 4, 4, 6, 4, 3, 1, 3, 1, 3, 2, ! 1, 6, 0, 2, 1, 2, 0, 2, 3, 3, ! 2, 2, 3, 1, 1, 1, 2, 5, 5, 3, ! 5, 4, 3, 3, 2, 1, 3, 3, 2, 2, ! 3, 1, 3, 3, 2, 2, 3, 1, 5, 5, ! 3, 5, 3, 4, 3, 2, 2, 1, 2, 4, ! 4, 2, 1, 1, 1, 2, 2, 2, 1, 2, ! 1, 2, 2, 3, 1, 3, 2, 3, 2, 2, ! 3, 1, 3, 4, 3, 2, 2, 1, 3, 2, ! 2, 1, 2, 3, 1, 3, 1, 5, 3, 4, ! 3, 4, 2, 2, 3, 2, 1, 1, 2, 2, ! 2, 0, 0, 1, 1, 2, 3, 1, 2, 3, ! 5, 6, 5, 0, 0, 6, 1, 2, 1, 1, ! 1, 2, 0, 4, 1, 0, 0, 6, 0, 0, ! 7, 0, 0, 0, 10, 0, 0, 0, 10, 0, ! 7, 0, 5, 0, 7, 0, 4, 2, 2, 2, ! 3, 6, 8, 10, 12, 4, 3, 2, 2, 1, ! 1, 0, 0, 7, 1, 2, 2, 0, 0, 5, ! 1, 1, 3, 3, 2, 2, 2, 3, 4, 4, ! 3, 4, 6, 6, 0, 1, 0, 1, 1, 0, ! 1, 1, 3, 4, 1, 3, 0, 1, 1, 1, ! 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, ! 3, 2, 2, 4, 2, 2, 2, 2, 2, 2, ! 1, 2, 1, 3, 1, 1, 0, 0, 1, 0, ! 4, 1, 1, 3, 0, 3, 3, 3, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, ! 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, ! 4, 4, 3, 2 }; static const short yydefact[] = { 3, ! 10, 10, 5, 0, 4, 0, 220, 523, 307, 317, ! 475, 0, 8, 9, 0, 0, 389, 0, 709, 0, ! 535, 221, 64, 0, 0, 697, 0, 76, 21, 0, ! 11, 6, 0, 15, 14, 13, 12, 277, 0, 524, ! 117, 230, 502, 0, 297, 0, 296, 310, 0, 330, ! 316, 0, 400, 402, 403, 408, 407, 384, 306, 529, ! 486, 0, 229, 231, 485, 0, 525, 318, 473, 0, ! 0, 219, 62, 63, 527, 0, 0, 101, 102, 103, ! 378, 381, 0, 531, 0, 382, 0, 0, 0, 32, ! 0, 307, 0, 22, 0, 0, 400, 0, 0, 0, ! 0, 500, 0, 0, 0, 499, 0, 0, 0, 0, ! 230, 0, 0, 0, 229, 231, 473, 0, 3, 0, ! 0, 0, 0, 402, 403, 700, 0, 88, 83, 277, ! 0, 0, 60, 528, 124, 473, 0, 477, 61, 0, ! 0, 0, 0, 0, 326, 287, 484, 288, 496, 0, ! 473, 309, 308, 59, 298, 0, 328, 0, 303, 323, ! 324, 299, 312, 314, 325, 0, 54, 390, 391, 392, ! 393, 406, 107, 106, 108, 395, 401, 397, 117, 396, ! 409, 409, 423, 0, 476, 311, 72, 0, 75, 533, ! 517, 487, 526, 0, 530, 0, 744, 740, 739, 737, ! 719, 724, 725, 0, 731, 730, 716, 717, 715, 734, ! 723, 720, 721, 722, 726, 727, 713, 714, 710, 711, ! 712, 736, 728, 729, 718, 735, 0, 732, 641, 310, ! 642, 705, 475, 234, 275, 0, 0, 0, 0, 156, ! 271, 269, 247, 273, 274, 0, 0, 0, 0, 0, ! 0, 0, 129, 128, 0, 130, 131, 0, 0, 216, ! 132, 0, 118, 0, 189, 0, 193, 186, 121, 233, ! 155, 0, 0, 235, 236, 0, 120, 294, 310, 295, ! 518, 258, 249, 0, 0, 0, 400, 380, 0, 375, ! 532, 0, 133, 134, 0, 0, 0, 0, 31, 0, ! 110, 409, 125, 109, 115, 0, 498, 0, 497, 102, ! 103, 218, 227, 0, 506, 226, 0, 505, 0, 232, ! 513, 0, 0, 18, 10, 0, 7, 7, 48, 47, ! 700, 0, 34, 42, 38, 36, 43, 40, 332, 82, ! 89, 86, 0, 0, 277, 0, 0, 0, 572, 65, ! 578, 67, 113, 511, 0, 674, 675, 154, 0, 153, ! 669, 691, 0, 294, 310, 295, 0, 668, 670, 698, ! 680, 0, 515, 0, 0, 0, 482, 0, 481, 0, ! 0, 0, 0, 473, 70, 58, 73, 0, 57, 473, ! 0, 477, 495, 0, 300, 301, 0, 55, 71, 56, ! 74, 305, 304, 315, 700, 331, 398, 394, 399, 410, ! 404, 405, 439, 0, 0, 442, 445, 0, 0, 428, ! 0, 700, 313, 0, 0, 346, 474, 501, 534, 0, ! 0, 733, 738, 473, 473, 0, 473, 743, 0, 0, ! 0, 163, 0, 0, 165, 0, 0, 0, 0, 0, ! 0, 0, 0, 162, 159, 158, 160, 0, 0, 0, ! 0, 217, 0, 116, 161, 0, 0, 187, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 243, 245, 246, 279, 278, 0, 0, 0, 0, 0, ! 167, 471, 0, 175, 276, 223, 0, 697, 222, 261, ! 262, 0, 289, 552, 548, 557, 0, 477, 473, 473, ! 473, 291, 555, 0, 522, 293, 0, 292, 260, 0, ! 256, 270, 272, 519, 0, 257, 112, 111, 468, 387, ! 466, 377, 0, 319, 0, 0, 320, 321, 322, 33, ! 0, 28, 24, 696, 310, 26, 695, 30, 693, 122, ! 114, 504, 503, 232, 507, 0, 17, 20, 19, 332, ! 53, 49, 51, 52, 50, 46, 0, 0, 0, 0, ! 346, 104, 94, 105, 0, 87, 90, 0, 0, 0, ! 368, 0, 364, 84, 0, 0, 66, 69, 579, 573, ! 473, 473, 673, 686, 679, 677, 552, 548, 0, 687, ! 473, 690, 692, 688, 0, 689, 473, 672, 685, 678, ! 676, 671, 699, 682, 683, 0, 514, 478, 480, 479, ! 0, 0, 494, 0, 346, 327, 490, 0, 0, 0, ! 493, 0, 483, 302, 329, 346, 332, 420, 0, 419, ! 411, 412, 414, 0, 416, 438, 434, 433, 220, 523, ! 473, 0, 667, 700, 435, 443, 448, 449, 700, 700, ! 436, 446, 700, 0, 383, 430, 429, 431, 432, 332, ! 702, 310, 703, 0, 0, 0, 345, 347, 348, 742, ! 741, 705, 705, 705, 0, 0, 0, 522, 0, 0, ! 523, 0, 157, 0, 0, 0, 0, 0, 0, 238, ! 237, 0, 184, 119, 220, 523, 221, 0, 0, 369, ! 385, 0, 215, 214, 659, 658, 0, 212, 211, 209, ! 210, 208, 207, 206, 203, 204, 205, 201, 202, 196, ! 197, 198, 199, 200, 194, 195, 0, 0, 0, 0, ! 0, 0, 169, 181, 0, 0, 168, 473, 473, 0, ! 473, 470, 542, 0, 0, 0, 0, 264, 0, 266, ! 0, 516, 551, 550, 547, 546, 696, 0, 0, 566, ! 0, 0, 563, 290, 564, 553, 473, 667, 477, 552, ! 548, 0, 0, 473, 233, 0, 518, 0, 0, 0, ! 388, 0, 387, 152, 151, 150, 149, 0, 23, 0, ! 395, 0, 0, 16, 346, 35, 39, 37, 41, 0, ! 0, 92, 0, 96, 0, 100, 0, 98, 0, 365, ! 0, 85, 68, 0, 580, 0, 574, 575, 512, 509, ! 551, 547, 552, 548, 0, 485, 0, 473, 553, 552, ! 548, 0, 233, 0, 518, 510, 0, 681, 336, 473, ! 473, 473, 492, 342, 346, 0, 0, 422, 421, 415, ! 0, 0, 441, 346, 0, 79, 0, 332, 332, 0, ! 332, 0, 346, 0, 701, 0, 0, 343, 349, 707, ! 706, 708, 248, 164, 0, 0, 0, 166, 190, 192, ! 191, 254, 255, 0, 0, 0, 0, 240, 0, 0, ! 0, 0, 185, 0, 241, 244, 179, 178, 171, 0, ! 170, 183, 0, 0, 539, 537, 0, 540, 477, 176, ! 0, 0, 267, 0, 0, 549, 545, 556, 473, 565, ! 554, 559, 0, 561, 0, 0, 520, 521, 0, 259, ! 469, 467, 379, 0, 25, 29, 694, 0, 0, 44, ! 93, 91, 0, 0, 0, 0, 366, 362, 0, 0, ! 220, 523, 584, 596, 599, 0, 572, 0, 0, 0, ! 0, 0, 0, 221, 630, 0, 655, 0, 591, 0, ! 0, 310, 0, 568, 589, 595, 567, 590, 631, 0, ! 602, 606, 576, 551, 547, 487, 553, 521, 684, 334, ! 491, 488, 489, 340, 339, 0, 0, 413, 346, 346, ! 78, 458, 473, 220, 523, 0, 444, 450, 451, 700, ! 700, 346, 346, 447, 0, 437, 704, 333, 353, 0, ! 0, 0, 0, 0, 0, 373, 0, 0, 370, 188, ! 213, 126, 0, 172, 173, 180, 182, 538, 536, 543, ! 541, 0, 177, 0, 263, 265, 562, 473, 560, 228, ! 376, 0, 45, 95, 99, 97, 367, 0, 577, 571, ! 583, 645, 647, 572, 572, 572, 0, 0, 0, 616, ! 618, 619, 620, 0, 0, 0, 646, 572, 656, 0, ! 592, 285, 700, 0, 286, 0, 700, 0, 700, 0, ! 0, 581, 570, 569, 593, 629, 628, 572, 572, 0, ! 0, 337, 417, 418, 457, 454, 440, 0, 0, 346, ! 332, 332, 452, 455, 359, 360, 361, 358, 0, 351, ! 354, 344, 0, 0, 0, 0, 371, 0, 0, 126, ! 242, 0, 174, 544, 268, 558, 123, 363, 0, 0, ! 0, 587, 0, 0, 572, 648, 0, 651, 0, 0, ! 612, 0, 621, 0, 627, 632, 0, 281, 332, 283, ! 284, 332, 0, 0, 0, 280, 282, 582, 572, 0, ! 0, 335, 341, 0, 77, 346, 346, 465, 346, 346, ! 0, 0, 353, 0, 0, 250, 251, 252, 253, 0, ! 374, 127, 472, 137, 0, 585, 597, 588, 600, 652, ! 650, 0, 649, 144, 0, 310, 0, 0, 0, 617, ! 626, 0, 0, 594, 141, 0, 140, 0, 338, 464, ! 461, 459, 462, 453, 456, 352, 350, 220, 0, 372, ! 0, 572, 0, 0, 0, 0, 610, 700, 614, 613, ! 0, 635, 0, 633, 660, 0, 603, 607, 0, 0, ! 0, 355, 357, 138, 586, 573, 598, 148, 135, 0, ! 0, 654, 0, 653, 572, 332, 0, 637, 636, 638, ! 0, 0, 661, 662, 622, 0, 0, 460, 463, 0, ! 145, 0, 0, 601, 611, 346, 615, 634, 0, 660, ! 0, 0, 0, 0, 356, 0, 0, 136, 0, 639, ! 0, 0, 623, 663, 604, 608, 147, 146, 142, 0, ! 664, 0, 0, 0, 0, 0, 0, 0, 665, 0, ! 624, 605, 609, 143, 0, 0, 640, 0, 0, 643, ! 644, 666, 625, 0, 0, 0 }; ! static const short yydefgoto[] = { 1354, ! 1, 2, 120, 568, 987, 3, 4, 31, 32, 33, ! 300, 551, 552, 553, 34, 91, 35, 577, 579, 578, ! 580, 576, 36, 37, 38, 415, 129, 130, 131, 341, ! 586, 587, 539, 588, 177, 39, 40, 41, 135, 262, ! 263, 303, 813, 304, 1151, 264, 988, 1281, 1216, 1236, ! 1237, 1336, 1277, 293, 793, 265, 448, 500, 757, 266, ! 267, 268, 294, 270, 510, 313, 43, 271, 460, 1052, ! 272, 273, 274, 275, 132, 276, 989, 405, 520, 777, ! 990, 45, 162, 991, 47, 163, 443, 164, 144, 156, ! 49, 635, 145, 1120, 406, 1194, 157, 1121, 50, 1040, ! 687, 688, 689, 1139, 1140, 1141, 969, 720, 721, 51, ! 543, 289, 912, 802, 52, 53, 54, 55, 181, 182, ! 56, 57, 58, 411, 651, 652, 653, 654, 184, 418, ! 419, 420, 421, 665, 671, 666, 1027, 667, 668, 1028, ! 1029, 540, 541, 501, 783, 59, 374, 375, 146, 60, ! 61, 147, 148, 114, 63, 511, 281, 282, 283, 65, ! 284, 67, 68, 180, 69, 285, 762, 763, 778, 523, ! 993, 994, 1161, 836, 837, 838, 350, 995, 996, 1084, ! 1252, 1163, 997, 998, 1189, 1085, 1253, 1086, 1254, 1118, ! 1296, 1334, 1119, 1297, 1335, 1285, 1229, 1287, 1172, 999, ! 1232, 1290, 1264, 1308, 1330, 1227, 1338, 1000, 1001, 1002, ! 1100, 727, 1292, 1293, 1294, 1340, 367, 779, 369, 370, ! 371, 558, 372, 107, 625, 1179, 683, 684, 438, 71, ! 72 }; ! static const short yypact[] = { 64, ! 80,-32768,-32768, 2131,-32768, 130,-32768, 283, 48,-32768, ! -32768, 556,-32768,-32768, 66, 87,-32768, 206,-32768, 2650, ! -32768, 210,-32768, 1299, 1299,-32768, 1901,-32768,-32768, 292, ! -32768, 333, 3137,-32768,-32768,-32768,-32768, 573, 353, 368, ! -32768,-32768, 166, 1701,-32768, 2829,-32768, 1033, 294,-32768, ! -32768, 540,-32768,-32768,-32768,-32768,-32768, 396, 1486,-32768, ! -32768, 591,-32768,-32768,-32768, 82,-32768,-32768,-32768, 214, ! 6712,-32768,-32768,-32768,-32768, 8620, 2499,-32768, 283, 210, ! 355, 414, 368,-32768, 214,-32768, 214, 8620, 8620,-32768, ! 512,-32768, 210,-32768, 4042, 3298, 1, 214, 8446, 283, ! 2225,-32768, 361, 267, 2225,-32768, 262, 2706, 2706, 1901, ! 383, 435, 166, 453, 495, 498,-32768, 571, 446, 2532, ! 224, 4042, 3192, 680, 723, 521, 617,-32768, 55, 16, ! 143, 143,-32768,-32768, 546,-32768, 6059, 532,-32768, 3255, ! 3255, 4407, 641, 569,-32768,-32768, 255,-32768,-32768, 82, ! -32768,-32768,-32768,-32768, 1033, 669,-32768, 998,-32768,-32768, ! -32768, 1070, 673,-32768,-32768, 4042,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768,-32768,-32768, 368, 775,-32768, ! 609, 609,-32768, 2064,-32768, 673,-32768, 604, 970,-32768, ! -32768,-32768,-32768, 3851,-32768, 50,-32768, 605, 633,-32768, ! -32768,-32768,-32768, 640,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768,-32768, 601,-32768,-32768, 673, ! 1486, 654, 627,-32768,-32768, 9561, 9644, 659, 664,-32768, ! -32768,-32768,-32768,-32768,-32768, 675, 689, 696, 698, 701, ! 262, 9312,-32768,-32768, 9312,-32768,-32768, 9312, 6796, 3961, ! -32768, 422,-32768, 9312,-32768, 8707,-32768,-32768, 9780,-32768, ! 845, 1829, 8790,-32768, 781, 434,-32768, 126, 1601, 4144, ! -32768, 160,-32768, 475, 813, 4042, 1,-32768, 262, 690, ! -32768, 721, 743, 9688, 726, 728, 734, 800,-32768, 2499, ! -32768, 609,-32768,-32768,-32768, 478,-32768, 125,-32768,-32768, ! -32768,-32768,-32768, 2225,-32768,-32768, 2225,-32768, 758,-32768, ! -32768, 3851, 47,-32768, 729, 2499,-32768,-32768,-32768,-32768, ! 521, 708,-32768,-32768,-32768,-32768,-32768,-32768, 712,-32768, ! 249,-32768, 6886, 8877,-32768, 143, 143, 803,-32768,-32768, ! -32768,-32768,-32768, 855, 765,-32768,-32768, 743, 767, 9688, ! 296, 2466, 3192, 2466, 3043, 3464, 772,-32768, 100, 3351, ! 807, 819,-32768, 776, 8877, 3862,-32768, 3862,-32768, 4280, ! 4280, 4407, 785,-32768,-32768,-32768, 970, 4042,-32768,-32768, ! 6161, 792,-32768, 4311, 1070, 1033, 4042,-32768,-32768,-32768, ! 970,-32768,-32768,-32768, 521,-32768,-32768,-32768,-32768, 905, ! -32768,-32768,-32768, 8877, 447, 1155, 3724, 60, 1544,-32768, ! 252, 521, 673, 2142, 802, 867,-32768,-32768,-32768, 796, ! 798,-32768,-32768,-32768,-32768, 164,-32768,-32768, 8877, 627, ! 6796,-32768, 229, 6796,-32768, 8877, 8964, 9312, 8620, 2142, ! 2142, 2142, 2142,-32768,-32768,-32768,-32768, 805, 809, 803, ! 810,-32768, 8620,-32768,-32768, 6623, 6796,-32768, 8877, 8877, ! 6976, 8877, 8877, 8877, 8877, 8877, 8877, 8877, 8877, 8877, ! 8877, 8877, 8877, 8877, 8877, 8877, 8877, 8877, 8877, 8877, ! -32768,-32768,-32768,-32768,-32768, 8877, 8877, 8877, 8620, 1393, ! 564, 670, 7615,-32768,-32768, 283, 865, 912,-32768, 237, ! 244, 615,-32768, 1080, 1080,-32768, 3796, 814, 837, 884, ! -32768,-32768, 490, 8090, 114,-32768, 188,-32768,-32768, 8877, ! -32768,-32768,-32768,-32768, 626,-32768,-32768,-32768, 877, 874, ! -32768,-32768, 262,-32768, 7438, 7528,-32768,-32768,-32768,-32768, ! 606, 879,-32768,-32768, 3594, 540,-32768,-32768, 887,-32768, ! -32768,-32768,-32768, 844,-32768, 891,-32768,-32768,-32768, 712, ! -32768,-32768,-32768,-32768,-32768,-32768, 893, 896, 897, 903, ! 867,-32768,-32768, 210, 8877, 906,-32768, 280, 420, 436, ! -32768, 6263, 9757,-32768, 849, 143,-32768,-32768,-32768, 24, ! -32768,-32768,-32768,-32768,-32768,-32768, 817, 817, 4802,-32768, ! -32768,-32768,-32768,-32768, 8181,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768, 902, 6886,-32768,-32768,-32768,-32768, ! 3862, 3862,-32768, 4311, 867,-32768, 855, 861, 863, 866, ! -32768, 872,-32768, 1070,-32768, 867, 712,-32768, 883,-32768, ! 923,-32768,-32768, 939,-32768, 9757,-32768,-32768, 922, 18, ! -32768, 8877, 2818, 521, 930,-32768,-32768,-32768, 510, 611, ! 934,-32768, 521, 937,-32768,-32768,-32768,-32768,-32768, 748, ! -32768, 3086,-32768, 281, 571, 916, 947, 867,-32768,-32768, ! -32768, 282, 282, 282, 904, 908, 9051, 884, 913, 915, ! 192, 917,-32768, 918, 920, 938, 944, 948, 957,-32768, ! -32768, 932,-32768,-32768, 975, 421, 338, 8877, 976,-32768, ! 987, 941, 9757, 9757,-32768,-32768, 988, 4588, 9818, 4862, ! 4703, 4168, 4535, 3669, 1937, 1937, 1937, 1334, 1334, 1050, ! 1050, 713, 713, 713,-32768,-32768, 955, 954, 959, 958, ! 961, 2142, 564,-32768, 6886, 8877,-32768,-32768,-32768, 8877, ! -32768,-32768, 980, 9312, 967, 981, 1030,-32768, 8877,-32768, ! 8877,-32768, 1350,-32768, 1350,-32768, 71, 977, 978,-32768, ! 973, 2142, 855,-32768, 855, 1728,-32768, 1109, 983, 8272, ! 8272, 5855, 979, 8707, 383, 984, 498, 813, 989, 8877, ! 262, 982, 874,-32768, 9757,-32768, 9757, 2499,-32768, 2761, ! 662, 6886, 396,-32768, 867,-32768,-32768,-32768,-32768, 708, ! 994,-32768, 249,-32768, 8877,-32768, 8877,-32768, 8877,-32768, ! 116,-32768,-32768, 262,-32768, 5585, 1049,-32768, 855, 855, ! 1260, 1260, 1918, 1918, 4802,-32768, 82,-32768, 2412, 8359, ! 8359, 5957, 240, 1005, 341, 855, 6886,-32768, 1031,-32768, ! -32768,-32768,-32768, 1051, 867, 8620, 905,-32768,-32768,-32768, ! 8877, 8877, 152, 4929, 1006,-32768, 401, 712, 712, 3568, ! 755, 2290, 867, 2142,-32768, 54, 1023,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768, 9395, 9395, 7066,-32768,-32768,-32768, ! -32768,-32768,-32768, 1024, 1029, 1032, 1034,-32768, 4688, 6886, ! 6353, 1020,-32768, 8877,-32768,-32768,-32768,-32768, 474, 1035, ! -32768,-32768, 1039, 44, 181, 181, 1027, 181,-32768,-32768, ! 9312, 1128,-32768, 1044, 1046,-32768,-32768,-32768,-32768,-32768, ! -32768, 855, 1059,-32768, 1047, 1062,-32768,-32768, 452,-32768, ! 9757,-32768,-32768, 1063,-32768,-32768,-32768, 2064, 708,-32768, ! -32768,-32768, 1068, 1071, 1073, 6443,-32768,-32768, 745, 289, ! 1075, 575,-32768,-32768,-32768, 1065,-32768, 8877, 1116, 1121, ! 1122, 8533, 67, 572,-32768, 1129, 1175, 1131,-32768, 2565, ! 4428, 2918, 5022,-32768,-32768, 1170,-32768,-32768,-32768, 7718, ! -32768,-32768,-32768, 1260, 1260,-32768, 2412, 1408,-32768,-32768, ! 855, 855, 855,-32768, 1132, 1089, 1093,-32768, 4929, 4929, ! -32768,-32768,-32768, 1138, 624, 8877,-32768,-32768,-32768, 521, ! 521, 867, 867,-32768, 2406,-32768,-32768,-32768, 583, 6886, ! 8877, 8877, 8877, 8877, 6886,-32768, 8877, 1140,-32768,-32768, ! 9801, 546, 8877,-32768, 474,-32768,-32768,-32768,-32768,-32768, ! -32768, 1100,-32768, 1163,-32768,-32768, 855,-32768,-32768,-32768, ! -32768, 73,-32768,-32768,-32768,-32768,-32768, 262,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768, 803, 6533, 1123, 4518,-32768, ! -32768,-32768,-32768, 1153, 8877, 1158,-32768,-32768,-32768, 1130, ! -32768,-32768, 191, 763,-32768, 788, 521, 9138, 427, 797, ! 307,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 6886, ! 6886,-32768,-32768,-32768,-32768,-32768, 152, 8877, 8877, 4929, ! 712, 712, 1159, 1161,-32768,-32768,-32768,-32768, 315,-32768, ! 1133,-32768, 1120, 1126, 1127, 1137,-32768, 9711, 6886, 546, ! -32768, 1119,-32768,-32768,-32768, 855,-32768,-32768, 462, 462, ! 8000,-32768, 1210, 1184, 1139,-32768, 1189,-32768, 8620, 8877, ! -32768, 7820,-32768, 1190,-32768,-32768, 571,-32768, 712,-32768, ! -32768, 712, 9478, 9478, 7156,-32768,-32768,-32768, 803, 7246, ! 7246,-32768,-32768, 6886,-32768, 4929, 4929,-32768, 867, 867, ! 6886, 6886, 583, 1146, 9225,-32768,-32768,-32768,-32768, 6886, ! -32768,-32768,-32768,-32768, 8620,-32768,-32768,-32768,-32768,-32768, ! -32768, 5675,-32768,-32768, 1148, 416, 4042, 9734, 7820,-32768, ! -32768, 5141, 51,-32768,-32768, 1198,-32768, 1199,-32768,-32768, ! -32768, 1174, 1200,-32768,-32768,-32768,-32768, 369, 1154,-32768, ! 1160, 803, 7910, 527, 370, 5273,-32768, 521,-32768,-32768, ! 379,-32768, 5377,-32768, 1248, 1204,-32768,-32768, 6886, 6886, ! 8877,-32768,-32768,-32768,-32768, 25,-32768,-32768,-32768, 8877, ! 1205,-32768, 1213,-32768, 803, 712, 7820,-32768,-32768,-32768, ! 1178, 271, 1216,-32768,-32768, 7336, 7336,-32768,-32768, 1171, ! -32768, 5765, 1172,-32768,-32768, 867,-32768, 1181, 8877, 1248, ! 1222, 1248, 1177, 1187,-32768, 397, 5481,-32768, 1233,-32768, ! 1192, 365,-32768,-32768,-32768,-32768,-32768,-32768,-32768, 1208, ! -32768, 1271, 1236, 7910, 7910, 6886, 3413, 803,-32768, 410, ! -32768,-32768,-32768,-32768, 1195, 1197,-32768, 1296, 1251,-32768, ! -32768,-32768,-32768, 1308, 1309,-32768 }; static const short yypgoto[] = {-32768, ! 1191,-32768,-32768, 986, 7, 1310,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768, 507,-32768,-32768,-32768,-32768,-32768,-32768, ! -32768, -770, 1196, 1207,-32768,-32768,-32768,-32768, 1201,-32768, ! -32768, 496, 135,-32768,-32768,-32768, 2838, -25,-32768, 1221, ! 888, -999,-32768, -88, 178,-32768, 895,-32768, 169, 139, ! -1101,-32768, -524, 1474, -99, 619,-32768,-32768, -714, 3947, ! 43, -240, 2252, 2872, 825, 1176, 432,-32768,-32768,-32768, ! -32768, -273,-32768, -116, -94,-32768, 266, 17, -276, 132, ! 75, -106, -109, -3, 1594, 27, 1371, -118, -752, 364, ! -32768, -82,-32768,-32768, 265,-32768,-32768,-32768,-32768,-32768, ! 327,-32768, 677,-32768, 155,-32768,-32768, 730, 769, 74, ! -32768,-32768,-32768, 560, -272, 13, 1335, 1336,-32768,-32768, ! -32768,-32768,-32768, -141,-32768, 500, 716,-32768, 559, 418, ! 497, -414,-32768,-32768,-32768,-32768,-32768,-32768, 960,-32768, ! 501, 835, 582, 889, 2241, 1820, -368,-32768, 3695, -55, ! 10,-32768, 4252, -90, 717,-32768, 3290,-32768,-32768, 3834, ! -4, 245, -328, 1372, 3416, 871, -214,-32768, 4134,-32768, ! -1157, -942, -343, 117,-32768, 553, -97, -122,-32768,-32768, ! -32768, -1137, -860, -1112,-32768,-32768,-32768,-32768,-32768,-32768, -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, ! -32768,-32768,-32768,-32768,-32768, -37,-32768,-32768,-32768,-32768, ! -32768, -425, 86,-32768, 90,-32768, -354, -133,-32768,-32768, ! -293, 1052, -286,-32768,-32768, 40, 530,-32768, 57,-32768, ! -260 }; ! #define YYLAST 9897 static const short yytable[] = { 66, ! 46, 323, 525, 368, 677, 600, 557, 85, 351, 351, ! 30, 533, 590, 559, 195, 85, 96, 315, 318, 103, ! 103, 84, 103, 642, 536, 468, 179, 556, 66, 123, ! 362, 291, 97, 232, 352, 347, 640, 359, 921, 150, ! 412, 66, 195, 403, 404, 395, 353, 85, 1218, 960, ! 1113, 1234, 1150, 8, 85, 505, -124, 834, 834, 505, ! 143, 84, 505, -1, 1256, 196, 85, 1225, 75, 78, ! 310, 345, 85, 96, 1263, 128, 557, 872, 44, -2, ! 603, 655, 85, 559, 7, 8, 76, 513, 525, 287, ! 150, 85, 77, 85, 95, 674, 103, 302, 342, 308, ! 103, 189, 93, 103, 103, 103, 426, 122, 674, 618, ! 1265, 301, 343, 1251, 1275, 66, 46, 150, 66, 311, ! -473, 165, 19, -473, 429, 604, 835, 1301, 100, 100, ! 605, 697, 1114, 363, 22, 150, 150, 150, 331, 1117, ! 1278, 1095, 344, 348, 1317, 1057, 82, 1305, 566, 781, ! 1150, 286, 1266, 88, 619, 1038, 190, 784, 427, 620, ! 560, 150, 675, 606, 26, 339, 698, 100, -473, 513, ! 966, -473, 713, -473, 89, 1157, 21, 93, 93, 66, ! 417, 396, 387, -473, 100, 73, 176, 427, 1073, 103, ! 514, 8, 621, 362, 44, 425, 349, 401, 538, 429, ! 515, -473, -473, 529, 1054, -700, -473, 277, 90, 136, ! 516, -700, 423, 517, 518, -473, 93, 8, 967, 295, ! 297, 1278, 1278, 351, 351, 599, 85, 436, 165, 195, ! 277, 21, 74, 93, 502, 165, 165, 1104, 190, 1110, ! 93, 312, 75, 188, 595, 758, 1178, 530, 597, 598, ! 596, 582, 8, 137, 138, 759, 581, 368, 416, 165, ! 76, 533, 190, 362, 78, 310, 93, 85, 361, 760, ! 100, 512, 513, 436, 436, 527, 403, 404, 99, 329, ! 768, 150, 188, -230, 362, 100, 644, 770, 427, 315, ! 318, 639, 583, 900, 455, 85, 363, 456, 390, 21, ! 457, 584, 537, 165, 404, 603, 465, 678, 875, 103, ! 193, 1230, 103, 1113, 311, 504, 697, 103, 646, 93, ! 1113, 85, 96, 824, 769, 655, 330, -230, -230, 193, ! 1310, 771, 21, 75, 93, 884, 585, 712, 97, 695, ! 1153, -224, 391, 392, 1080, 425, 434, 193, 166, 167, ! 604, 76, 165, -696, 679, 605, 435, 150, 66, 150, ! 150, 527, 1080, 7, 100, 66, 363, 825, 1260, 1203, ! 570, 150, 1311, 150, 1113, 150, 150, 150, 610, 118, ! 614, 616, 885, 150, -231, 454, 119, 363, 606, 150, ! 461, 1081, 150, 425, 193, 1114, 747, -103, 749, 750, ! 95, 19, 1114, 1024, 1025, 85, 99, 425, 133, 1188, ! 362, 150, 66, 22, 66, 417, 1204, 362, 134, 85, ! 945, 160, 161, 1271, 1332, 1080, 1307, 12, -231, -231, ! 799, 554, 664, 943, 1080, 190, 7, 506, 165, 507, ! 193, 19, -225, 26, 647, 85, 85, 85, 85, 183, ! 17, 21, 1080, 22, 7, 8, 1114, 288, 113, 513, ! 1026, 680, 502, 826, 1348, 140, 1333, 290, 165, 165, ! 1272, 75, 1282, 351, 19, 141, 463, 7, 8, 828, ! -102, 1288, 1186, 26, -224, 821, 22, 815, 142, 76, ! 703, 464, 19, 416, 590, 85, 165, 436, 833, 1327, ! 657, 554, 362, 697, 22, 1214, 658, 827, 362, 436, ! 436, 1349, 527, 363, 557, 19, 508, 754, 188, 66, ! 363, 559, 361, 829, 533, 403, 429, 22, 193, 368, ! 179, 755, 463, 787, 26, 556, 320, 536, 655, 113, ! 113, 113, 78, 79, 168, 169, 170, 561, 324, 1215, ! 150, 85, 193, 468, 321, 681, 362, 26, 78, 79, ! 1062, 756, 1053, -287, 865, 84, 298, 299, 886, -287, ! 1279, 616, 696, 113, 171, 699, 425, 788, 789, 235, ! 705, 706, 707, 708, 709, 78, 310, 1135, 1136, 1137, ! 21, 187, 80, 172, 277, 127, -508, 883, 722, -225, ! 719, 188, 150, 150, 847, 363, 21, 754, 80, 81, ! 847, 363, 188, -700, 1280, -700, -700, 7, 506, 340, ! 677, 755, -700, 388, 389, 75, 150, 150, 165, 150, ! 751, 1097, 128, 1088, 1083, 311, 373, 173, 174, 175, ! 99, 385, 302, 76, -700, -700, -700, 698, -700, 85, ! -700, 756, 636, 425, 368, 19, 923, 100, 847, 363, ! 808, 645, 241, -700, -288, -700, -700, 22, 410, 934, ! -288, 935, -700, 100, 75, 809, 21, 436, 160, 161, ! 193, 362, 188, 1129, 12, 362, 425, 436, 436, 436, ! 811, 424, 76, 430, -700, -700, 386, 26, -700, 432, ! -700, 362, 188, 876, 21, 433, 93, 17, 878, 879, ! 1058, 1059, 881, 1061, 439, 698, -27, 165, 434, -27, ! 21, 431, 93, 397, 398, 963, 719, 964, 435, 965, ! 571, -27, 188, 333, 758, 334, 13, 14, 362, 335, ! 1159, 1160, 195, 115, 759, 362, 446, 85, 890, 891, ! 892, 447, 315, 318, 1176, 165, 193, 450, 760, 315, ! 318, 572, 449, 573, 451, 574, 452, 575, 436, 453, ! 436, 193, 13, 14, 1190, 1191, 336, 85, 337, 13, ! 14, 436, 338, 85, 363, 66, 66, 66, 363, 505, ! 489, 490, 542, 949, 361, 1032, 1033, 545, 1033, 1078, ! 1079, -81, 550, 85, 363, 85, 930, -81, -80, 1342, ! 1343, 113, 113, 113, -80, 531, 8, 388, 1180, 7, ! 8, 1222, 544, 11, 115, 115, 115, 547, 407, 548, ! 408, 567, 455, 456, 409, 549, 150, 150, 150, 150, ! 847, 363, 397, 1181, 150, 847, 847, 847, 363, 241, ! 532, 388, 1187, 19, 442, 445, 349, 19, 115, 564, ! 513, 427, 85, 21, -695, 93, 601, 21, 602, 22, ! 1313, 1314, 150, 617, 70, 103, 626, 66, 417, 85, ! 627, 607, 87, 920, 425, 425, 633, 425, 491, 685, ! 98, 608, 455, 456, 104, 104, 641, 104, 686, 26, ! 690, 516, 691, 70, 609, 518, 710, 820, 8, 648, ! 711, 713, 1021, 722, 104, 766, 70, 767, 780, 361, ! 436, 436, 87, 436, 782, 492, 493, 784, 801, 98, ! 494, 495, 496, 497, 800, 649, 810, 455, 456, 554, ! 650, 98, 8, 868, 812, -228, 814, 98, 816, 698, ! 832, 817, 818, 66, 417, 21, 416, 93, 819, 857, ! 823, 859, 860, 1162, 861, 104, 98, 862, 968, 649, ! 866, 104, 864, 1063, 869, 104, 863, 867, 104, 104, ! 104, 871, 292, 296, 877, 150, 66, 150, 880, 21, ! 70, 93, 104, 70, 13, 14, 882, 1017, 399, 150, ! 150, -332, 150, 887, 888, 893, 1103, 904, 1109, 894, ! 104, 104, 104, 905, 898, 681, 899, 906, 901, 902, ! -700, 903, -700, -700, -332, -332, 907, -332, 461, -700, ! 66, 417, 416, 908, -101, 910, 104, 159, 160, 161, ! 113, 911, 913, 557, 12, 1048, 113, 914, 1199, 1200, ! 1346, -700, -700, 400, 70, -700, 915, -700, 916, 918, ! 1233, 917, 919, 932, 104, 165, 1162, 17, 929, 1131, ! 1132, 931, 594, 933, 402, 160, 161, 940, 938, 939, ! 947, 12, 834, 100, 953, 948, 11, 944, 1010, 188, ! 950, 193, 315, 318, 113, 961, 115, 115, 115, 646, ! 1048, 98, 104, 847, 17, 1249, 1008, 1023, 1014, 416, ! 1039, 1041, 8, 92, 10, 11, 1042, 1096, 356, 1043, ! 12, 1044, 1050, 513, 486, 487, 488, 489, 490, 1162, ! 21, 1060, 93, 1064, 1082, 15, 1055, 425, 425, 16, ! 1056, 959, 98, 17, 514, 1065, 1182, 1066, 104, 104, ! 70, 1069, 1087, 459, 515, 535, 104, 659, 660, 21, ! 1068, 93, 1162, 1070, 516, 1071, 1195, 517, 518, 1074, ! 98, 1300, 1075, 1138, 1076, 1090, 1091, 1092, 847, 847, ! 847, 1099, 1098, 1115, 104, 425, 1101, 104, 425, 1122, ! 1123, 1015, 104, 193, 1124, 19, 98, 1128, 661, 1149, ! 1022, 357, 112, 1306, 1154, 21, 1155, 22, 1173, 1036, ! 1169, 98, 1158, 1175, 662, 1347, 1201, 1177, 1202, 140, ! 1205, 1206, 150, 1213, 1219, 455, 456, 1207, 1208, 141, ! 362, 1269, 104, 70, 104, 104, 70, 26, 1209, 1220, ! 70, 1221, 663, 1258, 1223, 1231, 104, 1247, 104, 1257, ! 104, 104, 104, 1267, 1268, 1273, 1291, 1270, 104, 1295, ! 1304, 1274, 7, 8, 104, 1309, 185, 104, 1080, 628, ! 1312, 1320, 1315, 1318, 113, 113, 113, 1323, 1325, 1339, ! 98, 113, 113, 113, 316, 319, 104, 70, 1326, 70, ! 1329, 1341, 425, 1331, 98, 1337, 1350, 1286, 1351, 165, ! 19, 7, 100, 513, 1352, 11, 1353, 1355, 1356, 325, ! 21, 5, 22, 569, 955, 327, 461, 112, 962, 306, ! 98, 98, 98, 98, 607, 115, 328, 1212, 1217, 1238, ! 346, 115, 85, 363, 608, 459, 772, 1138, 459, 19, ! 700, 702, 26, 704, 516, 1125, 1126, 609, 518, 21, ! 714, 22, 1168, 100, 1106, 858, 185, 1246, 1133, 1134, ! 831, 459, 954, 24, 889, 726, 1018, 124, 125, 870, ! 98, 958, 104, 25, 48, 1072, 672, 803, 1035, 115, ! 1034, 26, 952, 86, 104, 104, 27, 70, 753, 1003, ! 48, 748, 1302, 513, 798, 1322, 8, 765, 10, 11, ! 21, 1324, 93, 48, 12, 535, 484, 485, 486, 487, ! 488, 489, 490, 1037, 514, 0, 155, -232, 0, 15, ! 0, 624, 0, 16, 515, 104, 87, 17, 0, 186, ! 0, 0, -232, -232, 516, 0, 0, 517, 518, -232, ! 0, 230, 0, 21, 0, 93, 279, 48, 0, 0, ! 0, -232, 0, 0, 0, 0, 1198, 0, 279, 279, ! 0, 0, -232, -232, 0, -232, 155, -232, 554, 279, ! 0, 0, 0, 0, 0, 0, 0, 104, 104, 70, ! 752, 0, 0, 0, 922, 798, 0, 0, 0, 8, ! 48, 10, 185, 155, 0, -232, -232, 12, 0, -232, ! -232, 104, 104, 0, 104, 0, 0, 365, 0, -232, ! 0, 0, 15, 0, 0, 0, 16, 0, 0, 0, ! 17, 0, 1240, 1241, 98, 1242, 1243, 0, 0, 0, ! 0, 0, 0, 70, 0, 0, 21, 0, 93, 113, ! 0, 957, 0, 0, 413, 0, 7, 8, 92, 10, ! 11, 0, 104, 0, 48, 12, 316, 319, 0, 115, ! 115, 115, 104, 104, 104, 0, 115, 115, 115, 0, ! 15, 0, 0, 0, 16, 0, 0, 0, 17, -425, ! 0, 0, 0, 0, 19, 0, 1009, 0, 0, 0, ! 0, 0, 0, 0, 21, 0, 22, 0, 0, 676, ! 0, 186, 0, 414, 100, 0, 160, 161, 24, 0, ! 358, 0, 12, 0, 113, 113, 113, 0, 25, 0, ! 0, 0, 98, 0, 0, 0, 26, 0, 0, 279, ! 0, 27, 1319, 0, 0, 17, 0, 0, 0, 1046, ! 1049, 0, 230, 104, 513, 104, -425, 0, 0, 0, ! 186, 21, 98, 93, 927, 0, 104, 0, 98, 0, ! 798, 798, 798, 0, 229, 514, 0, 0, 535, 278, ! 555, 0, 0, 0, 0, 515, 0, 0, 98, 0, ! 98, 278, 278, 0, 0, 516, 459, 0, 524, 518, ! 0, 0, 278, 98, 0, 1049, 48, 0, 0, 796, ! 0, 0, 0, 7, 8, 0, 0, 0, 0, 0, ! 0, 104, 104, 104, 104, 70, 0, 0, 0, 104, ! 798, 798, 798, 0, 0, 0, 0, 0, 0, 0, ! 364, 100, 0, 155, 427, 0, 186, 98, 0, 0, ! 555, 19, 0, 0, 0, 0, 459, 104, 0, 0, ! 104, 21, 70, 22, 98, 0, 139, 0, 0, 0, ! 1016, 365, 0, 0, 0, 140, 0, 0, 0, 1142, ! 0, 513, 0, 0, 1147, 141, 0, 0, 21, 0, ! 93, 0, 0, 26, 112, 0, 0, 155, 142, 48, ! 854, 459, 514, 0, 682, 104, 104, 0, 104, 0, ! 0, 0, 515, 0, 0, 0, 0, 0, 0, 0, ! 0, 279, 516, 0, 279, 517, 518, 358, 0, 279, ! 682, 682, 682, 682, 115, 0, 0, 0, 70, 0, ! 0, 0, 8, 279, 10, 11, 0, 279, 112, 0, ! 12, 0, 0, 101, 105, 0, 0, 0, 0, 1192, ! 1193, 0, 278, 0, 0, 15, 0, 0, 0, 16, ! 104, 70, 104, 17, 358, 229, 0, 0, 0, 279, ! 230, 0, 796, 0, 104, 104, 1094, 104, 1211, 21, ! 0, 93, 498, 0, 0, 0, 0, 555, 0, 0, ! 231, 0, 0, 364, 365, 280, 0, 0, 0, 115, ! 115, 115, 0, 7, 100, 70, 0, 280, 280, 0, ! 0, 0, 358, 0, 0, 0, 499, 0, 280, 0, ! 7, 8, 0, 1239, 11, 0, 0, 314, 317, 0, ! 1244, 1245, 0, 0, 0, 1143, 1144, 1145, 1146, 1250, ! 0, 19, 0, 0, 0, 0, 0, 1152, 0, 0, ! 0, 21, 0, 22, 0, 0, 366, 0, 19, 376, ! 378, 513, 0, 364, 0, 108, 316, 946, 21, 358, ! 22, 358, 358, 0, 0, 109, 0, 0, 798, 555, ! 0, 1167, 843, 26, 364, 365, 0, 0, 110, 1174, ! 0, 0, 844, 0, 0, 0, 0, 358, 1298, 1299, ! 26, 0, 516, 358, 0, 845, 518, 482, 483, 484, ! 485, 486, 487, 488, 489, 490, 0, 278, 0, 316, ! 319, 0, 0, 0, 0, 0, 316, 319, 0, 0, ! 0, 0, 0, 555, 278, 0, 0, 278, 0, 0, ! 0, 0, 278, 278, 278, 278, 278, 0, 0, 0, ! 0, 0, 0, 798, 798, 798, 278, 0, 358, 0, ! 278, 0, 0, 1224, 413, 1344, 7, 8, 92, 10, ! 11, 316, 946, 0, 0, 12, 0, 0, 280, 459, ! 0, 0, 0, 0, 1224, 1224, 0, 0, 358, 0, ! 15, 231, 278, 229, 16, 0, 0, 104, 17, -424, ! 0, 0, 0, 0, 19, 0, 0, 0, 0, 1224, ! 364, 0, 0, 0, 21, 0, 22, 364, 0, 366, ! 0, 0, 682, 414, 0, 0, 924, 0, 24, 0, ! 0, 6, 0, 7, 8, 9, 10, 11, 25, 0, ! 0, 0, 12, 0, 0, 8, 26, 10, 11, 0, ! 0, 27, 682, 12, 0, 13, 14, 15, 555, 0, ! 0, 16, 365, 0, 0, 17, -424, 0, 15, 18, ! 358, 19, 16, 0, 1303, 20, 17, 0, 555, 0, ! 956, 21, 0, 22, 0, 0, 23, 0, 0, 366, ! 726, 726, 21, 0, 93, 24, 0, 0, 0, 631, ! 632, 0, 364, 1321, 0, 25, 992, 98, 364, 0, ! 366, 0, 0, 26, 0, 555, 0, 0, 27, 0, ! 0, 0, 365, 0, 28, 29, 0, 7, 100, 358, ! 0, 185, 0, 0, 0, 0, 279, 0, 0, 0, ! 0, 0, 358, 280, 358, 0, 0, 0, 0, 0, ! 0, 0, 48, 0, 682, 0, 364, 0, 0, 0, ! 280, 0, 0, 280, 0, 19, 0, 279, 280, 280, ! 280, 280, 280, 0, 0, 21, 0, 22, 0, 0, ! 0, 0, 280, 854, 0, 0, 280, 0, 0, 24, ! 413, 0, 7, 8, 92, 10, 11, 0, 358, 25, ! 358, 12, 358, 0, 0, 0, 0, 26, 0, 194, ! 0, 0, 27, 0, 0, 0, 15, 0, 280, 231, ! 16, 0, 0, 0, 17, -427, 0, 269, 48, 0, ! 19, 0, 0, 773, 775, 0, 366, 0, 0, 0, ! 21, 0, 22, 366, 0, 278, 0, 0, 0, 414, ! 269, 0, 0, 0, 24, 0, 0, 322, 0, 316, ! 319, 155, 0, 992, 25, 0, 0, 0, 0, 0, ! 992, 0, 26, 0, 0, 278, 354, 27, 0, 0, ! 0, 364, 0, 0, 0, 364, 0, 0, 360, 0, ! 0, 394, -427, 0, 0, 0, 0, 0, 0, 0, ! 0, 364, 0, 0, 0, 48, 413, 0, 7, 8, ! 92, 10, 11, 0, 7, 8, 0, 12, 427, 0, ! 0, 0, 0, 0, 0, 0, 841, 842, 366, 0, ! 0, 0, 15, 0, 366, 0, 16, 0, 364, 0, ! 17, -426, 0, 0, 0, 364, 19, 0, 0, 0, ! 0, 0, 19, 0, 0, 513, 21, 992, 22, 278, ! 0, 676, 21, 0, 22, 414, 0, 0, 7, 8, ! 24, 0, 0, 0, 0, 0, 607, 278, 0, 0, ! 25, 0, 366, 0, 0, 0, 608, 0, 26, 0, ! 278, 0, 0, 27, 26, 0, 516, 0, 0, 609, ! 518, 0, 8, 92, 10, 11, 19, 0, -426, 513, ! 12, 462, 0, 0, 0, 0, 21, 0, 22, 0, ! 0, 0, 0, 0, 0, 15, 0, 0, 0, 16, ! 607, 992, 6, 17, 7, 8, 9, 10, 11, 1226, ! 608, 0, 992, 12, 0, 0, 0, 0, 26, 21, ! 516, 93, 0, 609, 518, 279, 0, 0, 15, 0, ! 1226, 1226, 16, 0, 0, 0, 17, 7, 8, 0, ! 0, 280, 19, 0, 0, 0, 326, 0, 0, 0, ! 0, 358, 21, 0, 22, 1226, 0, 23, 0, 0, ! 0, 0, 992, 0, 593, 360, 24, 0, 0, 992, ! 0, 280, 992, 0, 0, 19, 25, 366, 0, 773, ! 775, 366, 0, 0, 26, 21, 0, 22, 0, 27, ! 1102, 0, 0, 992, 634, 28, 992, 366, 0, 140, ! 637, 0, 0, 992, 0, 0, 0, 0, 0, 141, ! 0, 0, 360, 0, 0, 0, 0, 26, 0, 0, ! 0, 0, 142, 8, 92, 10, 11, 992, 0, 0, ! 0, 12, 1004, 1005, 366, 656, 0, 0, 0, 1004, ! 1005, 366, 992, 0, 692, 693, 15, 694, 358, 0, ! 16, 0, 0, 0, 17, 280, 0, 992, 0, 0, ! 360, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 21, 0, 93, 280, 992, 992, 0, 555, 7, 100, ! 0, 0, 11, 0, 269, 0, 280, 593, 94, 0, ! 723, 724, 0, 728, 729, 730, 731, 732, 733, 734, ! 735, 736, 737, 738, 739, 740, 741, 742, 743, 744, ! 745, 746, 0, 0, 358, 0, 19, 360, 0, 360, ! 360, 0, 0, 0, 0, 0, 21, 0, 22, 0, ! 785, 786, 229, 0, 8, 785, 10, 0, 0, 0, ! 108, 0, 12, 0, 0, 360, 0, 0, 278, 0, ! 109, 360, 0, 229, 229, 0, 0, 15, 26, 0, ! 0, 16, 0, 110, 0, 17, 805, 807, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 229, 0, ! 0, 21, 0, 93, 0, 0, 0, 0, 0, 0, ! 7, 8, 92, 10, 11, 0, 0, 356, 0, 12, ! 0, 7, 8, 152, 10, 153, 360, 0, 0, 0, ! 12, 839, 840, 593, 15, 0, 0, 0, 16, 83, ! 0, 849, 17, 0, 0, 15, 0, 856, 19, 16, ! 0, 83, 83, 17, 83, 0, 360, 0, 21, 19, ! 22, 0, 0, 0, 0, 42, 0, 593, 0, 21, ! 0, 22, 380, 0, 154, 0, 0, 0, 0, 178, ! 0, 0, 381, 24, 0, 42, 42, 0, 111, 0, ! 26, 873, 0, 25, 42, 382, 0, 0, 0, 0, ! 357, 26, 0, 874, 0, 42, 27, 42, 0, 0, ! 7, 8, 159, 160, 161, 0, 0, 0, 0, 12, ! 364, 0, 0, 0, 0, 0, 0, 191, 83, 0, ! 83, 83, 83, 0, 0, 83, 83, 83, 360, 0, ! 0, 0, 17, 0, 0, 0, 0, 0, 19, 0, ! 0, 513, 0, 0, 0, 0, 42, 0, 21, 909, ! 22, 0, 42, 0, 191, 0, 42, 0, 0, 111, ! 111, 111, 140, 0, 0, 0, 0, 0, 231, 0, ! 0, 42, 141, 42, 42, 0, 0, 0, 925, 926, ! 26, 928, 631, 632, 280, 1108, 593, 360, 0, 231, ! 231, 42, 42, 111, 0, 0, 0, 0, 0, 0, ! 360, 191, 360, 0, 0, 0, 0, 942, 0, 0, ! 0, 83, 0, 0, 231, 0, 0, 42, 0, 0, ! 0, 0, 0, 0, 0, 7, 8, 159, 160, 161, ! 0, 951, 0, 0, 12, 42, 0, 0, 0, 0, ! 0, 0, 0, 593, 0, 42, 0, 0, 0, 83, ! 0, 0, 0, 0, 0, 0, 360, 17, 360, 0, ! 360, 0, 0, 19, 0, 0, 513, 0, 1007, 100, ! 0, 160, 161, 21, 0, 22, 0, 12, 0, 0, ! 1011, 1012, 1013, 0, 0, 0, 0, 607, 593, 0, ! 0, 0, 0, 83, 0, 83, 83, 608, 0, 0, ! 17, 0, 1019, 1020, 0, 26, 0, 516, 0, 513, ! 615, 518, 0, 0, 0, 0, 21, 121, 93, 7, ! 8, 92, 10, 11, 0, 83, 0, 509, 12, 0, ! 514, 83, 0, 0, 83, 191, 366, 42, 0, 83, ! 515, 593, 593, 15, 0, 1051, 0, 16, 0, 0, ! 516, 17, 0, 517, 518, 0, 0, 19, 0, 1067, ! 0, 0, 0, 0, 0, 42, 0, 21, 42, 22, ! 0, 0, 0, 42, 7, 8, 152, 10, 153, 0, ! 0, 24, 0, 12, 0, 0, 0, 0, 0, 0, ! 0, 25, 0, 0, 0, 0, 0, 593, 15, 26, ! 0, 0, 16, 0, 27, 0, 17, 0, 0, 1089, ! 0, 0, 19, 42, 42, 42, 42, 0, 0, 0, ! 0, 42, 21, 0, 22, 0, 0, 42, 0, 42, ! 0, 111, 111, 111, 0, 0, 24, 7, 8, 42, ! 0, 11, 0, 1127, 0, 42, 25, 0, 42, 0, ! 0, 0, 0, 83, 26, 0, 0, 1130, 0, 27, ! 0, 0, 0, 0, 0, 0, 0, 42, 42, 0, ! 42, 593, 0, 64, 0, 19, 593, 0, 1148, 0, ! 0, 8, 152, 10, 153, 21, 0, 22, 1156, 12, ! 0, 0, 0, 64, 64, 0, 116, 0, 0, 140, ! 0, 0, 64, 0, 15, 0, 0, 0, 16, 141, ! 0, 0, 17, 64, 0, 64, 0, 26, 0, 83, ! 0, 0, 142, 0, 0, 0, 0, 0, 21, 83, ! 93, 83, 83, 7, 8, 92, 10, 11, 0, 360, ! 622, 0, 12, 0, 0, 0, 0, 0, 0, 0, ! 0, 593, 593, 0, 0, 0, 0, 15, 0, 1196, ! 1197, 16, 0, 509, 64, 17, 0, 0, 0, 0, ! 64, 19, 0, 178, 64, 795, 0, 116, 116, 116, ! 593, 21, 0, 22, 0, 0, 0, 0, 0, 64, ! 0, 64, 64, 0, 0, 24, 8, 92, 10, 11, ! 0, 1228, 1345, 0, 12, 25, 42, 0, 0, 64, ! 64, 116, 0, 26, 0, 0, 0, 0, 27, 15, ! 0, 0, 117, 16, 0, 593, 0, 17, 0, 0, ! 0, 0, 593, 593, 0, 64, 360, 0, 0, 151, ! 0, 593, 0, 21, 0, 93, -306, 8, -306, 10, ! 185, 0, 0, 64, 0, 12, 0, 0, 42, 42, ! 111, 0, 0, 64, 0, 0, 853, 0, 0, 0, ! 15, 0, 0, 0, 16, 0, 0, 0, 17, 0, ! 0, 0, 42, 42, -306, 42, 0, 513, 0, 0, ! 151, 0, 0, 0, 21, 0, 93, 0, 0, 83, ! 593, 593, 360, 117, 117, 117, 0, 0, 514, 83, ! 83, 83, 0, 0, 111, 0, 0, 151, 515, 0, ! 0, 0, 0, 0, 0, 0, -306, 0, 516, 0, ! 0, 517, 518, 0, 0, 151, 151, 384, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 795, 0, ! 1024, 100, 0, 0, 534, 64, 0, 0, 0, 0, ! 0, 151, 0, 0, 0, 0, 0, 593, 0, 0, ! 0, 0, 0, 0, 0, 0, 7, 8, 159, 160, ! 161, 0, 0, 64, 0, 12, 64, 0, 19, 0, ! 83, 64, 83, 0, 0, 0, 0, 0, 21, 0, ! 22, 0, 0, 83, 0, 0, 0, 1026, 17, 0, ! 589, 0, 24, 0, 19, 0, 0, 513, 0, 0, ! 0, 0, 25, 0, 21, 0, 22, 437, 0, 0, ! 26, 64, 64, 64, 64, 27, 0, 0, 607, 64, ! 0, 795, 795, 795, 0, 64, 0, 64, 608, 116, ! 116, 116, 0, 0, 0, 0, 26, 64, 516, 0, ! 0, 609, 518, 64, 0, 0, 64, 0, 0, 0, ! 0, 0, 0, 521, 521, 521, 0, 0, 0, 0, ! 0, 151, 0, 0, 0, 64, 64, 0, 64, 0, ! 0, 0, 42, 42, 111, 111, 111, 83, 191, 0, ! 42, 853, 853, 853, 0, 0, 659, 8, 152, 10, ! 153, 0, 0, 0, 0, 12, 479, 480, 481, 482, ! 483, 484, 485, 486, 487, 488, 489, 490, 42, 0, ! 15, 42, 0, 42, 16, 0, 0, 0, 17, 0, ! 0, 0, 83, 83, 19, 83, 795, 795, 795, 0, ! 0, 0, 0, 0, 21, 0, 22, 611, 0, 611, ! 611, 521, 0, 662, 0, 0, 0, 0, 24, 0, ! 0, 151, 0, 151, 0, 384, 384, 384, 25, 8, ! 92, 10, 11, 151, 0, 356, 26, 12, 0, 151, ! 0, 27, 151, 797, 0, 0, 0, 0, 0, 0, ! 191, 0, 15, 0, 0, 0, 16, 0, 0, 42, ! 17, 151, 0, 0, 377, 379, 383, 0, 0, 513, ! 0, 0, 0, 0, 64, 0, 21, 0, 93, 0, ! 0, 0, 0, 7, 100, 0, 0, 427, 0, 0, ! 514, 42, 42, 42, 7, 8, 0, 0, 185, 0, ! 515, 0, 0, 0, 0, 42, 42, 149, 42, 0, ! 516, 0, 0, 517, 518, 0, 0, 0, 357, 0, ! 0, 19, 0, 0, 0, 0, 64, 64, 116, 192, ! 0, 21, 19, 22, 855, 0, 42, 0, 0, 0, ! 0, 0, 21, 0, 22, 24, 0, 761, 192, 0, ! 64, 64, 0, 64, 0, 25, 140, 0, 149, 521, ! 521, 0, 521, 26, 0, 0, 141, 0, 27, 521, ! 0, 0, 0, 0, 26, 0, 0, 0, 0, 142, ! 0, 0, 116, 0, 0, 149, 0, 0, 0, 0, ! 0, 0, 0, 7, 8, 0, 10, 440, 234, 235, ! 611, 236, 12, 149, 149, 149, 0, 0, 0, 853, ! 0, 0, 0, 393, 0, 0, 797, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 149, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 611, 611, 848, 0, 0, 0, 0, 192, ! 848, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 256, 257, 258, 7, 8, 151, 151, 259, 151, ! 0, 0, 260, 0, 853, 853, 853, 0, 0, 0, ! 0, 0, 0, 0, 261, 0, 0, 0, 0, 0, ! 629, 0, 630, 0, 377, 379, 383, 0, 384, 797, ! 797, 797, 19, 0, 0, 0, 0, 534, 643, 0, ! 0, 0, 21, 0, 22, 0, 0, 521, 42, 0, ! 0, 0, 0, 0, 0, 0, 140, 437, 437, 437, ! 669, 0, 589, 0, 0, 0, 141, 192, 0, 149, ! 0, 0, 0, 0, 26, 0, 0, 0, 0, 142, ! 64, 64, 116, 116, 116, 0, 0, 0, 64, 855, ! 855, 855, 0, 0, 0, 0, 0, 8, 0, 10, ! 185, 0, 0, 0, 0, 12, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 64, 0, 0, 64, ! 15, 64, 0, 0, 16, 0, 0, 0, 17, 0, ! 0, 0, 0, 0, 797, 797, 797, 513, 521, 0, ! 521, 0, 0, 0, 21, 149, 93, 149, 149, 0, ! 0, 521, 0, 0, 0, 521, 521, 521, 514, 149, ! 0, 149, 0, 149, 149, 149, 0, 0, 515, 0, ! 0, 149, 0, 0, 519, 519, 519, 149, 516, 0, ! 149, 517, 518, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490, 64, 0, 149, ! 0, 0, 0, 0, 0, 62, 611, 611, 848, 848, ! 848, 0, 0, 0, 611, 848, 848, 848, 0, 0, ! 0, 0, 0, 0, 0, 102, 106, 0, 0, 64, ! 64, 64, 7, 8, 126, 0, 11, 0, 0, 0, ! 0, 0, 151, 64, 64, 0, 64, 158, 0, 0, ! 0, 377, 379, 383, 0, 0, 0, 0, 519, 383, ! 519, 519, 519, 7, 8, 0, 0, 427, 0, 0, ! 19, 0, 0, 0, 64, 629, 630, 0, 643, 0, ! 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, ! 761, 761, 0, 761, 380, 0, 0, 0, 0, 0, ! 0, 19, 307, 0, 381, 0, 309, 383, 0, 0, ! 192, 21, 26, 22, 0, 0, 0, 382, 0, 0, ! 0, 62, 0, 0, 332, 140, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 141, 0, 0, 149, 0, ! 0, 102, 106, 26, 0, 0, 0, 855, 142, 0, ! 0, 0, 0, 0, 0, 151, 0, 151, 0, 7, ! 8, 522, 526, 528, 0, 0, 0, 0, 0, 611, ! 611, 0, 611, 0, 0, 0, 0, 0, 0, 0, ! 7, 8, 152, 10, 153, 422, 0, 0, 0, 12, ! 149, 149, 846, 0, 0, 428, 0, 19, 846, 0, ! 0, 0, 0, 0, 15, 0, 0, 21, 16, 22, ! 519, 519, 17, 519, 149, 149, 0, 149, 19, 0, ! 794, 380, 855, 855, 855, 0, 0, 0, 21, 0, ! 22, 381, 0, 1105, 0, 0, 0, 0, 0, 26, ! 0, 0, 24, 0, 382, 612, 846, 522, 526, 528, ! 0, 519, 25, 0, 0, 0, 0, 0, 0, 0, ! 26, 0, 0, 0, 0, 27, 64, 0, 0, 0, ! 0, 0, 0, 384, 0, 0, 0, 1170, 0, 0, ! 0, 0, 0, 0, 0, 629, 630, 377, 379, 383, ! 0, 0, 0, 643, 377, 379, 383, 0, 0, 0, ! 0, 0, 0, 519, 519, 519, 0, 0, 0, 0, ! 0, 794, 0, 0, 0, 562, 0, 0, 563, 0, ! 0, 1030, 0, 565, 469, 470, 471, 1171, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490, 0, 384, 384, ! 384, 478, 479, 480, 481, 482, 483, 484, 485, 486, ! 487, 488, 489, 490, 613, 0, 0, 0, 0, 0, ! 0, 623, 0, 0, 0, 0, 0, 307, 519, 309, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 151, 0, 0, 428, 0, 774, 776, 473, ! 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490, 670, 673, 0, ! 422, 0, 0, 0, 149, 149, 149, 149, 846, 0, ! 1006, 0, 149, 846, 846, 846, 0, 0, 526, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 629, 630, ! 0, 643, 0, 0, 0, 0, 0, 0, 0, 0, ! 149, 0, 0, 0, 0, 0, 0, 0, 0, 519, ! 0, 519, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 519, 0, 0, 0, 794, 794, 794, 0, ! 774, 776, 0, 0, 469, 470, 471, 0, 472, 473, ! 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490, 476, 477, 478, ! 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, ! 489, 490, 192, 0, 0, 0, 0, 519, 519, 519, ! 519, 519, 1045, 0, 0, 519, 794, 794, 794, 0, ! 0, 0, 383, 0, 7, 8, 92, 10, 11, 0, ! 0, 356, 0, 12, 0, 526, 0, 0, 0, 0, ! 0, 0, 0, 149, 0, 149, 0, 0, 15, 0, ! 0, 0, 16, 0, 0, 0, 17, 149, 149, 0, ! 149, 0, 19, 0, 0, 513, 0, 0, 0, 0, ! 0, 0, 21, 0, 22, 0, 0, 0, 102, 106, ! 0, 0, 0, 0, 0, 0, 843, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 844, 377, 379, 383, ! 0, 0, 562, 563, 26, 565, 516, 0, 0, 845, ! 518, 0, 0, 0, 357, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 936, 0, 937, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 941, ! 0, 0, 0, 774, 776, 475, 476, 477, 478, 479, ! 480, 481, 482, 483, 484, 485, 486, 487, 488, 489, ! 490, 846, 0, 0, 0, 0, 0, 0, 0, 0, ! 519, 519, 0, 519, 0, 0, 0, 0, 0, 0, ! 686, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 936, 937, 774, 776, 0, 0, ! 0, 0, 941, 774, 776, 469, 470, 471, 0, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, ! 483, 484, 485, 486, 487, 488, 489, 490, 0, 0, ! 0, 0, 0, 0, 0, 0, 846, 846, 846, 0, ! 0, 0, 1111, 0, 971, 972, 92, 10, 233, 234, ! 235, 0, 236, 12, 973, 0, 974, 975, 976, 977, ! 978, 979, 980, 981, 982, 983, 13, 14, 15, 237, ! 238, 239, 16, 0, 240, 0, 17, 0, 241, 242, ! 149, 243, 19, 244, 245, 0, 0, 246, 247, 248, ! 249, 250, 21, 0, 984, 349, 0, 985, 0, 0, ! 0, 0, 0, 251, 0, 0, 252, 0, 0, 0, ! 0, 0, 307, 309, 253, 254, 255, 0, 0, 0, ! 428, 0, 256, 257, 258, 0, 0, 0, 0, 259, ! 0, 986, 0, 260, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 1112, 261, 0, 0, 1031, 0, ! 0, 1031, 0, 422, 0, 0, 0, 936, 937, 0, ! 941, 1261, 0, 971, 972, 92, 10, 233, 234, 235, ! 0, 236, 12, 973, 0, 974, 975, 976, 977, 978, ! 979, 980, 981, 982, 983, 13, 14, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 984, 349, 0, 985, 0, 0, 0, ! 0, 0, 251, 0, 0, 252, 0, 0, 0, 422, ! 0, 0, 0, 253, 254, 255, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 0, 0, 0, 259, 0, ! 986, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 1107, 1262, 261, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 562, 563, 0, 565, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 1283, 0, 971, 972, 92, 10, 233, ! 234, 235, 0, 236, 12, 973, 422, 974, 975, 976, ! 977, 978, 979, 980, 981, 982, 983, 13, 14, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 984, 349, 0, 985, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 0, 986, 0, 260, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 1284, 261, 1283, 0, 971, ! 972, 92, 10, 233, 234, 235, 0, 236, 12, 973, ! 0, 974, 975, 976, 977, 978, 979, 980, 981, 982, ! 983, 13, 14, 15, 237, 238, 239, 16, 0, 240, ! 0, 17, 0, 241, 242, 0, 243, 19, 244, 245, ! 0, 0, 246, 247, 248, 249, 250, 21, 0, 984, ! 349, 0, 985, 0, 0, 0, 0, 0, 251, 0, ! 0, 252, 0, 0, 0, 0, 0, 0, 0, 253, ! 254, 255, 0, 0, 0, 0, 0, 256, 257, 258, ! 0, 0, 0, 0, 259, 0, 986, 0, 260, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 1289, ! 261, 1283, 0, 971, 972, 92, 10, 233, 234, 235, ! 0, 236, 12, 973, 0, 974, 975, 976, 977, 978, ! 979, 980, 981, 982, 983, 13, 14, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 984, 349, 0, 985, 0, 0, 0, ! 0, 0, 251, 0, 0, 252, 0, 0, 0, 0, ! 0, 0, 0, 253, 254, 255, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 0, 0, 0, 259, 0, ! 986, 0, 260, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 1328, 261, 970, 0, 971, 972, 92, ! 10, 233, 234, 235, 0, 236, 12, 973, 0, 974, ! 975, 976, 977, 978, 979, 980, 981, 982, 983, 13, ! 14, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 984, 349, 0, ! 985, 0, 0, 0, 0, 0, 251, 0, 0, 252, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 255, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 0, 0, 259, 0, 986, 1255, 260, 971, 972, 92, ! 10, 233, 234, 235, 0, 236, 12, 973, 261, 974, ! 975, 976, 977, 978, 979, 980, 981, 982, 983, 13, ! 14, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 984, 349, 0, ! 985, 0, 0, 0, 0, 0, 251, 0, 0, 252, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 255, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 0, 0, 259, 0, 986, 1316, 260, 971, 972, 92, ! 10, 233, 234, 235, 0, 236, 12, 973, 261, 974, ! 975, 976, 977, 978, 979, 980, 981, 982, 983, 13, ! 14, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 984, 349, 0, ! 985, 0, 0, 0, 0, 0, 251, 0, 0, 252, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 255, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 0, 0, 259, 0, 986, 458, 260, 7, 8, 92, ! 10, 233, 234, 235, 356, 236, 12, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 513, 0, ! 246, 247, 248, 249, 250, 21, 0, 22, -239, 0, ! 0, 0, 0, 0, 0, 0, 251, 0, 0, 790, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 791, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 516, ! 0, 0, 792, 518, 0, 0, 260, 357, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 458, 261, 7, ! 8, 92, 10, 233, 234, 235, 356, 236, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 15, 237, 238, 239, 16, 0, 240, ! 0, 17, 0, 241, 242, 0, 243, 19, 244, 245, ! 513, 0, 246, 247, 248, 249, 250, 21, 0, 22, ! -239, 0, 0, 0, 0, 0, 0, 0, 251, 0, ! 0, 850, 0, 0, 0, 0, 0, 0, 0, 253, ! 254, 851, 0, 0, 0, 0, 0, 256, 257, 258, ! 0, 516, 0, 0, 852, 518, 0, 0, 260, 357, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 355, ! 261, 7, 8, 92, 10, 233, 234, 235, 356, 236, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 237, 238, 239, 16, ! 0, 240, 0, 17, 0, 241, 242, 0, 243, 19, ! 244, 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, ! 251, 0, 0, 252, 0, 0, 0, 0, 0, 0, ! 0, 253, 254, 255, 0, 0, 0, 0, 0, 256, ! 257, 258, 0, 0, 0, 0, 259, 0, 0, 0, ! 260, 357, 0, 0, 0, 0, 0, 0, 0, 0, ! -667, 638, 261, 7, 8, 92, 10, 233, 234, 235, ! 356, 236, 12, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 251, 0, 0, 252, 0, 0, 0, 0, ! 0, 0, 0, 253, 254, 255, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 0, 0, 0, 259, 0, ! 0, 0, 260, 357, 0, 0, 0, 0, 0, 0, ! 0, 0, -667, 591, 261, 715, 716, 0, 10, 440, ! 234, 235, 0, 236, 12, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 717, 592, 0, 0, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 718, 0, 591, 260, 715, 716, 0, 10, 440, ! 234, 235, 0, 236, 12, 830, 261, 0, 0, 0, ! 0, 1047, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 717, 592, 0, 0, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 0, 0, 591, 260, 715, 716, 0, 10, 440, ! 234, 235, 0, 236, 12, -386, 261, 0, 0, 0, ! 0, 1047, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 717, 592, 0, 0, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 0, 0, 1164, 260, 7, 8, 92, 10, 233, ! 234, 235, 0, 236, 12, 1077, 261, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 22, 1165, 0, 1166, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 0, 0, 591, 260, 715, 716, 0, 10, 440, ! 234, 235, 0, 236, 12, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 717, 592, 0, 0, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 718, 197, 0, 260, 8, 0, 10, 11, 0, ! 0, 0, 0, 12, 0, 0, 261, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, ! 0, 0, 16, 0, 0, 0, 17, 0, 198, 199, ! 0, 0, 0, 0, 0, 200, 0, 0, 0, 0, ! 0, 0, 21, 0, 93, 0, 201, 0, 202, 203, ! 204, 0, 205, 206, 207, 208, 209, 210, 211, 212, ! 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, ! 0, 0, 223, 224, 225, 0, 458, 226, 7, 8, ! 227, 10, 233, 234, 235, 0, 236, 12, 0, 0, ! 0, 0, 0, 0, 0, 228, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, -239, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 0, 591, 260, 7, 8, ! 0, 10, 440, 234, 235, 0, 236, 12, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, 592, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 0, 725, 260, 7, 8, ! 0, 10, 440, 234, 235, 0, 236, 12, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, ! 0, 0, 0, 0, 0, -657, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 0, 458, 260, 7, 8, ! 0, 10, 233, 234, 235, 0, 236, 12, 0, 261, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, -239, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 895, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 896, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 897, 0, 0, 458, 260, 7, 8, ! 0, 10, 233, 234, 235, 0, 236, 12, 0, 261, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, -239, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 1183, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 1184, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 1185, 0, 0, 1235, 260, 7, 8, ! 0, 10, 233, 234, 235, 0, 236, 12, 0, 261, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, ! 0, -139, 0, 0, 0, 0, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 0, 725, 260, 7, 8, ! 0, 10, 440, 234, 235, 0, 236, 12, 0, 261, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 0, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 0, 0, 260, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, -657, 804, 261, ! 7, 8, 0, 10, 440, 234, 235, 0, 236, 12, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 15, 237, 238, 239, 16, 0, ! 240, 0, 17, 0, 241, 242, 0, 243, 19, 244, ! 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 251, ! 0, 0, 252, 0, 0, 0, 0, 0, 0, 0, ! 253, 254, 255, 0, 0, 0, 0, 0, 256, 257, ! 258, 0, 0, 0, 0, 259, 0, 0, 806, 260, ! 7, 8, 0, 10, 440, 234, 235, 0, 236, 12, ! 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 15, 237, 238, 239, 16, 0, ! 240, 0, 17, 0, 241, 242, 0, 243, 19, 244, ! 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 251, ! 0, 0, 252, 0, 0, 0, 0, 0, 0, 0, ! 253, 254, 255, 0, 0, 0, 0, 0, 256, 257, ! 258, 0, 0, 0, 0, 259, 0, 7, 8, 260, ! 10, 440, 234, 235, 0, 236, 12, 0, 0, 0, ! 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 251, 0, 0, 252, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 255, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 0, 0, 259, 0, 0, 0, 260, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 261, 764, ! 971, 972, 92, 10, 233, 234, 235, 0, 236, 12, ! 973, 0, 974, 975, 976, 977, 978, 979, 980, 981, ! 982, 983, 13, 14, 15, 237, 238, 239, 16, 0, ! 240, 0, 17, 0, 241, 242, 0, 243, 19, 244, ! 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, ! 984, 349, 0, 985, 0, 0, 0, 0, 0, 251, ! 0, 0, 252, 0, 0, 0, 0, 0, 0, 0, ! 253, 254, 255, 0, 0, 0, 0, 0, 256, 257, ! 258, 0, 0, 0, 0, 259, 0, 986, 0, 260, ! 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 1116, 261, 971, 972, 92, 10, 233, 234, 235, 0, ! 236, 12, 973, 0, 974, 975, 976, 977, 978, 979, ! 980, 981, 982, 983, 13, 14, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 0, 0, 246, 247, 248, 249, 250, ! 21, 0, 984, 349, 0, 985, 0, 0, 0, 0, ! 0, 251, 0, 0, 252, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 255, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 0, 0, 0, 259, 0, 986, ! 0, 260, 971, 972, 92, 10, 233, 234, 235, 0, ! 236, 12, 973, 261, 974, 975, 976, 977, 978, 979, ! 980, 981, 982, 983, 13, 14, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 0, 0, 246, 247, 248, 249, 250, ! 21, 0, 984, 1276, 0, 985, 0, 0, 0, 0, ! 0, 251, 0, 0, 252, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 255, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 0, 0, 0, 259, 0, 986, ! 0, 260, 971, 972, 92, 10, 233, 234, 235, 0, ! 236, 12, 973, 261, 974, 975, 976, 977, 978, 979, ! 980, 981, 982, 983, 13, 14, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 0, 0, 246, 247, 248, 249, 250, ! 21, 0, 984, 0, 0, 985, 0, 0, 0, 0, ! 0, 251, 0, 0, 252, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 255, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 0, 0, 0, 259, 0, 986, ! 0, 260, 7, 8, 92, 10, 233, 234, 235, 356, ! 236, 12, 0, 261, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 513, 0, 246, 247, 248, 249, 250, ! 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, ! 0, 251, 0, 0, 790, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 791, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 516, 0, 0, 792, 518, 0, ! 0, 260, 357, 7, 8, 92, 10, 233, 234, 235, ! 356, 236, 12, 261, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 513, 0, 246, 247, 248, 249, ! 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 251, 0, 0, 850, 0, 0, 0, 0, ! 0, 0, 0, 253, 254, 851, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 516, 0, 0, 852, 518, ! 0, 0, 260, 357, 7, 8, 0, 10, 233, 234, ! 235, 0, 236, 12, 261, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 15, 237, ! 238, 239, 16, 0, 240, 0, 17, 0, 241, 242, ! 0, 243, 19, 244, 245, 513, 0, 246, 247, 248, ! 249, 250, 21, 0, 22, 0, 0, 0, 0, 0, ! 0, 0, 0, 251, 0, 0, 790, 0, 0, 0, ! 0, 0, 0, 0, 253, 254, 791, 0, 0, 0, ! 0, 0, 256, 257, 258, 0, 516, 0, 0, 792, ! 518, 7, 8, 0, 10, 233, 234, 235, 0, 236, ! 12, 0, 0, 0, 0, 261, 0, 0, 0, 0, ! 0, 0, 0, 0, 0, 15, 237, 238, 239, 16, ! 0, 240, 0, 17, 0, 241, 242, 0, 243, 19, ! 244, 245, 513, 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, ! 251, 0, 0, 850, 0, 0, 0, 0, 0, 0, ! 0, 253, 254, 851, 0, 0, 0, 0, 0, 256, ! 257, 258, 0, 516, 0, 0, 852, 518, 7, 8, ! 0, 10, 233, 234, 235, 0, 236, 12, 0, 0, ! 0, 0, 261, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 15, 237, 238, 239, 16, 0, 240, 0, ! 17, 0, 241, 242, 0, 243, 19, 244, 245, 0, ! 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, ! 0, 0, 0, 0, 0, 0, 0, 251, 0, 0, ! 252, 0, 0, 0, 0, 305, 0, 0, 253, 254, ! 255, 0, 0, 0, 0, 0, 256, 257, 258, 0, ! 0, 0, 0, 259, 0, 7, 8, 260, 10, 440, ! 234, 235, 0, 236, 12, 0, 0, 0, 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, ! 237, 238, 239, 16, 0, 240, 0, 17, 0, 241, ! 242, 0, 243, 19, 244, 245, 0, 0, 246, 247, ! 248, 249, 250, 21, 0, 22, 0, 0, 1093, 0, ! 0, 0, 0, 0, 251, 0, 0, 252, 0, 0, ! 0, 0, 0, 0, 0, 253, 254, 255, 0, 0, ! 0, 0, 0, 256, 257, 258, 0, 0, 0, 0, ! 259, 0, 7, 8, 260, 10, 233, 234, 235, 0, ! 236, 12, 0, 0, 0, 0, 261, 0, 0, 0, ! 0, 0, 0, 0, 0, 0, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, ! 0, 251, 0, 0, 252, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 255, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 0, 0, 0, 259, 0, 7, ! 8, 260, 10, 440, 234, 235, 0, 236, 12, 0, ! 0, 0, 0, 261, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 15, 237, 238, 239, 16, 0, 240, ! 0, 17, 0, 241, 242, 0, 243, 19, 244, 245, ! 0, 0, 246, 247, 248, 249, 250, 21, 0, 22, ! 466, 0, 0, 0, 0, 0, 0, 0, 251, 0, ! 0, 252, 0, 0, 0, 0, 0, 0, 0, 253, ! 254, 255, 0, 0, 0, 0, 0, 256, 257, 258, ! 0, 0, 7, 8, 467, 10, 440, 234, 235, 0, ! 236, 12, 0, 0, 0, 0, 0, 0, 0, 0, ! 261, 0, 0, 0, 0, 0, 15, 237, 238, 239, ! 16, 0, 240, 0, 17, 0, 241, 242, 0, 243, ! 19, 244, 245, 0, 0, 246, 247, 248, 249, 250, ! 21, 0, 22, 0, 0, 0, 0, 0, 0, 0, ! 0, 251, 0, 0, 252, 0, 0, 0, 0, 0, ! 0, 0, 253, 254, 255, 0, 0, 0, 0, 0, ! 256, 257, 258, 0, 0, 0, 0, 259, 503, 7, ! 8, 0, 10, 440, 234, 235, 0, 236, 12, 0, ! 0, 0, 0, 261, 0, 0, 0, 0, 0, 0, ! 0, 0, 0, 15, 237, 238, 239, 16, 0, 240, ! 0, 17, 0, 241, 242, 0, 243, 19, 244, 245, ! 0, 0, 246, 247, 248, 249, 250, 21, 0, 22, ! 0, 0, 0, 0, 0, 0, 0, 0, 251, 0, ! 0, 252, 0, 0, 0, 0, 0, 0, 0, 253, ! 254, 255, 0, 0, 0, 0, 0, 256, 257, 258, ! 0, 0, 0, 0, 259, 0, 7, 701, 260, 10, ! 440, 234, 235, 0, 236, 12, 0, 0, 0, 0, ! 261, 0, 0, 0, 0, 0, 0, 0, 0, 0, ! 15, 237, 238, 239, 16, 0, 240, 0, 17, 0, ! 241, 242, 0, 243, 19, 244, 245, 0, 0, 246, ! 247, 248, 249, 250, 21, 0, 22, 0, 0, 0, ! 0, 0, 0, 0, 0, 251, 0, 0, 252, 0, ! 0, 0, 0, 0, 0, 0, 253, 254, 255, 0, ! 0, 0, 0, 0, 256, 257, 258, 0, 0, 0, ! 0, 259, 0, 7, 8, 260, 10, 440, 234, 235, ! 0, 236, 12, 0, 0, 0, 0, 261, 0, 0, ! 0, 0, 0, 0, 0, 0, 0, 15, 237, 238, ! 239, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 251, 0, 0, 895, 0, 0, 0, 0, ! 0, 0, 0, 253, 254, 896, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 0, 0, 0, 897, 0, ! 7, 8, 260, 10, 440, 234, 235, 0, 236, 12, ! 0, 0, 0, 0, 261, 0, 0, 0, 0, 0, ! 0, 0, 0, 0, 15, 237, 238, 239, 16, 0, ! 240, 0, 17, 0, 241, 242, 0, 243, 19, 244, ! 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 251, ! 0, 0, 1183, 0, 0, 0, 0, 0, 0, 0, ! 253, 254, 1184, 0, 0, 0, 0, 0, 256, 257, ! 258, 0, 0, 0, 0, 1185, 0, 1248, 8, 260, ! 10, 440, 234, 235, 0, 236, 12, 0, 0, 0, ! 0, 261, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 251, 0, 0, 252, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 255, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 0, 0, 259, 0, 7, 8, 260, 10, 440, 234, ! 235, 0, 236, 12, 0, 0, 0, 0, 261, 0, ! 0, 0, 0, 0, 0, 0, 0, 0, 15, 237, ! 238, 239, 16, 0, 240, 0, 17, 0, 241, 242, ! 0, 243, 19, 244, 245, 0, 0, 246, 247, 248, ! 249, 250, 21, 0, 22, 0, 0, 0, 0, 0, ! 0, 0, 0, 251, 0, 0, 252, 0, 0, 0, ! 0, 0, 0, 0, 253, 254, 255, 0, 0, 0, ! 0, 0, 256, 257, 258, 0, 0, 7, 8, 259, ! 10, 440, 234, 235, 0, 236, 12, 0, 0, 0, ! 0, 0, 0, 0, 0, 261, 0, 0, 0, 0, ! 0, 15, 237, 238, 239, 16, 0, 240, 0, 17, ! 0, 241, 242, 0, 243, 19, 244, 245, 0, 0, ! 246, 247, 248, 249, 250, 21, 0, 22, 0, 0, ! 0, 0, 0, 0, 0, 0, 251, 0, 0, 895, ! 0, 0, 0, 0, 0, 0, 0, 253, 254, 896, ! 0, 0, 0, 0, 0, 256, 257, 258, 0, 0, ! 7, 8, 897, 10, 233, 234, 235, 0, 236, 12, ! 0, 0, 0, 0, 0, 0, 0, 0, 261, 0, ! 0, 0, 0, 0, 15, 237, 238, 239, 16, 0, ! 240, 0, 17, 0, 241, 242, 0, 243, 19, 244, ! 245, 0, 0, 246, 247, 248, 249, 250, 21, 0, ! 22, 0, 0, 0, 0, 0, 0, 0, 0, 251, ! 0, 0, 1183, 0, 0, 0, 0, 0, 0, 0, ! 253, 254, 1184, 0, 0, 0, 0, 0, 256, 257, ! 258, 0, 0, 7, 8, 1185, 10, 440, 234, 235, ! 0, 236, 12, 0, 0, 0, 0, 0, 0, 0, ! 0, 261, 0, 0, 0, 0, 0, 15, 237, 0, ! 0, 16, 0, 240, 0, 17, 0, 241, 242, 0, ! 243, 19, 244, 245, 0, 0, 246, 247, 248, 249, ! 250, 21, 0, 22, 0, 0, 0, 0, 0, 0, ! 0, 0, 251, 0, 0, 252, 0, 0, 0, 0, ! 0, 0, 0, 253, 254, 255, 0, 0, 0, 0, ! 0, 256, 257, 258, 0, 0, 7, 8, 441, 10, ! 440, 234, 235, 0, 236, 12, 0, 0, 0, 0, ! 0, 0, 0, 0, 261, 0, 0, 0, 0, 0, ! 15, 237, 0, 0, 16, 0, 240, 0, 17, 0, ! 241, 242, 0, 243, 19, 244, 245, 0, 0, 246, ! 247, 248, 249, 250, 21, 0, 22, 0, 0, 0, ! 0, 0, 0, 0, 0, 251, 0, 0, 252, 0, ! 0, 0, 0, 0, 0, 0, 253, 254, 255, 0, ! 0, 0, 0, 0, 256, 257, 258, 0, 0, 0, ! 0, 444, 0, 0, 0, 0, 0, 0, 0, 0, ! 0, 0, 546, 0, 469, 470, 471, 261, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490, 469, 470, 471, ! 1210, 472, 473, 474, 475, 476, 477, 478, 479, 480, ! 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, ! 469, 470, 471, 1259, 472, 473, 474, 475, 476, 477, ! 478, 479, 480, 481, 482, 483, 484, 485, 486, 487, ! 488, 489, 490, 469, 470, 471, 0, 472, 473, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, 484, ! 485, 486, 487, 488, 489, 490, 469, 470, 471, 0, ! 472, 473, 474, 475, 476, 477, 478, 479, 480, 0, ! 482, 483, 484, 485, 486, 487, 488, 489, 490, 471, ! 0, 472, 473, 474, 475, 476, 477, 478, 479, 480, ! 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 474, 475, 476, 477, 478, 479, 480, 481, 482, 483, ! 484, 485, 486, 487, 488, 489, 490 }; static const short yycheck[] = { 4, ! 4, 118, 279, 137, 419, 349, 300, 12, 131, 132, ! 4, 285, 341, 300, 70, 20, 20, 108, 109, 24, ! 25, 12, 27, 392, 285, 266, 52, 300, 33, 33, ! 137, 87, 20, 71, 132, 130, 391, 137, 753, 44, ! 182, 46, 98, 162, 163, 155, 135, 52, 1161, 820, ! 993, 1189, 1052, 4, 59, 9, 56, 34, 34, 9, ! 44, 52, 9, 0, 1222, 70, 71, 1169, 51, 3, ! 4, 56, 77, 77, 1232, 60, 370, 60, 4, 0, ! 10, 410, 87, 370, 3, 4, 69, 44, 365, 77, ! 95, 96, 45, 98, 20, 36, 101, 97, 44, 104, ! 105, 62, 53, 108, 109, 110, 189, 33, 36, 10, ! 60, 95, 58, 1215, 1252, 120, 120, 122, 123, 53, ! 7, 48, 41, 10, 75, 55, 103, 103, 4, 4, ! 60, 88, 993, 137, 53, 140, 141, 142, 122, 1000, ! 1253, 75, 88, 1, 1302, 102, 12, 1285, 102, 518, ! 1150, 77, 102, 88, 55, 102, 75, 44, 7, 60, ! 302, 166, 103, 93, 83, 126, 443, 4, 55, 44, ! 55, 58, 102, 60, 88, 103, 51, 53, 53, 184, ! 184, 155, 143, 70, 4, 56, 52, 7, 959, 194, ! 65, 4, 93, 300, 120, 189, 54, 158, 287, 75, ! 75, 88, 89, 44, 919, 54, 93, 76, 3, 44, ! 85, 60, 186, 88, 89, 102, 53, 4, 103, 88, ! 89, 1334, 1335, 346, 347, 348, 231, 232, 155, 285, ! 99, 51, 103, 53, 272, 162, 163, 990, 75, 992, ! 53, 107, 51, 92, 344, 65, 56, 88, 346, 347, ! 345, 3, 4, 88, 89, 75, 339, 391, 184, 186, ! 69, 535, 75, 370, 3, 4, 53, 272, 137, 89, ! 4, 276, 44, 278, 279, 280, 395, 396, 69, 56, ! 44, 286, 92, 44, 391, 4, 396, 44, 7, 380, ! 381, 391, 44, 102, 252, 300, 300, 255, 44, 51, ! 258, 53, 286, 230, 423, 10, 264, 56, 663, 314, ! 66, 1172, 317, 1256, 53, 273, 88, 322, 401, 53, ! 1263, 326, 326, 44, 88, 654, 103, 88, 89, 85, ! 60, 88, 51, 51, 53, 55, 88, 460, 326, 439, ! 1055, 102, 88, 89, 56, 339, 65, 103, 55, 56, ! 55, 69, 279, 58, 103, 60, 75, 362, 363, 364, ! 365, 366, 56, 3, 4, 370, 370, 88, 1229, 55, ! 331, 376, 102, 378, 1317, 380, 381, 382, 362, 88, ! 364, 365, 102, 388, 44, 251, 54, 391, 93, 394, ! 259, 103, 397, 387, 150, 1256, 496, 60, 498, 499, ! 326, 41, 1263, 3, 4, 410, 69, 401, 56, 103, ! 517, 416, 417, 53, 419, 419, 102, 524, 51, 424, ! 789, 6, 7, 55, 60, 56, 1287, 12, 88, 89, ! 530, 300, 416, 788, 56, 75, 3, 4, 365, 6, ! 196, 41, 102, 83, 405, 450, 451, 452, 453, 54, ! 35, 51, 56, 53, 3, 4, 1317, 103, 27, 44, ! 60, 422, 500, 44, 55, 65, 102, 54, 395, 396, ! 102, 51, 103, 596, 41, 75, 55, 3, 4, 44, ! 60, 103, 56, 83, 102, 585, 53, 570, 88, 69, ! 448, 70, 41, 419, 823, 500, 423, 502, 596, 103, ! 54, 370, 609, 88, 53, 44, 60, 88, 615, 514, ! 515, 102, 517, 517, 808, 41, 83, 44, 92, 524, ! 524, 808, 391, 88, 798, 644, 75, 53, 284, 663, ! 556, 58, 55, 44, 83, 808, 102, 798, 867, 108, ! 109, 110, 3, 4, 5, 6, 7, 70, 103, 88, ! 555, 556, 308, 794, 102, 424, 663, 83, 3, 4, ! 929, 88, 89, 54, 647, 556, 55, 56, 685, 60, ! 44, 555, 441, 142, 35, 444, 570, 88, 89, 9, ! 449, 450, 451, 452, 453, 3, 4, 5, 6, 7, ! 51, 1, 53, 54, 463, 23, 102, 680, 467, 102, ! 466, 92, 607, 608, 609, 609, 51, 44, 53, 54, ! 615, 615, 92, 23, 88, 25, 26, 3, 4, 3, ! 1035, 58, 32, 55, 56, 51, 631, 632, 555, 634, ! 499, 60, 60, 977, 60, 53, 105, 98, 99, 100, ! 69, 1, 97, 69, 54, 55, 56, 924, 58, 654, ! 60, 88, 388, 647, 788, 41, 756, 4, 663, 663, ! 55, 397, 37, 23, 54, 25, 26, 53, 60, 769, ! 60, 771, 32, 4, 51, 70, 51, 682, 6, 7, ! 436, 788, 92, 60, 12, 792, 680, 692, 693, 694, ! 556, 88, 69, 89, 54, 55, 56, 83, 58, 60, ! 60, 808, 92, 664, 51, 105, 53, 35, 669, 670, ! 925, 926, 673, 928, 88, 992, 55, 644, 65, 58, ! 51, 89, 53, 55, 56, 825, 592, 827, 75, 829, ! 23, 70, 92, 54, 65, 56, 25, 26, 845, 60, ! 1084, 1085, 798, 27, 75, 852, 88, 752, 692, 693, ! 694, 88, 843, 844, 1098, 682, 512, 69, 89, 850, ! 851, 54, 88, 56, 69, 58, 69, 60, 773, 69, ! 775, 527, 25, 26, 1118, 1119, 54, 782, 56, 25, ! 26, 786, 60, 788, 788, 790, 791, 792, 792, 9, ! 78, 79, 103, 798, 663, 878, 879, 55, 881, 55, ! 56, 54, 3, 808, 808, 810, 764, 60, 54, 1334, ! 1335, 380, 381, 382, 60, 3, 4, 55, 56, 3, ! 4, 1165, 102, 7, 108, 109, 110, 102, 54, 102, ! 56, 103, 790, 791, 60, 102, 841, 842, 843, 844, ! 845, 845, 55, 56, 849, 850, 851, 852, 852, 37, ! 38, 55, 56, 41, 236, 237, 54, 41, 142, 102, ! 44, 7, 867, 51, 58, 53, 102, 51, 102, 53, ! 1296, 1297, 877, 102, 4, 880, 58, 882, 882, 884, ! 105, 65, 12, 752, 878, 879, 102, 881, 44, 88, ! 20, 75, 850, 851, 24, 25, 105, 27, 32, 83, ! 105, 85, 105, 33, 88, 89, 102, 581, 4, 5, ! 102, 102, 873, 782, 44, 51, 46, 6, 105, 788, ! 925, 926, 52, 928, 88, 81, 82, 44, 55, 59, ! 86, 87, 88, 89, 58, 31, 58, 895, 896, 808, ! 36, 71, 4, 5, 58, 102, 56, 77, 56, 1226, ! 102, 56, 56, 958, 958, 51, 882, 53, 56, 58, ! 55, 635, 102, 1086, 102, 95, 96, 102, 834, 31, ! 88, 101, 646, 931, 36, 105, 105, 55, 108, 109, ! 110, 60, 88, 89, 55, 990, 991, 992, 55, 51, ! 120, 53, 122, 123, 25, 26, 60, 866, 1, 1004, ! 1005, 32, 1007, 88, 58, 102, 990, 70, 992, 102, ! 140, 141, 142, 70, 102, 884, 102, 70, 102, 102, ! 23, 102, 25, 26, 55, 56, 70, 58, 897, 32, ! 1035, 1035, 958, 102, 60, 60, 166, 5, 6, 7, ! 609, 55, 102, 1337, 12, 911, 615, 60, 1131, 1132, ! 1337, 54, 55, 56, 184, 58, 102, 60, 105, 102, ! 1177, 103, 102, 83, 194, 992, 1189, 35, 89, 1030, ! 1031, 105, 343, 44, 5, 6, 7, 105, 102, 102, ! 102, 12, 34, 4, 103, 102, 7, 105, 58, 92, ! 102, 847, 1183, 1184, 663, 102, 380, 381, 382, 1182, ! 966, 231, 232, 1108, 35, 1205, 102, 102, 58, 1035, ! 88, 88, 4, 5, 6, 7, 88, 983, 10, 88, ! 12, 88, 103, 44, 75, 76, 77, 78, 79, 1252, ! 51, 105, 53, 6, 60, 27, 102, 1131, 1132, 31, ! 102, 815, 272, 35, 65, 102, 1107, 102, 278, 279, ! 280, 105, 88, 259, 75, 285, 286, 3, 4, 51, ! 102, 53, 1285, 102, 85, 103, 1127, 88, 89, 102, ! 300, 1271, 102, 1039, 102, 60, 56, 56, 1183, 1184, ! 1185, 7, 54, 14, 314, 1179, 56, 317, 1182, 58, ! 102, 865, 322, 949, 102, 41, 326, 60, 44, 60, ! 874, 93, 27, 1286, 105, 51, 44, 53, 56, 883, ! 88, 341, 1078, 56, 60, 1338, 58, 88, 58, 65, ! 88, 102, 1227, 105, 15, 1183, 1184, 102, 102, 75, ! 1337, 58, 362, 363, 364, 365, 366, 83, 102, 56, ! 370, 103, 88, 1227, 56, 56, 376, 102, 378, 102, ! 380, 381, 382, 56, 56, 102, 9, 58, 388, 56, ! 56, 102, 3, 4, 394, 88, 7, 397, 56, 375, ! 55, 91, 102, 102, 843, 844, 845, 56, 102, 9, ! 410, 850, 851, 852, 109, 110, 416, 417, 102, 419, ! 58, 56, 1286, 102, 424, 88, 102, 1258, 102, 1226, ! 41, 3, 4, 44, 9, 7, 56, 0, 0, 119, ! 51, 2, 53, 328, 808, 120, 1185, 142, 823, 99, ! 450, 451, 452, 453, 65, 609, 120, 1150, 1160, 1191, ! 130, 615, 1337, 1337, 75, 441, 512, 1203, 444, 41, ! 446, 447, 83, 449, 85, 1019, 1020, 88, 89, 51, ! 463, 53, 1087, 4, 991, 626, 7, 1203, 1032, 1033, ! 592, 467, 803, 65, 688, 471, 867, 33, 33, 654, ! 500, 813, 502, 75, 4, 958, 417, 543, 882, 663, ! 880, 83, 801, 12, 514, 515, 88, 517, 500, 837, ! 20, 497, 1276, 44, 524, 1310, 4, 503, 6, 7, ! 51, 1312, 53, 33, 12, 535, 73, 74, 75, 76, ! 77, 78, 79, 884, 65, -1, 46, 10, -1, 27, ! -1, 370, -1, 31, 75, 555, 556, 35, -1, 59, ! -1, -1, 25, 26, 85, -1, -1, 88, 89, 32, ! -1, 71, -1, 51, -1, 53, 76, 77, -1, -1, ! -1, 44, -1, -1, -1, -1, 1130, -1, 88, 89, ! -1, -1, 55, 56, -1, 58, 96, 60, 1337, 99, ! -1, -1, -1, -1, -1, -1, -1, 607, 608, 609, ! 88, -1, -1, -1, 755, 615, -1, -1, -1, 4, ! 120, 6, 7, 123, -1, 88, 89, 12, -1, 92, ! 93, 631, 632, -1, 634, -1, -1, 137, -1, 102, ! -1, -1, 27, -1, -1, -1, 31, -1, -1, -1, ! 35, -1, 1196, 1197, 654, 1199, 1200, -1, -1, -1, ! -1, -1, -1, 663, -1, -1, 51, -1, 53, 1108, ! -1, 812, -1, -1, 1, -1, 3, 4, 5, 6, ! 7, -1, 682, -1, 184, 12, 381, 382, -1, 843, ! 844, 845, 692, 693, 694, -1, 850, 851, 852, -1, ! 27, -1, -1, -1, 31, -1, -1, -1, 35, 36, ! -1, -1, -1, -1, 41, -1, 857, -1, -1, -1, ! -1, -1, -1, -1, 51, -1, 53, -1, -1, 56, ! -1, 231, -1, 60, 4, -1, 6, 7, 65, -1, ! 137, -1, 12, -1, 1183, 1184, 1185, -1, 75, -1, ! -1, -1, 752, -1, -1, -1, 83, -1, -1, 259, ! -1, 88, 1306, -1, -1, 35, -1, -1, -1, 910, ! 911, -1, 272, 773, 44, 775, 103, -1, -1, -1, ! 280, 51, 782, 53, 760, -1, 786, -1, 788, -1, ! 790, 791, 792, -1, 71, 65, -1, -1, 798, 76, ! 300, -1, -1, -1, -1, 75, -1, -1, 808, -1, ! 810, 88, 89, -1, -1, 85, 792, -1, 88, 89, ! -1, -1, 99, 823, -1, 966, 326, -1, -1, 524, ! -1, -1, -1, 3, 4, -1, -1, -1, -1, -1, ! -1, 841, 842, 843, 844, 845, -1, -1, -1, 849, ! 850, 851, 852, -1, -1, -1, -1, -1, -1, -1, ! 137, 4, -1, 363, 7, -1, 366, 867, -1, -1, ! 370, 41, -1, -1, -1, -1, 852, 877, -1, -1, ! 880, 51, 882, 53, 884, -1, 56, -1, -1, -1, ! 866, 391, -1, -1, -1, 65, -1, -1, -1, 1040, ! -1, 44, -1, -1, 1045, 75, -1, -1, 51, -1, ! 53, -1, -1, 83, 609, -1, -1, 417, 88, 419, ! 615, 897, 65, -1, 424, 925, 926, -1, 928, -1, ! -1, -1, 75, -1, -1, -1, -1, -1, -1, -1, ! -1, 441, 85, -1, 444, 88, 89, 344, -1, 449, ! 450, 451, 452, 453, 1108, -1, -1, -1, 958, -1, ! -1, -1, 4, 463, 6, 7, -1, 467, 663, -1, ! 12, -1, -1, 24, 25, -1, -1, -1, -1, 1120, ! 1121, -1, 259, -1, -1, 27, -1, -1, -1, 31, ! 990, 991, 992, 35, 391, 272, -1, -1, -1, 499, ! 500, -1, 697, -1, 1004, 1005, 982, 1007, 1149, 51, ! -1, 53, 54, -1, -1, -1, -1, 517, -1, -1, ! 71, -1, -1, 300, 524, 76, -1, -1, -1, 1183, ! 1184, 1185, -1, 3, 4, 1035, -1, 88, 89, -1, ! -1, -1, 439, -1, -1, -1, 88, -1, 99, -1, ! 3, 4, -1, 1194, 7, -1, -1, 108, 109, -1, ! 1201, 1202, -1, -1, -1, 1041, 1042, 1043, 1044, 1210, ! -1, 41, -1, -1, -1, -1, -1, 1053, -1, -1, ! -1, 51, -1, 53, -1, -1, 137, -1, 41, 140, ! 141, 44, -1, 370, -1, 65, 791, 792, 51, 496, ! 53, 498, 499, -1, -1, 75, -1, -1, 1108, 609, ! -1, 1087, 65, 83, 391, 615, -1, -1, 88, 1095, ! -1, -1, 75, -1, -1, -1, -1, 524, 1269, 1270, ! 83, -1, 85, 530, -1, 88, 89, 71, 72, 73, ! 74, 75, 76, 77, 78, 79, -1, 424, -1, 844, ! 845, -1, -1, -1, -1, -1, 851, 852, -1, -1, ! -1, -1, -1, 663, 441, -1, -1, 444, -1, -1, ! -1, -1, 449, 450, 451, 452, 453, -1, -1, -1, ! -1, -1, -1, 1183, 1184, 1185, 463, -1, 585, -1, ! 467, -1, -1, 1169, 1, 1336, 3, 4, 5, 6, ! 7, 896, 897, -1, -1, 12, -1, -1, 259, 1185, ! -1, -1, -1, -1, 1190, 1191, -1, -1, 615, -1, ! 27, 272, 499, 500, 31, -1, -1, 1227, 35, 36, ! -1, -1, -1, -1, 41, -1, -1, -1, -1, 1215, ! 517, -1, -1, -1, 51, -1, 53, 524, -1, 300, ! -1, -1, 752, 60, -1, -1, 756, -1, 65, -1, ! -1, 1, -1, 3, 4, 5, 6, 7, 75, -1, ! -1, -1, 12, -1, -1, 4, 83, 6, 7, -1, ! -1, 88, 782, 12, -1, 25, 26, 27, 788, -1, ! -1, 31, 792, -1, -1, 35, 103, -1, 27, 39, ! 697, 41, 31, -1, 1280, 45, 35, -1, 808, -1, ! 810, 51, -1, 53, -1, -1, 56, -1, -1, 370, ! 1296, 1297, 51, -1, 53, 65, -1, -1, -1, 380, ! 381, -1, 609, 1309, -1, 75, 836, 1337, 615, -1, ! 391, -1, -1, 83, -1, 845, -1, -1, 88, -1, ! -1, -1, 852, -1, 94, 95, -1, 3, 4, 756, ! -1, 7, -1, -1, -1, -1, 866, -1, -1, -1, ! -1, -1, 769, 424, 771, -1, -1, -1, -1, -1, ! -1, -1, 882, -1, 884, -1, 663, -1, -1, -1, ! 441, -1, -1, 444, -1, 41, -1, 897, 449, 450, ! 451, 452, 453, -1, -1, 51, -1, 53, -1, -1, ! -1, -1, 463, 1108, -1, -1, 467, -1, -1, 65, ! 1, -1, 3, 4, 5, 6, 7, -1, 825, 75, ! 827, 12, 829, -1, -1, -1, -1, 83, -1, 69, ! -1, -1, 88, -1, -1, -1, 27, -1, 499, 500, ! 31, -1, -1, -1, 35, 36, -1, 76, 958, -1, ! 41, -1, -1, 514, 515, -1, 517, -1, -1, -1, ! 51, -1, 53, 524, -1, 752, -1, -1, -1, 60, ! 99, -1, -1, -1, 65, -1, -1, 117, -1, 1184, ! 1185, 991, -1, 993, 75, -1, -1, -1, -1, -1, ! 1000, -1, 83, -1, -1, 782, 136, 88, -1, -1, ! -1, 788, -1, -1, -1, 792, -1, -1, 137, -1, ! -1, 151, 103, -1, -1, -1, -1, -1, -1, -1, ! -1, 808, -1, -1, -1, 1035, 1, -1, 3, 4, ! 5, 6, 7, -1, 3, 4, -1, 12, 7, -1, ! -1, -1, -1, -1, -1, -1, 607, 608, 609, -1, ! -1, -1, 27, -1, 615, -1, 31, -1, 845, -1, ! 35, 36, -1, -1, -1, 852, 41, -1, -1, -1, ! -1, -1, 41, -1, -1, 44, 51, 1087, 53, 866, ! -1, 56, 51, -1, 53, 60, -1, -1, 3, 4, ! 65, -1, -1, -1, -1, -1, 65, 884, -1, -1, ! 75, -1, 663, -1, -1, -1, 75, -1, 83, -1, ! 897, -1, -1, 88, 83, -1, 85, -1, -1, 88, ! 89, -1, 4, 5, 6, 7, 41, -1, 103, 44, ! 12, 260, -1, -1, -1, -1, 51, -1, 53, -1, ! -1, -1, -1, -1, -1, 27, -1, -1, -1, 31, ! 65, 1161, 1, 35, 3, 4, 5, 6, 7, 1169, ! 75, -1, 1172, 12, -1, -1, -1, -1, 83, 51, ! 85, 53, -1, 88, 89, 1185, -1, -1, 27, -1, ! 1190, 1191, 31, -1, -1, -1, 35, 3, 4, -1, ! -1, 752, 41, -1, -1, -1, 45, -1, -1, -1, ! -1, 1108, 51, -1, 53, 1215, -1, 56, -1, -1, ! -1, -1, 1222, -1, 343, 344, 65, -1, -1, 1229, ! -1, 782, 1232, -1, -1, 41, 75, 788, -1, 790, ! 791, 792, -1, -1, 83, 51, -1, 53, -1, 88, ! 56, -1, -1, 1253, 384, 94, 1256, 808, -1, 65, ! 390, -1, -1, 1263, -1, -1, -1, -1, -1, 75, ! -1, -1, 391, -1, -1, -1, -1, 83, -1, -1, ! -1, -1, 88, 4, 5, 6, 7, 1287, -1, -1, ! -1, 12, 843, 844, 845, 414, -1, -1, -1, 850, ! 851, 852, 1302, -1, 434, 435, 27, 437, 1205, -1, ! 31, -1, -1, -1, 35, 866, -1, 1317, -1, -1, ! 439, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 51, -1, 53, 884, 1334, 1335, -1, 1337, 3, 4, ! -1, -1, 7, -1, 463, -1, 897, 466, 69, -1, ! 469, 470, -1, 472, 473, 474, 475, 476, 477, 478, ! 479, 480, 481, 482, 483, 484, 485, 486, 487, 488, ! 489, 490, -1, -1, 1271, -1, 41, 496, -1, 498, ! 499, -1, -1, -1, -1, -1, 51, -1, 53, -1, ! 520, 521, 1169, -1, 4, 525, 6, -1, -1, -1, ! 65, -1, 12, -1, -1, 524, -1, -1, 1185, -1, ! 75, 530, -1, 1190, 1191, -1, -1, 27, 83, -1, ! -1, 31, -1, 88, -1, 35, 545, 546, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 1215, -1, ! -1, 51, -1, 53, -1, -1, -1, -1, -1, -1, ! 3, 4, 5, 6, 7, -1, -1, 10, -1, 12, ! -1, 3, 4, 5, 6, 7, 585, -1, -1, -1, ! 12, 601, 602, 592, 27, -1, -1, -1, 31, 12, ! -1, 611, 35, -1, -1, 27, -1, 617, 41, 31, ! -1, 24, 25, 35, 27, -1, 615, -1, 51, 41, ! 53, -1, -1, -1, -1, 4, -1, 626, -1, 51, ! -1, 53, 65, -1, 56, -1, -1, -1, -1, 52, ! -1, -1, 75, 65, -1, 24, 25, -1, 27, -1, ! 83, 661, -1, 75, 33, 88, -1, -1, -1, -1, ! 93, 83, -1, 662, -1, 44, 88, 46, -1, -1, 3, 4, 5, 6, 7, -1, -1, -1, -1, 12, ! 1337, -1, -1, -1, -1, -1, -1, 66, 101, -1, ! 103, 104, 105, -1, -1, 108, 109, 110, 697, -1, ! -1, -1, 35, -1, -1, -1, -1, -1, 41, -1, ! -1, 44, -1, -1, -1, -1, 95, -1, 51, 718, ! 53, -1, 101, -1, 103, -1, 105, -1, -1, 108, ! 109, 110, 65, -1, -1, -1, -1, -1, 1169, -1, ! -1, 120, 75, 122, 123, -1, -1, -1, 758, 759, ! 83, 761, 1183, 1184, 1185, 88, 755, 756, -1, 1190, ! 1191, 140, 141, 142, -1, -1, -1, -1, -1, -1, ! 769, 150, 771, -1, -1, -1, -1, 787, -1, -1, ! -1, 194, -1, -1, 1215, -1, -1, 166, -1, -1, ! -1, -1, -1, -1, -1, 3, 4, 5, 6, 7, ! -1, 800, -1, -1, 12, 184, -1, -1, -1, -1, ! -1, -1, -1, 812, -1, 194, -1, -1, -1, 232, ! -1, -1, -1, -1, -1, -1, 825, 35, 827, -1, ! 829, -1, -1, 41, -1, -1, 44, -1, 848, 4, ! -1, 6, 7, 51, -1, 53, -1, 12, -1, -1, ! 860, 861, 862, -1, -1, -1, -1, 65, 857, -1, ! -1, -1, -1, 276, -1, 278, 279, 75, -1, -1, ! 35, -1, 871, 872, -1, 83, -1, 85, -1, 44, ! 88, 89, -1, -1, -1, -1, 51, 1, 53, 3, ! 4, 5, 6, 7, -1, 308, -1, 276, 12, -1, ! 65, 314, -1, -1, 317, 284, 1337, 286, -1, 322, ! 75, 910, 911, 27, -1, 914, -1, 31, -1, -1, ! 85, 35, -1, 88, 89, -1, -1, 41, -1, 939, ! -1, -1, -1, -1, -1, 314, -1, 51, 317, 53, ! -1, -1, -1, 322, 3, 4, 5, 6, 7, -1, ! -1, 65, -1, 12, -1, -1, -1, -1, -1, -1, ! -1, 75, -1, -1, -1, -1, -1, 966, 27, 83, ! -1, -1, 31, -1, 88, -1, 35, -1, -1, 978, ! -1, -1, 41, 362, 363, 364, 365, -1, -1, -1, ! -1, 370, 51, -1, 53, -1, -1, 376, -1, 378, ! -1, 380, 381, 382, -1, -1, 65, 3, 4, 388, ! -1, 7, -1, 1023, -1, 394, 75, -1, 397, -1, ! -1, -1, -1, 436, 83, -1, -1, 1026, -1, 88, ! -1, -1, -1, -1, -1, -1, -1, 416, 417, -1, ! 419, 1040, -1, 4, -1, 41, 1045, -1, 1047, -1, ! -1, 4, 5, 6, 7, 51, -1, 53, 1068, 12, ! -1, -1, -1, 24, 25, -1, 27, -1, -1, 65, ! -1, -1, 33, -1, 27, -1, -1, -1, 31, 75, ! -1, -1, 35, 44, -1, 46, -1, 83, -1, 502, ! -1, -1, 88, -1, -1, -1, -1, -1, 51, 512, ! 53, 514, 515, 3, 4, 5, 6, 7, -1, 1108, ! 10, -1, 12, -1, -1, -1, -1, -1, -1, -1, ! -1, 1120, 1121, -1, -1, -1, -1, 27, -1, 1128, ! 1129, 31, -1, 512, 95, 35, -1, -1, -1, -1, ! 101, 41, -1, 556, 105, 524, -1, 108, 109, 110, ! 1149, 51, -1, 53, -1, -1, -1, -1, -1, 120, ! -1, 122, 123, -1, -1, 65, 4, 5, 6, 7, ! -1, 1170, 10, -1, 12, 75, 555, -1, -1, 140, ! 141, 142, -1, 83, -1, -1, -1, -1, 88, 27, ! -1, -1, 27, 31, -1, 1194, -1, 35, -1, -1, ! -1, -1, 1201, 1202, -1, 166, 1205, -1, -1, 44, ! -1, 1210, -1, 51, -1, 53, 3, 4, 5, 6, ! 7, -1, -1, 184, -1, 12, -1, -1, 607, 608, ! 609, -1, -1, 194, -1, -1, 615, -1, -1, -1, ! 27, -1, -1, -1, 31, -1, -1, -1, 35, -1, ! -1, -1, 631, 632, 41, 634, -1, 44, -1, -1, ! 95, -1, -1, -1, 51, -1, 53, -1, -1, 682, ! 1269, 1270, 1271, 108, 109, 110, -1, -1, 65, 692, ! 693, 694, -1, -1, 663, -1, -1, 122, 75, -1, ! -1, -1, -1, -1, -1, -1, 83, -1, 85, -1, ! -1, 88, 89, -1, -1, 140, 141, 142, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 697, -1, ! 3, 4, -1, -1, 285, 286, -1, -1, -1, -1, ! -1, 166, -1, -1, -1, -1, -1, 1336, -1, -1, ! -1, -1, -1, -1, -1, -1, 3, 4, 5, 6, ! 7, -1, -1, 314, -1, 12, 317, -1, 41, -1, ! 773, 322, 775, -1, -1, -1, -1, -1, 51, -1, ! 53, -1, -1, 786, -1, -1, -1, 60, 35, -1, ! 341, -1, 65, -1, 41, -1, -1, 44, -1, -1, ! -1, -1, 75, -1, 51, -1, 53, 232, -1, -1, ! 83, 362, 363, 364, 365, 88, -1, -1, 65, 370, ! -1, 790, 791, 792, -1, 376, -1, 378, 75, 380, ! 381, 382, -1, -1, -1, -1, 83, 388, 85, -1, ! -1, 88, 89, 394, -1, -1, 397, -1, -1, -1, ! -1, -1, -1, 278, 279, 280, -1, -1, -1, -1, ! -1, 286, -1, -1, -1, 416, 417, -1, 419, -1, ! -1, -1, 841, 842, 843, 844, 845, 880, 847, -1, ! 849, 850, 851, 852, -1, -1, 3, 4, 5, 6, ! 7, -1, -1, -1, -1, 12, 68, 69, 70, 71, ! 72, 73, 74, 75, 76, 77, 78, 79, 877, -1, ! 27, 880, -1, 882, 31, -1, -1, -1, 35, -1, ! -1, -1, 925, 926, 41, 928, 895, 896, 897, -1, ! -1, -1, -1, -1, 51, -1, 53, 362, -1, 364, ! 365, 366, -1, 60, -1, -1, -1, -1, 65, -1, ! -1, 376, -1, 378, -1, 380, 381, 382, 75, 4, ! 5, 6, 7, 388, -1, 10, 83, 12, -1, 394, ! -1, 88, 397, 524, -1, -1, -1, -1, -1, -1, ! 949, -1, 27, -1, -1, -1, 31, -1, -1, 958, ! 35, 416, -1, -1, 140, 141, 142, -1, -1, 44, ! -1, -1, -1, -1, 555, -1, 51, -1, 53, -1, ! -1, -1, -1, 3, 4, -1, -1, 7, -1, -1, ! 65, 990, 991, 992, 3, 4, -1, -1, 7, -1, ! 75, -1, -1, -1, -1, 1004, 1005, 44, 1007, -1, ! 85, -1, -1, 88, 89, -1, -1, -1, 93, -1, ! -1, 41, -1, -1, -1, -1, 607, 608, 609, 66, ! -1, 51, 41, 53, 615, -1, 1035, -1, -1, -1, ! -1, -1, 51, -1, 53, 65, -1, 502, 85, -1, ! 631, 632, -1, 634, -1, 75, 65, -1, 95, 514, ! 515, -1, 517, 83, -1, -1, 75, -1, 88, 524, ! -1, -1, -1, -1, 83, -1, -1, -1, -1, 88, ! -1, -1, 663, -1, -1, 122, -1, -1, -1, -1, ! -1, -1, -1, 3, 4, -1, 6, 7, 8, 9, ! 555, 11, 12, 140, 141, 142, -1, -1, -1, 1108, ! -1, -1, -1, 150, -1, -1, 697, 27, 28, 29, ! 30, 31, -1, 33, -1, 35, -1, 37, 38, 166, ! 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, ! 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, ! -1, -1, 607, 608, 609, -1, -1, -1, -1, 196, ! 615, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, 81, 82, 83, 3, 4, 631, 632, 88, 634, ! -1, -1, 92, -1, 1183, 1184, 1185, -1, -1, -1, ! -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, ! 376, -1, 378, -1, 380, 381, 382, -1, 663, 790, ! 791, 792, 41, -1, -1, -1, -1, 798, 394, -1, ! -1, -1, 51, -1, 53, -1, -1, 682, 1227, -1, ! -1, -1, -1, -1, -1, -1, 65, 692, 693, 694, ! 416, -1, 823, -1, -1, -1, 75, 284, -1, 286, ! -1, -1, -1, -1, 83, -1, -1, -1, -1, 88, ! 841, 842, 843, 844, 845, -1, -1, -1, 849, 850, ! 851, 852, -1, -1, -1, -1, -1, 4, -1, 6, ! 7, -1, -1, -1, -1, 12, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, 877, -1, -1, 880, ! 27, 882, -1, -1, 31, -1, -1, -1, 35, -1, ! -1, -1, -1, -1, 895, 896, 897, 44, 773, -1, ! 775, -1, -1, -1, 51, 362, 53, 364, 365, -1, ! -1, 786, -1, -1, -1, 790, 791, 792, 65, 376, ! -1, 378, -1, 380, 381, 382, -1, -1, 75, -1, ! -1, 388, -1, -1, 278, 279, 280, 394, 85, -1, ! 397, 88, 89, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79, 958, -1, 416, ! -1, -1, -1, -1, -1, 4, 841, 842, 843, 844, ! 845, -1, -1, -1, 849, 850, 851, 852, -1, -1, ! -1, -1, -1, -1, -1, 24, 25, -1, -1, 990, ! 991, 992, 3, 4, 33, -1, 7, -1, -1, -1, ! -1, -1, 877, 1004, 1005, -1, 1007, 46, -1, -1, ! -1, 607, 608, 609, -1, -1, -1, -1, 362, 615, ! 364, 365, 366, 3, 4, -1, -1, 7, -1, -1, ! 41, -1, -1, -1, 1035, 631, 632, -1, 634, -1, ! 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, ! 925, 926, -1, 928, 65, -1, -1, -1, -1, -1, ! -1, 41, 101, -1, 75, -1, 105, 663, -1, -1, ! 527, 51, 83, 53, -1, -1, -1, 88, -1, -1, ! -1, 120, -1, -1, 123, 65, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 75, -1, -1, 555, -1, ! -1, 140, 141, 83, -1, -1, -1, 1108, 88, -1, ! -1, -1, -1, -1, -1, 990, -1, 992, -1, 3, ! 4, 278, 279, 280, -1, -1, -1, -1, -1, 1004, ! 1005, -1, 1007, -1, -1, -1, -1, -1, -1, -1, ! 3, 4, 5, 6, 7, 184, -1, -1, -1, 12, ! 607, 608, 609, -1, -1, 194, -1, 41, 615, -1, ! -1, -1, -1, -1, 27, -1, -1, 51, 31, 53, ! 514, 515, 35, 517, 631, 632, -1, 634, 41, -1, ! 524, 65, 1183, 1184, 1185, -1, -1, -1, 51, -1, ! 53, 75, -1, 56, -1, -1, -1, -1, -1, 83, ! -1, -1, 65, -1, 88, 362, 663, 364, 365, 366, ! -1, 555, 75, -1, -1, -1, -1, -1, -1, -1, ! 83, -1, -1, -1, -1, 88, 1227, -1, -1, -1, ! -1, -1, -1, 1108, -1, -1, -1, 10, -1, -1, ! -1, -1, -1, -1, -1, 841, 842, 843, 844, 845, ! -1, -1, -1, 849, 850, 851, 852, -1, -1, -1, ! -1, -1, -1, 607, 608, 609, -1, -1, -1, -1, ! -1, 615, -1, -1, -1, 314, -1, -1, 317, -1, ! -1, 877, -1, 322, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79, -1, 1183, 1184, ! 1185, 67, 68, 69, 70, 71, 72, 73, 74, 75, ! 76, 77, 78, 79, 363, -1, -1, -1, -1, -1, ! -1, 370, -1, -1, -1, -1, -1, 376, 682, 378, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 1227, -1, -1, 394, -1, 514, 515, 62, ! 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79, 416, 417, -1, ! 419, -1, -1, -1, 841, 842, 843, 844, 845, -1, ! 847, -1, 849, 850, 851, 852, -1, -1, 555, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 1004, 1005, ! -1, 1007, -1, -1, -1, -1, -1, -1, -1, -1, ! 877, -1, -1, -1, -1, -1, -1, -1, -1, 773, ! -1, 775, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 786, -1, -1, -1, 790, 791, 792, -1, ! 607, 608, -1, -1, 57, 58, 59, -1, 61, 62, ! 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79, 65, 66, 67, ! 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, ! 78, 79, 949, -1, -1, -1, -1, 841, 842, 843, ! 844, 845, 105, -1, -1, 849, 850, 851, 852, -1, ! -1, -1, 1108, -1, 3, 4, 5, 6, 7, -1, ! -1, 10, -1, 12, -1, 682, -1, -1, -1, -1, ! -1, -1, -1, 990, -1, 992, -1, -1, 27, -1, ! -1, -1, 31, -1, -1, -1, 35, 1004, 1005, -1, ! 1007, -1, 41, -1, -1, 44, -1, -1, -1, -1, ! -1, -1, 51, -1, 53, -1, -1, -1, 607, 608, ! -1, -1, -1, -1, -1, -1, 65, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, 75, 1183, 1184, 1185, ! -1, -1, 631, 632, 83, 634, 85, -1, -1, 88, ! 89, -1, -1, -1, 93, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, 773, -1, 775, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 786, ! -1, -1, -1, 790, 791, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, ! 79, 1108, -1, -1, -1, -1, -1, -1, -1, -1, ! 1004, 1005, -1, 1007, -1, -1, -1, -1, -1, -1, ! 32, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 841, 842, 843, 844, -1, -1, ! -1, -1, 849, 850, 851, 57, 58, 59, -1, 61, ! 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, ! 72, 73, 74, 75, 76, 77, 78, 79, -1, -1, ! -1, -1, -1, -1, -1, -1, 1183, 1184, 1185, -1, ! -1, -1, 1, -1, 3, 4, 5, 6, 7, 8, ! 9, -1, 11, 12, 13, -1, 15, 16, 17, 18, ! 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, ! 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, ! 1227, 40, 41, 42, 43, -1, -1, 46, 47, 48, ! 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, ! -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, ! -1, -1, 841, 842, 73, 74, 75, -1, -1, -1, ! 849, -1, 81, 82, 83, -1, -1, -1, -1, 88, ! -1, 90, -1, 92, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 103, 104, -1, -1, 877, -1, ! -1, 880, -1, 882, -1, -1, -1, 1004, 1005, -1, ! 1007, 1, -1, 3, 4, 5, 6, 7, 8, 9, -1, 11, 12, 13, -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, *************** *** 2706,2719 **** 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, ! -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, ! -1, -1, -1, 73, 74, 75, -1, 949, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, 90, -1, 92, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, 103, 104, -1, -1, -1, -1, 981, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 994, 995, -1, 997, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, 1, -1, 3, 4, 5, 6, 7, 8, 9, ! -1, 11, 12, 13, 1026, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, --- 2711,2744 ---- 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, ! -1, -1, 62, -1, -1, 65, -1, -1, -1, 958, ! -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, 90, -1, 92, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 991, 103, 104, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 1004, 1005, -1, 1007, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, 1, -1, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, 1035, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, -1, 92, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 103, 104, 1, -1, 3, ! 4, 5, 6, 7, 8, 9, -1, 11, 12, 13, ! -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, ! 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, ! -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, ! -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, ! 54, -1, 56, -1, -1, -1, -1, -1, 62, -1, ! -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, ! 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, ! -1, -1, -1, -1, 88, -1, 90, -1, 92, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 103, ! 104, 1, -1, 3, 4, 5, 6, 7, 8, 9, ! -1, 11, 12, 13, -1, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, *************** *** 2733,2796 **** -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, 90, -1, 92, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 103, 104, 1, ! -1, 3, 4, 5, 6, 7, 8, 9, -1, 11, ! 12, 13, -1, 15, 16, 17, 18, 19, 20, 21, ! 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, ! -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, ! 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, ! -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, ! 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, ! -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, ! 82, 83, -1, -1, -1, -1, 88, -1, 90, -1, ! 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, 103, 104, 1, -1, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, -1, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, 1, 92, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, 104, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, 1, 92, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, 104, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, 1, 92, 3, 4, 5, 6, 7, ! 8, 9, 10, 11, 12, -1, 104, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, 44, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, 85, -1, -1, ! 88, 89, -1, -1, 92, 93, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, 1, 104, 3, 4, 5, ! 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, ! 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, -1, -1, 92, 93, -1, -1, ! -1, -1, -1, -1, -1, -1, 102, 1, 104, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, --- 2758,2790 ---- -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, 90, 1, 92, 3, 4, 5, ! 6, 7, 8, 9, -1, 11, 12, 13, 104, 15, ! 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, ! 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, ! 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, ! 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, ! -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, 90, 1, 92, 3, 4, 5, ! 6, 7, 8, 9, -1, 11, 12, 13, 104, 15, ! 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, ! 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, ! 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, ! 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, ! -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, 90, 1, 92, 3, 4, 5, ! 6, 7, 8, 9, 10, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, ! 46, 47, 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, 85, ! -1, -1, 88, 89, -1, -1, 92, 93, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 1, 104, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, *************** *** 2797,2807 **** -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, ! -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, ! -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, ! -1, -1, -1, -1, 88, -1, -1, -1, 92, 93, ! -1, -1, -1, -1, -1, -1, -1, -1, 102, 1, ! 104, 3, 4, -1, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, --- 2791,2801 ---- -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, ! 44, -1, 46, 47, 48, 49, 50, 51, -1, 53, ! 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, ! -1, 85, -1, -1, 88, 89, -1, -1, 92, 93, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, ! 104, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, *************** *** 2808,2892 **** -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, 89, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, 103, 104, -1, -1, -1, -1, 19, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, 103, 104, -1, -1, -1, -1, 19, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, 5, 6, 7, 8, 9, -1, 11, - 12, 103, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, -1, -1, -1, -1, -1, -1, 60, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, - -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, - 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, - -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, - 82, 83, -1, -1, -1, -1, 88, -1, -1, 1, - 92, 3, 4, -1, 6, 7, 8, 9, -1, 11, - 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, - -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, - -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, - 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, --- 2802,2805 ---- *************** *** 2893,2908 **** -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, -1, -1, ! 92, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 102, 1, 104, 3, 4, -1, 6, 7, 8, 9, ! -1, 11, 12, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, ! 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, ! 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, ! 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, ! -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, ! -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, ! -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, ! -1, 1, 92, 3, 4, -1, 6, 7, 8, 9, ! -1, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, --- 2806,2812 ---- -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, -1, -1, ! 92, 93, -1, -1, -1, -1, -1, -1, -1, -1, ! 102, 1, 104, 3, 4, 5, 6, 7, 8, 9, ! 10, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, *************** *** 2912,2991 **** -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, ! 3, 4, 92, 6, 7, 8, 9, -1, 11, 12, ! -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, ! 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, ! 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, ! 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, ! -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, ! 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, ! 83, -1, -1, -1, -1, 88, -1, -1, -1, 92, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, 104, 105, 3, 4, 5, 6, 7, 8, 9, ! -1, 11, 12, 13, -1, 15, 16, 17, 18, 19, ! 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, ! 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, ! 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, ! 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, ! -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, ! -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, ! -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, ! 90, -1, 92, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, 103, 104, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, -1, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, -1, 92, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, 104, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, -1, 92, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 13, 104, 15, 16, 17, ! 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, 90, -1, 92, 3, 4, 5, 6, 7, ! 8, 9, 10, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, 44, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, 85, -1, -1, ! 88, 89, -1, -1, 92, 93, 3, 4, 5, 6, ! 7, 8, 9, 10, 11, 12, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, ! 37, 38, -1, 40, 41, 42, 43, 44, -1, 46, ! 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, ! -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, ! -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, ! -1, -1, -1, -1, 81, 82, 83, -1, 85, -1, ! -1, 88, 89, -1, -1, 92, 93, 3, 4, -1, ! 6, 7, 8, 9, -1, 11, 12, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, 44, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, 85, ! -1, -1, 88, 89, 3, 4, -1, 6, 7, 8, ! 9, -1, 11, 12, -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, --- 2816,3023 ---- -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, ! -1, -1, 92, 93, -1, -1, -1, -1, -1, -1, ! -1, -1, 102, 1, 104, 3, 4, -1, 6, 7, ! 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, 89, -1, 1, 92, 3, 4, -1, 6, 7, ! 8, 9, -1, 11, 12, 103, 104, -1, -1, -1, ! -1, 19, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, -1, 1, 92, 3, 4, -1, 6, 7, ! 8, 9, -1, 11, 12, 103, 104, -1, -1, -1, ! -1, 19, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, -1, 1, 92, 3, 4, 5, 6, 7, ! 8, 9, -1, 11, 12, 103, 104, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, -1, -1, 1, 92, 3, 4, -1, 6, 7, ! 8, 9, -1, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, 89, 1, -1, 92, 4, -1, 6, 7, -1, ! -1, -1, -1, 12, -1, -1, 104, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 27, -1, ! -1, -1, 31, -1, -1, -1, 35, -1, 37, 38, ! -1, -1, -1, -1, -1, 44, -1, -1, -1, -1, ! -1, -1, 51, -1, 53, -1, 55, -1, 57, 58, ! 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, ! 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, ! -1, -1, 81, 82, 83, -1, 1, 86, 3, 4, ! 89, 6, 7, 8, 9, -1, 11, 12, -1, -1, ! -1, -1, -1, -1, -1, 104, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, ! -1, -1, -1, -1, -1, 60, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, 54, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, ! 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, ! -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, ! -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, ! 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, ! -1, -1, -1, 88, -1, -1, 1, 92, 3, 4, ! -1, 6, 7, 8, 9, -1, 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, + 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, + -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, + -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, + 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, + 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, + -1, -1, -1, 88, -1, -1, -1, 92, -1, -1, + -1, -1, -1, -1, -1, -1, -1, 102, 1, 104, + 3, 4, -1, 6, 7, 8, 9, -1, 11, 12, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, + 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, + 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, + 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, + -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, + 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, + 83, -1, -1, -1, -1, 88, -1, -1, 1, 92, + 3, 4, -1, 6, 7, 8, 9, -1, 11, 12, + -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, + 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, + 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, + 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, + -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, + 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, + 83, -1, -1, -1, -1, 88, -1, 3, 4, 92, + 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, + -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, ! -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, ! -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, ! -1, -1, 88, -1, -1, -1, 92, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, -1, 104, 105, ! 3, 4, 5, 6, 7, 8, 9, -1, 11, 12, ! 13, -1, 15, 16, 17, 18, 19, 20, 21, 22, ! 23, 24, 25, 26, 27, 28, 29, 30, 31, -1, ! 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, ! 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, ! 53, 54, -1, 56, -1, -1, -1, -1, -1, 62, ! -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, ! 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, ! 83, -1, -1, -1, -1, 88, -1, 90, -1, 92, ! -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, ! 103, 104, 3, 4, 5, 6, 7, 8, 9, -1, ! 11, 12, 13, -1, 15, 16, 17, 18, 19, 20, ! 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, ! 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, ! 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, 54, -1, 56, -1, -1, -1, -1, ! -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, ! -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, -1, 90, ! -1, 92, 3, 4, 5, 6, 7, 8, 9, -1, ! 11, 12, 13, 104, 15, 16, 17, 18, 19, 20, ! 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, ! 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, ! 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, 54, -1, 56, -1, -1, -1, -1, ! -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, ! -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, -1, 90, ! -1, 92, 3, 4, 5, 6, 7, 8, 9, -1, ! 11, 12, 13, 104, 15, 16, 17, 18, 19, 20, ! 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, ! 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, ! 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, -1, -1, 56, -1, -1, -1, -1, ! -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, ! -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, -1, 90, ! -1, 92, 3, 4, 5, 6, 7, 8, 9, 10, ! 11, 12, -1, 104, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, ! 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, ! 41, 42, 43, 44, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, ! -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, ! -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, 85, -1, -1, 88, 89, -1, ! -1, 92, 93, 3, 4, 5, 6, 7, 8, 9, ! 10, 11, 12, 104, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, ! 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, ! 40, 41, 42, 43, 44, -1, 46, 47, 48, 49, ! 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, ! -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, ! -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, ! -1, 81, 82, 83, -1, 85, -1, -1, 88, 89, ! -1, -1, 92, 93, 3, 4, -1, 6, 7, 8, ! 9, -1, 11, 12, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, *************** *** 3009,3014 **** 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, ! -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, 3, 4, 92, 6, 7, --- 3041,3046 ---- 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, ! -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, ! 65, -1, -1, -1, -1, 70, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, 88, -1, 3, 4, 92, 6, 7, *************** *** 3017,3021 **** 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, --- 3049,3053 ---- 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, -1, -1, 56, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, *************** *** 3026,3044 **** 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, 3, 4, 88, 6, 7, ! 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, ! -1, -1, -1, 104, -1, -1, -1, -1, -1, 27, ! 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, ! 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, ! 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, ! -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, ! -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, ! -1, -1, -1, 81, 82, 83, -1, -1, -1, -1, ! 88, 89, 3, 4, -1, 6, 7, 8, 9, -1, ! 11, 12, -1, -1, -1, -1, 104, -1, -1, -1, ! -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, --- 3058,3076 ---- 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, ! 51, -1, 53, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, -1, 3, ! 4, 92, 6, 7, 8, 9, -1, 11, 12, -1, ! -1, -1, -1, 104, -1, -1, -1, -1, -1, -1, ! -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, ! -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, ! -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, ! 54, -1, -1, -1, -1, -1, -1, -1, 62, -1, ! -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, ! 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, ! -1, -1, 3, 4, 88, 6, 7, 8, 9, -1, ! 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, ! 104, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, *************** *** 3046,3051 **** -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, -1, 3, ! 4, 92, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, --- 3078,3083 ---- -1, 62, -1, -1, 65, -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, ! 81, 82, 83, -1, -1, -1, -1, 88, 89, 3, ! 4, -1, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, 104, -1, -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, 29, 30, 31, -1, 33, *************** *** 3090,3093 **** --- 3122,3142 ---- -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, + -1, -1, 88, -1, 3, 4, 92, 6, 7, 8, + 9, -1, 11, 12, -1, -1, -1, -1, 104, -1, + -1, -1, -1, -1, -1, -1, -1, -1, 27, 28, + 29, 30, 31, -1, 33, -1, 35, -1, 37, 38, + -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, + 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, + -1, -1, -1, 62, -1, -1, 65, -1, -1, -1, + -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, + -1, -1, 81, 82, 83, -1, -1, 3, 4, 88, + 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, + -1, -1, -1, -1, -1, 104, -1, -1, -1, -1, + -1, 27, 28, 29, 30, 31, -1, 33, -1, 35, + -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, + 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, + -1, -1, -1, -1, -1, -1, 62, -1, -1, 65, + -1, -1, -1, -1, -1, -1, -1, 73, 74, 75, + -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, 3, 4, 88, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, -1, -1, -1, 104, -1, *************** *** 3100,3105 **** 83, -1, -1, 3, 4, 88, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, -1, -1, ! -1, 104, -1, -1, -1, -1, -1, 27, 28, 29, ! 30, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, --- 3149,3154 ---- 83, -1, -1, 3, 4, 88, 6, 7, 8, 9, -1, 11, 12, -1, -1, -1, -1, -1, -1, -1, ! -1, 104, -1, -1, -1, -1, -1, 27, 28, -1, ! -1, 31, -1, 33, -1, 35, -1, 37, 38, -1, 40, 41, 42, 43, -1, -1, 46, 47, 48, 49, 50, 51, -1, 53, -1, -1, -1, -1, -1, -1, *************** *** 3115,3159 **** -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, ! -1, 88, 3, 4, 5, 6, 7, -1, -1, 10, ! -1, 12, -1, -1, -1, -1, -1, 104, -1, 3, ! 4, 5, 6, 7, -1, -1, 27, -1, 12, -1, ! 31, -1, -1, -1, 35, -1, -1, -1, -1, -1, ! 41, -1, -1, 27, -1, -1, -1, 31, -1, -1, ! 51, 35, 53, -1, -1, -1, -1, 41, -1, -1, ! -1, -1, -1, -1, 65, -1, -1, 51, -1, 53, ! -1, -1, -1, -1, 75, -1, 60, -1, -1, -1, ! -1, 65, 83, -1, -1, -1, -1, 88, -1, -1, ! -1, 75, 3, 4, 5, 6, 7, -1, -1, 83, ! -1, 12, -1, -1, 88, -1, -1, -1, -1, 3, ! 4, 5, 6, 7, -1, -1, 27, -1, 12, -1, ! 31, -1, -1, -1, 35, -1, -1, -1, -1, -1, ! 41, -1, -1, 27, -1, -1, -1, 31, -1, -1, ! 51, 35, 53, -1, -1, 56, -1, 41, -1, -1, ! -1, -1, -1, -1, 65, -1, -1, 51, -1, 53, ! -1, -1, -1, -1, 75, -1, -1, -1, -1, -1, ! -1, 65, 83, -1, -1, -1, -1, 88, -1, -1, ! -1, 75, -1, -1, -1, -1, -1, -1, -1, 83, ! 32, 57, 58, 59, 88, 61, 62, 63, 64, 65, ! 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, ! 76, 77, 78, 79, -1, 57, 58, 59, -1, 61, ! 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, ! 72, 73, 74, 75, 76, 77, 78, 79, 55, 105, ! 57, 58, 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, ! 77, 78, 79, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, ! 74, 75, 76, 77, 78, 79, 57, 58, 59, 60, ! 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, ! 71, 72, 73, 74, 75, 76, 77, 78, 79, 57, ! 58, 59, -1, 61, 62, 63, 64, 65, 66, 67, ! 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, ! 78, 79, 57, 58, 59, -1, 61, 62, 63, 64, ! 65, 66, 67, 68, 69, -1, 71, 72, 73, 74, ! 75, 76, 77, 78, 79, 62, 63, 64, 65, 66, ! 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, ! 77, 78, 79, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, ! 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, ! 74, 75, 76, 77, 78, 79 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ --- 3164,3184 ---- -1, -1, -1, -1, -1, -1, 73, 74, 75, -1, -1, -1, -1, -1, 81, 82, 83, -1, -1, -1, ! -1, 88, -1, -1, -1, -1, -1, -1, -1, -1, ! -1, -1, 55, -1, 57, 58, 59, 104, 61, 62, ! 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79, 57, 58, 59, ! 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, ! 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, ! 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, ! 77, 78, 79, 57, 58, 59, -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, ! 74, 75, 76, 77, 78, 79, 57, 58, 59, -1, ! 61, 62, 63, 64, 65, 66, 67, 68, 69, -1, ! 71, 72, 73, 74, 75, 76, 77, 78, 79, 59, ! -1, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, ! 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, ! 73, 74, 75, 76, 77, 78, 79 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ *************** *** 3638,3642 **** case 2: ! #line 293 "parse.y" { /* In case there were missing closebraces, --- 3663,3667 ---- case 2: ! #line 294 "parse.y" { /* In case there were missing closebraces, *************** *** 3648,3664 **** break;} case 3: ! #line 307 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 4: ! #line 308 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 5: ! #line 310 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 6: ! #line 314 "parse.y" { have_extern_spec = 1; used_extern_spec = 0; --- 3673,3689 ---- break;} case 3: ! #line 308 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 4: ! #line 309 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 5: ! #line 311 "parse.y" { yyval.ttype = NULL_TREE; ; break;} case 6: ! #line 315 "parse.y" { have_extern_spec = 1; used_extern_spec = 0; *************** *** 3666,3678 **** break;} case 7: ! #line 319 "parse.y" { have_extern_spec = 0; ; break;} case 10: ! #line 328 "parse.y" { if (pending_lang_change) do_pending_lang_change(); ; break;} case 11: ! #line 330 "parse.y" { if (! global_bindings_p () && ! pseudo_global_level_p()) pop_everything (); ; --- 3691,3703 ---- break;} case 7: ! #line 320 "parse.y" { have_extern_spec = 0; ; break;} case 10: ! #line 329 "parse.y" { if (pending_lang_change) do_pending_lang_change(); ; break;} case 11: ! #line 331 "parse.y" { if (! global_bindings_p () && ! pseudo_global_level_p()) pop_everything (); ; *************** *** 3679,3695 **** break;} case 12: ! #line 336 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 13: ! #line 338 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 14: ! #line 340 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 16: ! #line 343 "parse.y" { if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype); assemble_asm (yyvsp[-2].ttype); ; --- 3704,3720 ---- break;} case 12: ! #line 337 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 13: ! #line 339 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 14: ! #line 341 "parse.y" { if (pending_inlines) do_pending_inlines (); ; break;} case 16: ! #line 344 "parse.y" { if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype); assemble_asm (yyvsp[-2].ttype); ; *************** *** 3696,3708 **** break;} case 17: ! #line 346 "parse.y" { pop_lang_context (); ; break;} case 18: ! #line 348 "parse.y" { pop_lang_context (); ; break;} case 19: ! #line 350 "parse.y" { if (pending_inlines) do_pending_inlines (); pop_lang_context (); ; --- 3721,3733 ---- break;} case 17: ! #line 347 "parse.y" { pop_lang_context (); ; break;} case 18: ! #line 349 "parse.y" { pop_lang_context (); ; break;} case 19: ! #line 351 "parse.y" { if (pending_inlines) do_pending_inlines (); pop_lang_context (); ; *************** *** 3709,3713 **** break;} case 20: ! #line 353 "parse.y" { if (pending_inlines) do_pending_inlines (); pop_lang_context (); ; --- 3734,3738 ---- break;} case 20: ! #line 354 "parse.y" { if (pending_inlines) do_pending_inlines (); pop_lang_context (); ; *************** *** 3714,3783 **** break;} case 21: ! #line 359 "parse.y" { push_lang_context (yyvsp[0].ttype); ; break;} case 22: ! #line 364 "parse.y" { begin_template_parm_list (); ; break;} case 23: ! #line 366 "parse.y" { yyval.ttype = end_template_parm_list (yyvsp[-1].ttype); ; break;} case 24: ! #line 371 "parse.y" { yyval.ttype = process_template_parm (NULL_TREE, yyvsp[0].ttype); ; break;} case 25: ! #line 373 "parse.y" { yyval.ttype = process_template_parm (yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} case 26: ! #line 385 "parse.y" ! { ! if (yyvsp[-1].ttype == signature_type_node) ! sorry ("signature as template type parameter"); ! else if (yyvsp[-1].ttype != class_type_node) ! error ("template type parameter must use keyword `class'"); yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); ; break;} case 27: ! #line 393 "parse.y" ! { ! if (yyvsp[-3].ttype == signature_type_node) ! sorry ("signature as template type parameter"); ! else if (yyvsp[-3].ttype != class_type_node) ! error ("template type parameter must use keyword `class'"); ! warning ("restricted template type parameters not yet implemented"); ! yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ! ; break;} ! case 29: ! #line 406 "parse.y" ! { warning ("use of `overload' is an anachronism"); ; break;} ! case 30: ! #line 410 "parse.y" ! { declare_overloaded (yyvsp[0].ttype); ; break;} case 31: #line 412 "parse.y" { declare_overloaded (yyvsp[0].ttype); ; break;} ! case 32: ! #line 419 "parse.y" ! { yychar = '{'; goto template1; ; break;} case 34: ! #line 422 "parse.y" { yychar = '{'; goto template1; ; break;} case 36: ! #line 425 "parse.y" ! { yychar = ':'; goto template1; ; break;} case 38: ! #line 428 "parse.y" { yychar = ':'; --- 3739,3810 ---- break;} case 21: ! #line 360 "parse.y" { push_lang_context (yyvsp[0].ttype); ; break;} case 22: ! #line 365 "parse.y" { begin_template_parm_list (); ; break;} case 23: ! #line 367 "parse.y" { yyval.ttype = end_template_parm_list (yyvsp[-1].ttype); ; break;} case 24: ! #line 372 "parse.y" { yyval.ttype = process_template_parm (NULL_TREE, yyvsp[0].ttype); ; break;} case 25: ! #line 374 "parse.y" { yyval.ttype = process_template_parm (yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} case 26: ! #line 379 "parse.y" ! { yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); + ttpa: + if (TREE_PURPOSE (yyval.ttype) == signature_type_node) + sorry ("signature as template type parameter"); + else if (TREE_PURPOSE (yyval.ttype) != class_type_node) + pedwarn ("template type parameters must use the keyword `class'"); ; break;} case 27: ! #line 388 "parse.y" ! { yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); goto ttpa; ; break;} ! case 28: ! #line 400 "parse.y" ! { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 29: ! #line 402 "parse.y" ! { yyval.ttype = build_tree_list (yyvsp[0].ttype, yyval.ttype); ; break;} case 31: + #line 408 "parse.y" + { warning ("use of `overload' is an anachronism"); ; + break;} + case 32: #line 412 "parse.y" { declare_overloaded (yyvsp[0].ttype); ; break;} ! case 33: ! #line 414 "parse.y" ! { declare_overloaded (yyvsp[0].ttype); ; break;} case 34: ! #line 421 "parse.y" { yychar = '{'; goto template1; ; break;} case 36: ! #line 424 "parse.y" ! { yychar = '{'; goto template1; ; break;} case 38: ! #line 427 "parse.y" ! { yychar = ':'; goto template1; ; ! break;} ! case 40: ! #line 430 "parse.y" { yychar = ':'; *************** *** 3794,3799 **** ; break;} ! case 40: ! #line 443 "parse.y" { end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr, 0); --- 3821,3826 ---- ; break;} ! case 42: ! #line 445 "parse.y" { end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr, 0); *************** *** 3801,3806 **** ; break;} ! case 41: ! #line 448 "parse.y" { end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr, 0); --- 3828,3833 ---- ; break;} ! case 43: ! #line 450 "parse.y" { end_template_decl (yyvsp[-2].ttype, yyvsp[-1].ttype, current_aggr, 0); *************** *** 3808,3813 **** ; break;} ! case 42: ! #line 455 "parse.y" { tree d; --- 3835,3840 ---- ; break;} ! case 44: ! #line 457 "parse.y" { tree d; *************** *** 3825,3830 **** ; break;} ! case 43: ! #line 472 "parse.y" { tree d; --- 3852,3857 ---- ; break;} ! case 45: ! #line 474 "parse.y" { tree d; *************** *** 3848,3853 **** ; break;} ! case 44: ! #line 493 "parse.y" { int def = (yyvsp[0].itype != ';'); --- 3875,3880 ---- ; break;} ! case 46: ! #line 495 "parse.y" { int def = (yyvsp[0].itype != ';'); *************** *** 3859,3900 **** ; break;} - case 45: - #line 502 "parse.y" - { end_template_decl (yyvsp[-2].ttype, 0, 0, 0); ; - break;} - case 46: - #line 503 "parse.y" - { end_template_decl (yyvsp[-2].ttype, 0, 0, 0); ; - break;} case 47: ! #line 506 "parse.y" ! { yyval.itype = '{'; ; break;} case 48: ! #line 507 "parse.y" ! { yyval.itype = ':'; ; break;} case 49: #line 508 "parse.y" ! { yyval.itype = ';'; ; break;} case 50: #line 509 "parse.y" ! { yyval.itype = '='; ; break;} case 51: #line 510 "parse.y" ! { yyval.itype = RETURN; ; break;} case 52: ! #line 515 "parse.y" ! {; break;} case 53: #line 517 "parse.y" {; break;} ! case 54: ! #line 520 "parse.y" { tree d; d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE); --- 3886,3927 ---- ; break;} case 47: ! #line 504 "parse.y" ! { end_template_decl (yyvsp[-2].ttype, 0, 0, 0); ; break;} case 48: ! #line 505 "parse.y" ! { end_template_decl (yyvsp[-2].ttype, 0, 0, 0); ; break;} case 49: #line 508 "parse.y" ! { yyval.itype = '{'; ; break;} case 50: #line 509 "parse.y" ! { yyval.itype = ':'; ; break;} case 51: #line 510 "parse.y" ! { yyval.itype = ';'; ; break;} case 52: ! #line 511 "parse.y" ! { yyval.itype = '='; ; break;} case 53: + #line 512 "parse.y" + { yyval.itype = RETURN; ; + break;} + case 54: #line 517 "parse.y" {; break;} ! case 55: ! #line 519 "parse.y" ! {; ! break;} ! case 56: ! #line 522 "parse.y" { tree d; d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE); *************** *** 3902,3907 **** ; break;} ! case 55: ! #line 525 "parse.y" { note_list_got_semicolon (yyval.ttype); --- 3929,3934 ---- ; break;} ! case 57: ! #line 527 "parse.y" { note_list_got_semicolon (yyval.ttype); *************** *** 3908,3913 **** ; break;} ! case 56: ! #line 530 "parse.y" { tree d; d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE); --- 3935,3940 ---- ; break;} ! case 58: ! #line 532 "parse.y" { tree d; d = start_decl (yyvsp[-1].ttype, yyval.ttype, 0, NULL_TREE); *************** *** 3916,3925 **** ; break;} ! case 57: ! #line 536 "parse.y" { pedwarn ("empty declaration"); ; break;} ! case 59: ! #line 539 "parse.y" { tree t = yyval.ttype; --- 3943,3952 ---- ; break;} ! case 59: ! #line 538 "parse.y" { pedwarn ("empty declaration"); ; break;} ! case 61: ! #line 541 "parse.y" { tree t = yyval.ttype; *************** *** 3941,3946 **** ; break;} ! case 63: ! #line 564 "parse.y" { finish_function (lineno, 1); --- 3968,3973 ---- ; break;} ! case 65: ! #line 566 "parse.y" { finish_function (lineno, 1); *************** *** 3956,3961 **** ; break;} ! case 64: ! #line 577 "parse.y" { finish_function (lineno, 1); --- 3983,3988 ---- ; break;} ! case 66: ! #line 579 "parse.y" { finish_function (lineno, 1); *************** *** 3971,4003 **** ; break;} ! case 65: ! #line 590 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 66: ! #line 593 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 67: ! #line 596 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 68: ! #line 599 "parse.y" ! {; ! break;} ! case 69: #line 601 "parse.y" {; break;} ! case 70: #line 603 "parse.y" {; break;} ! case 71: ! #line 608 "parse.y" { if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0)) YYERROR1; --- 3998,4030 ---- ; break;} ! case 67: ! #line 592 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 68: ! #line 595 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 69: ! #line 598 "parse.y" { finish_function (lineno, 0); if (yyval.ttype) process_next_inline (yyval.ttype); ; break;} ! case 70: #line 601 "parse.y" {; break;} ! case 71: #line 603 "parse.y" {; break;} ! case 72: ! #line 605 "parse.y" ! {; ! break;} ! case 73: ! #line 610 "parse.y" { if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0)) YYERROR1; *************** *** 4005,4010 **** yyval.ttype = NULL_TREE; ; break;} ! case 72: ! #line 613 "parse.y" { if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0)) YYERROR1; --- 4032,4037 ---- yyval.ttype = NULL_TREE; ; break;} ! case 74: ! #line 615 "parse.y" { if (! start_function (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype, 0)) YYERROR1; *************** *** 4012,4017 **** yyval.ttype = NULL_TREE; ; break;} ! case 73: ! #line 618 "parse.y" { if (! start_function (NULL_TREE, yyval.ttype, yyvsp[0].ttype, 0)) YYERROR1; --- 4039,4044 ---- yyval.ttype = NULL_TREE; ; break;} ! case 75: ! #line 620 "parse.y" { if (! start_function (NULL_TREE, yyval.ttype, yyvsp[0].ttype, 0)) YYERROR1; *************** *** 4019,4029 **** yyval.ttype = NULL_TREE; ; break;} ! case 74: ! #line 623 "parse.y" { start_function (NULL_TREE, TREE_VALUE (yyval.ttype), NULL_TREE, 1); reinit_parse_for_function (); ; break;} ! case 75: ! #line 631 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype); --- 4046,4056 ---- yyval.ttype = NULL_TREE; ; break;} ! case 76: ! #line 625 "parse.y" { start_function (NULL_TREE, TREE_VALUE (yyval.ttype), NULL_TREE, 1); reinit_parse_for_function (); ; break;} ! case 77: ! #line 633 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-5].ttype), yyvsp[-3].ttype, yyvsp[-1].ttype); *************** *** 4036,4041 **** reinit_parse_for_method (yychar, yyval.ttype); ; break;} ! case 76: ! #line 641 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-3].ttype), --- 4063,4068 ---- reinit_parse_for_method (yychar, yyval.ttype); ; break;} ! case 78: ! #line 643 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-3].ttype), *************** *** 4045,4062 **** ; break;} ! case 77: ! #line 648 "parse.y" ! { yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype); goto rest_of_mdef; ; ! break;} ! case 78: #line 650 "parse.y" { yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype); goto rest_of_mdef; ; break;} ! case 79: #line 652 "parse.y" { yyval.ttype = start_method (NULL_TREE, yyval.ttype, yyvsp[0].ttype); goto rest_of_mdef; ; break;} ! case 80: ! #line 656 "parse.y" { if (! current_function_parms_stored) --- 4072,4089 ---- ; break;} ! case 79: #line 650 "parse.y" { yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype); goto rest_of_mdef; ; break;} ! case 80: #line 652 "parse.y" + { yyval.ttype = start_method (yyval.ttype, yyvsp[-1].ttype, yyvsp[0].ttype); goto rest_of_mdef; ; + break;} + case 81: + #line 654 "parse.y" { yyval.ttype = start_method (NULL_TREE, yyval.ttype, yyvsp[0].ttype); goto rest_of_mdef; ; break;} ! case 82: ! #line 658 "parse.y" { if (! current_function_parms_stored) *************** *** 4065,4086 **** ; break;} ! case 81: ! #line 664 "parse.y" { store_return_init (yyval.ttype, NULL_TREE); ; break;} ! case 82: ! #line 666 "parse.y" { store_return_init (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 83: ! #line 668 "parse.y" { store_return_init (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 84: ! #line 670 "parse.y" { store_return_init (yyval.ttype, NULL_TREE); ; break;} ! case 85: ! #line 675 "parse.y" { if (yyvsp[0].itype == 0) --- 4092,4113 ---- ; break;} ! case 83: ! #line 666 "parse.y" { store_return_init (yyval.ttype, NULL_TREE); ; break;} ! case 84: ! #line 668 "parse.y" { store_return_init (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 85: ! #line 670 "parse.y" { store_return_init (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 86: ! #line 672 "parse.y" { store_return_init (yyval.ttype, NULL_TREE); ; break;} ! case 87: ! #line 677 "parse.y" { if (yyvsp[0].itype == 0) *************** *** 4093,4098 **** ; break;} ! case 86: ! #line 688 "parse.y" { if (! current_function_parms_stored) --- 4120,4125 ---- ; break;} ! case 88: ! #line 690 "parse.y" { if (! current_function_parms_stored) *************** *** 4115,4128 **** ; break;} ! case 87: ! #line 711 "parse.y" { yyval.itype = 0; ; break;} ! case 88: ! #line 713 "parse.y" { yyval.itype = 1; ; break;} ! case 91: ! #line 719 "parse.y" { if (current_class_name && !flag_traditional) --- 4142,4155 ---- ; break;} ! case 89: ! #line 713 "parse.y" { yyval.itype = 0; ; break;} ! case 90: ! #line 715 "parse.y" { yyval.itype = 1; ; break;} ! case 93: ! #line 721 "parse.y" { if (current_class_name && !flag_traditional) *************** *** 4131,4136 **** ; break;} ! case 92: ! #line 725 "parse.y" { if (current_class_name && !flag_traditional) --- 4158,4163 ---- ; break;} ! case 94: ! #line 727 "parse.y" { if (current_class_name && !flag_traditional) *************** *** 4139,4160 **** ; break;} ! case 93: ! #line 731 "parse.y" { expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 94: ! #line 733 "parse.y" { expand_member_init (C_C_D, yyval.ttype, void_type_node); ; break;} ! case 95: ! #line 735 "parse.y" { expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 96: ! #line 737 "parse.y" { expand_member_init (C_C_D, yyval.ttype, void_type_node); ; break;} ! case 97: ! #line 740 "parse.y" { do_member_init (OP0 (yyvsp[-3].ttype), OP1 (yyvsp[-3].ttype), yyvsp[-1].ttype); --- 4166,4187 ---- ; break;} ! case 95: ! #line 733 "parse.y" { expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 96: ! #line 735 "parse.y" { expand_member_init (C_C_D, yyval.ttype, void_type_node); ; break;} ! case 97: ! #line 737 "parse.y" { expand_member_init (C_C_D, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 98: ! #line 739 "parse.y" { expand_member_init (C_C_D, yyval.ttype, void_type_node); ; break;} ! case 99: ! #line 742 "parse.y" { do_member_init (OP0 (yyvsp[-3].ttype), OP1 (yyvsp[-3].ttype), yyvsp[-1].ttype); *************** *** 4161,4166 **** ; break;} ! case 98: ! #line 744 "parse.y" { do_member_init (OP0 (yyvsp[-1].ttype), OP1 (yyvsp[-1].ttype), void_type_node); --- 4188,4193 ---- ; break;} ! case 100: ! #line 746 "parse.y" { do_member_init (OP0 (yyvsp[-1].ttype), OP1 (yyvsp[-1].ttype), void_type_node); *************** *** 4167,4216 **** ; break;} ! case 107: ! #line 768 "parse.y" { do_type_instantiation (yyvsp[0].ttype ? yyvsp[0].ttype : yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 108: ! #line 770 "parse.y" { do_function_instantiation (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE); ; break;} ! case 109: ! #line 772 "parse.y" { do_type_instantiation (yyvsp[0].ttype ? yyvsp[0].ttype : yyvsp[-1].ttype, yyvsp[-3].ttype); ; break;} ! case 110: ! #line 774 "parse.y" { do_function_instantiation (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); ; break;} ! case 111: ! #line 779 "parse.y" { if (yyvsp[0].ttype) yyval.ttype = yyvsp[0].ttype; ; break;} ! case 112: ! #line 784 "parse.y" { yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 113: ! #line 786 "parse.y" { yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 114: ! #line 791 "parse.y" { yyval.ttype = instantiate_class_template (yyvsp[0].ttype, 1); ; break;} ! case 115: ! #line 796 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 116: ! #line 798 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 117: ! #line 803 "parse.y" { yyval.ttype = groktypename (yyval.ttype); ; break;} ! case 119: ! #line 809 "parse.y" { tree t, decl, tmpl; --- 4194,4247 ---- ; break;} ! case 109: ! #line 770 "parse.y" { do_type_instantiation (yyvsp[0].ttype ? yyvsp[0].ttype : yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 110: ! #line 772 "parse.y" { do_function_instantiation (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE); ; break;} ! case 111: ! #line 774 "parse.y" { do_type_instantiation (yyvsp[0].ttype ? yyvsp[0].ttype : yyvsp[-1].ttype, yyvsp[-3].ttype); ; break;} ! case 112: ! #line 776 "parse.y" { do_function_instantiation (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); ; break;} ! case 113: ! #line 781 "parse.y" { if (yyvsp[0].ttype) yyval.ttype = yyvsp[0].ttype; ; break;} ! case 114: ! #line 786 "parse.y" { yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 115: ! #line 788 "parse.y" ! { yyval.ttype = lookup_template_class (yyval.ttype, NULL_TREE, NULL_TREE); ; ! break;} ! case 116: ! #line 790 "parse.y" { yyval.ttype = lookup_template_class (yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 117: ! #line 795 "parse.y" { yyval.ttype = instantiate_class_template (yyvsp[0].ttype, 1); ; break;} ! case 118: ! #line 800 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 119: ! #line 802 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 120: ! #line 807 "parse.y" { yyval.ttype = groktypename (yyval.ttype); ; break;} ! case 122: ! #line 813 "parse.y" { tree t, decl, tmpl; *************** *** 4246,4251 **** ; break;} ! case 120: ! #line 842 "parse.y" { tree t = finish_struct (yyvsp[-3].ttype, yyvsp[-1].ttype, 0); --- 4277,4282 ---- ; break;} ! case 123: ! #line 846 "parse.y" { tree t = finish_struct (yyvsp[-3].ttype, yyvsp[-1].ttype, 0); *************** *** 4262,4307 **** ; break;} ! case 121: ! #line 859 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 122: ! #line 861 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 123: ! #line 866 "parse.y" { yyval.ttype = NULL_TREE; /* never used from here... */; break;} ! case 124: ! #line 868 "parse.y" { yyval.ttype = yyvsp[-1].ttype; /*???*/ ; break;} ! case 125: ! #line 872 "parse.y" { yyval.code = NEGATE_EXPR; ; break;} ! case 126: ! #line 874 "parse.y" { yyval.code = CONVERT_EXPR; ; break;} ! case 127: ! #line 876 "parse.y" { yyval.code = PREINCREMENT_EXPR; ; break;} ! case 128: ! #line 878 "parse.y" { yyval.code = PREDECREMENT_EXPR; ; break;} ! case 129: ! #line 880 "parse.y" { yyval.code = TRUTH_NOT_EXPR; ; break;} ! case 130: ! #line 884 "parse.y" { yyval.ttype = build_x_compound_expr (yyval.ttype); ; break;} ! case 132: ! #line 890 "parse.y" { error ("ANSI C++ forbids an empty condition for `%s'", cond_stmt_keyword); --- 4293,4338 ---- ; break;} ! case 124: ! #line 863 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 125: ! #line 865 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 126: ! #line 870 "parse.y" { yyval.ttype = NULL_TREE; /* never used from here... */; break;} ! case 127: ! #line 872 "parse.y" { yyval.ttype = yyvsp[-1].ttype; /*???*/ ; break;} ! case 128: ! #line 876 "parse.y" { yyval.code = NEGATE_EXPR; ; break;} ! case 129: ! #line 878 "parse.y" { yyval.code = CONVERT_EXPR; ; break;} ! case 130: ! #line 880 "parse.y" { yyval.code = PREINCREMENT_EXPR; ; break;} ! case 131: ! #line 882 "parse.y" { yyval.code = PREDECREMENT_EXPR; ; break;} ! case 132: ! #line 884 "parse.y" { yyval.code = TRUTH_NOT_EXPR; ; break;} ! case 133: ! #line 888 "parse.y" { yyval.ttype = build_x_compound_expr (yyval.ttype); ; break;} ! case 135: ! #line 894 "parse.y" { error ("ANSI C++ forbids an empty condition for `%s'", cond_stmt_keyword); *************** *** 4308,4317 **** yyval.ttype = integer_zero_node; ; break;} ! case 133: ! #line 894 "parse.y" ! { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 134: ! #line 899 "parse.y" { error ("ANSI C++ forbids an empty condition for `%s'", cond_stmt_keyword); --- 4339,4349 ---- yyval.ttype = integer_zero_node; ; break;} ! case 136: ! #line 898 "parse.y" ! { yyval.ttype = build1 (CLEANUP_POINT_EXPR, bool_type_node, ! bool_truthvalue_conversion (yyvsp[-1].ttype)); ; break;} ! case 137: ! #line 904 "parse.y" { error ("ANSI C++ forbids an empty condition for `%s'", cond_stmt_keyword); *************** *** 4318,4335 **** yyval.ttype = integer_zero_node; ; break;} ! case 135: ! #line 903 "parse.y" ! { yyval.ttype = yyvsp[-1].ttype; ; ! break;} ! case 136: #line 908 "parse.y" ! { yyval.ttype = NULL_TREE; ; break;} ! case 138: ! #line 911 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 139: #line 916 "parse.y" { { tree d; --- 4350,4373 ---- yyval.ttype = integer_zero_node; ; break;} ! case 138: #line 908 "parse.y" ! { yyval.ttype = build1 (CLEANUP_POINT_EXPR, bool_type_node, ! bool_truthvalue_conversion (yyvsp[-1].ttype)); ; break;} ! case 139: ! #line 914 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 140: #line 916 "parse.y" + { yyval.ttype = build1 (CLEANUP_POINT_EXPR, bool_type_node, + bool_truthvalue_conversion (yyval.ttype)); ; + break;} + case 141: + #line 919 "parse.y" + { yyval.ttype = NULL_TREE; ; + break;} + case 142: + #line 924 "parse.y" { { tree d; *************** *** 4349,4354 **** ; break;} ! case 140: ! #line 933 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].ttype, 0); --- 4387,4392 ---- ; break;} ! case 143: ! #line 941 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].ttype, 0); *************** *** 4359,4398 **** ; break;} ! case 142: ! #line 945 "parse.y" { finish_stmt (); ; break;} ! case 143: ! #line 947 "parse.y" { finish_stmt (); ; break;} ! case 144: ! #line 949 "parse.y" { finish_stmt (); ; break;} ! case 146: ! #line 956 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 147: ! #line 959 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, build_tree_list (NULL_TREE, error_mark_node)); ; break;} ! case 148: ! #line 962 "parse.y" { chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 149: ! #line 964 "parse.y" { chainon (yyval.ttype, build_tree_list (NULL_TREE, error_mark_node)); ; break;} ! case 150: ! #line 969 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 152: ! #line 975 "parse.y" { #if 0 --- 4397,4436 ---- ; break;} ! case 145: ! #line 953 "parse.y" { finish_stmt (); ; break;} ! case 146: ! #line 955 "parse.y" { finish_stmt (); ; break;} ! case 147: ! #line 957 "parse.y" { finish_stmt (); ; break;} ! case 149: ! #line 964 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 150: ! #line 967 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, build_tree_list (NULL_TREE, error_mark_node)); ; break;} ! case 151: ! #line 970 "parse.y" { chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 152: ! #line 972 "parse.y" { chainon (yyval.ttype, build_tree_list (NULL_TREE, error_mark_node)); ; break;} ! case 153: ! #line 977 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 155: ! #line 983 "parse.y" { #if 0 *************** *** 4402,4429 **** ; break;} ! case 153: ! #line 983 "parse.y" { yyvsp[0].itype = pedantic; pedantic = 0; ; break;} ! case 154: ! #line 986 "parse.y" { yyval.ttype = yyvsp[0].ttype; pedantic = yyvsp[-2].itype; ; break;} ! case 155: ! #line 989 "parse.y" { yyval.ttype = build_x_indirect_ref (yyvsp[0].ttype, "unary *"); ; break;} ! case 156: ! #line 991 "parse.y" { yyval.ttype = build_x_unary_op (ADDR_EXPR, yyvsp[0].ttype); ; break;} ! case 157: ! #line 993 "parse.y" { yyval.ttype = build_x_unary_op (BIT_NOT_EXPR, yyvsp[0].ttype); ; break;} ! case 158: ! #line 995 "parse.y" { yyval.ttype = build_x_unary_op (yyvsp[-1].code, yyvsp[0].ttype); if (yyvsp[-1].code == NEGATE_EXPR && TREE_CODE (yyvsp[0].ttype) == INTEGER_CST) --- 4440,4467 ---- ; break;} ! case 156: ! #line 991 "parse.y" { yyvsp[0].itype = pedantic; pedantic = 0; ; break;} ! case 157: ! #line 994 "parse.y" { yyval.ttype = yyvsp[0].ttype; pedantic = yyvsp[-2].itype; ; break;} ! case 158: ! #line 997 "parse.y" { yyval.ttype = build_x_indirect_ref (yyvsp[0].ttype, "unary *"); ; break;} ! case 159: ! #line 999 "parse.y" { yyval.ttype = build_x_unary_op (ADDR_EXPR, yyvsp[0].ttype); ; break;} ! case 160: ! #line 1001 "parse.y" { yyval.ttype = build_x_unary_op (BIT_NOT_EXPR, yyvsp[0].ttype); ; break;} ! case 161: ! #line 1003 "parse.y" { yyval.ttype = build_x_unary_op (yyvsp[-1].code, yyvsp[0].ttype); if (yyvsp[-1].code == NEGATE_EXPR && TREE_CODE (yyvsp[0].ttype) == INTEGER_CST) *************** *** 4432,4437 **** ; break;} ! case 159: ! #line 1002 "parse.y" { tree label = lookup_label (yyvsp[0].ttype); if (label == NULL_TREE) --- 4470,4475 ---- ; break;} ! case 162: ! #line 1010 "parse.y" { tree label = lookup_label (yyvsp[0].ttype); if (label == NULL_TREE) *************** *** 4445,4450 **** ; break;} ! case 160: ! #line 1013 "parse.y" { if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF && DECL_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1))) --- 4483,4488 ---- ; break;} ! case 163: ! #line 1021 "parse.y" { if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF && DECL_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1))) *************** *** 4467,4521 **** yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ; break;} ! case 161: ! #line 1033 "parse.y" { yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ; break;} ! case 162: ! #line 1035 "parse.y" { yyval.ttype = grok_alignof (yyvsp[0].ttype); ; break;} ! case 163: ! #line 1037 "parse.y" { yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ; break;} ! case 164: ! #line 1042 "parse.y" { yyval.ttype = build_new (NULL_TREE, yyvsp[0].ttype, NULL_TREE, yyvsp[-1].itype); ; break;} ! case 165: ! #line 1044 "parse.y" { yyval.ttype = build_new (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-2].itype); ; break;} ! case 166: ! #line 1046 "parse.y" { yyval.ttype = build_new (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE, yyvsp[-2].itype); ; break;} ! case 167: ! #line 1048 "parse.y" { yyval.ttype = build_new (yyvsp[-2].ttype, yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].itype); ; break;} ! case 168: ! #line 1050 "parse.y" { yyval.ttype = build_new (NULL_TREE, groktypename(yyvsp[-1].ttype), NULL_TREE, yyvsp[-3].itype); ; break;} ! case 169: ! #line 1053 "parse.y" { yyval.ttype = build_new (NULL_TREE, groktypename(yyvsp[-2].ttype), yyvsp[0].ttype, yyvsp[-4].itype); ; break;} ! case 170: ! #line 1055 "parse.y" { yyval.ttype = build_new (yyvsp[-3].ttype, groktypename(yyvsp[-1].ttype), NULL_TREE, yyvsp[-4].itype); ; break;} ! case 171: ! #line 1057 "parse.y" { yyval.ttype = build_new (yyvsp[-4].ttype, groktypename(yyvsp[-2].ttype), yyvsp[0].ttype, yyvsp[-5].itype); ; break;} ! case 172: ! #line 1060 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, NULL_TREE, 0, yyvsp[-1].itype); ; break;} ! case 173: ! #line 1062 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, NULL_TREE, 1, yyvsp[-3].itype); if (yychar == YYEMPTY) --- 4505,4559 ---- yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ; break;} ! case 164: ! #line 1041 "parse.y" { yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ; break;} ! case 165: ! #line 1043 "parse.y" { yyval.ttype = grok_alignof (yyvsp[0].ttype); ; break;} ! case 166: ! #line 1045 "parse.y" { yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ; break;} ! case 167: ! #line 1050 "parse.y" { yyval.ttype = build_new (NULL_TREE, yyvsp[0].ttype, NULL_TREE, yyvsp[-1].itype); ; break;} ! case 168: ! #line 1052 "parse.y" { yyval.ttype = build_new (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-2].itype); ; break;} ! case 169: ! #line 1054 "parse.y" { yyval.ttype = build_new (yyvsp[-1].ttype, yyvsp[0].ttype, NULL_TREE, yyvsp[-2].itype); ; break;} ! case 170: ! #line 1056 "parse.y" { yyval.ttype = build_new (yyvsp[-2].ttype, yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-3].itype); ; break;} ! case 171: ! #line 1058 "parse.y" { yyval.ttype = build_new (NULL_TREE, groktypename(yyvsp[-1].ttype), NULL_TREE, yyvsp[-3].itype); ; break;} ! case 172: ! #line 1061 "parse.y" { yyval.ttype = build_new (NULL_TREE, groktypename(yyvsp[-2].ttype), yyvsp[0].ttype, yyvsp[-4].itype); ; break;} ! case 173: ! #line 1063 "parse.y" { yyval.ttype = build_new (yyvsp[-3].ttype, groktypename(yyvsp[-1].ttype), NULL_TREE, yyvsp[-4].itype); ; break;} ! case 174: ! #line 1065 "parse.y" { yyval.ttype = build_new (yyvsp[-4].ttype, groktypename(yyvsp[-2].ttype), yyvsp[0].ttype, yyvsp[-5].itype); ; break;} ! case 175: ! #line 1068 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, NULL_TREE, 0, yyvsp[-1].itype); ; break;} ! case 176: ! #line 1070 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, NULL_TREE, 1, yyvsp[-3].itype); if (yychar == YYEMPTY) *************** *** 4522,4527 **** yychar = YYLEX; ; break;} ! case 174: ! #line 1066 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, yyvsp[-2].ttype, 2, yyvsp[-4].itype); if (yychar == YYEMPTY) --- 4560,4565 ---- yychar = YYLEX; ; break;} ! case 177: ! #line 1074 "parse.y" { yyval.ttype = delete_sanity (yyvsp[0].ttype, yyvsp[-2].ttype, 2, yyvsp[-4].itype); if (yychar == YYEMPTY) *************** *** 4528,4537 **** yychar = YYLEX; ; break;} ! case 175: ! #line 1073 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 176: ! #line 1075 "parse.y" { yyval.ttype = yyvsp[-1].ttype; --- 4566,4575 ---- yychar = YYLEX; ; break;} ! case 178: ! #line 1081 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 179: ! #line 1083 "parse.y" { yyval.ttype = yyvsp[-1].ttype; *************** *** 4539,4552 **** ; break;} ! case 177: ! #line 1083 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 178: ! #line 1085 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 179: ! #line 1087 "parse.y" { cp_error ("`%T' is not a valid expression", yyvsp[-1].ttype); --- 4577,4590 ---- ; break;} ! case 180: ! #line 1091 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 181: ! #line 1093 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 182: ! #line 1095 "parse.y" { cp_error ("`%T' is not a valid expression", yyvsp[-1].ttype); *************** *** 4554,4559 **** ; break;} ! case 180: ! #line 1095 "parse.y" { if (flag_ansi) --- 4592,4597 ---- ; break;} ! case 183: ! #line 1103 "parse.y" { if (flag_ansi) *************** *** 4562,4567 **** ; break;} ! case 181: ! #line 1105 "parse.y" { yyvsp[-1].ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, void_list_node); TREE_PARMLIST (yyvsp[-1].ttype) = 1; --- 4600,4605 ---- ; break;} ! case 184: ! #line 1113 "parse.y" { yyvsp[-1].ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, void_list_node); TREE_PARMLIST (yyvsp[-1].ttype) = 1; *************** *** 4569,4574 **** NULL_TREE); ; break;} ! case 182: ! #line 1110 "parse.y" { yyvsp[-1].ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, void_list_node); TREE_PARMLIST (yyvsp[-1].ttype) = 1; --- 4607,4612 ---- NULL_TREE); ; break;} ! case 185: ! #line 1118 "parse.y" { yyvsp[-1].ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, void_list_node); TREE_PARMLIST (yyvsp[-1].ttype) = 1; *************** *** 4575,4584 **** yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 184: ! #line 1118 "parse.y" { yyval.ttype = reparse_absdcl_as_casts (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 185: ! #line 1120 "parse.y" { tree init = build_nt (CONSTRUCTOR, NULL_TREE, --- 4613,4622 ---- yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-1].ttype, NULL_TREE); ; break;} ! case 187: ! #line 1126 "parse.y" { yyval.ttype = reparse_absdcl_as_casts (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 188: ! #line 1128 "parse.y" { tree init = build_nt (CONSTRUCTOR, NULL_TREE, *************** *** 4592,4605 **** ; break;} ! case 187: ! #line 1135 "parse.y" { yyval.ttype = build_headof (yyvsp[-1].ttype); ; break;} ! case 188: ! #line 1137 "parse.y" { yyval.ttype = build_classof (yyvsp[-1].ttype); ; break;} ! case 189: ! #line 1139 "parse.y" { if (is_aggr_typedef (yyvsp[-1].ttype, 1)) { --- 4630,4643 ---- ; break;} ! case 190: ! #line 1143 "parse.y" { yyval.ttype = build_headof (yyvsp[-1].ttype); ; break;} ! case 191: ! #line 1145 "parse.y" { yyval.ttype = build_classof (yyvsp[-1].ttype); ; break;} ! case 192: ! #line 1147 "parse.y" { if (is_aggr_typedef (yyvsp[-1].ttype, 1)) { *************** *** 4617,4706 **** ; break;} - case 191: - #line 1159 "parse.y" - { yyval.ttype = build_x_binary_op (MEMBER_REF, yyval.ttype, yyvsp[0].ttype); ; - break;} - case 192: - #line 1161 "parse.y" - { yyval.ttype = build_m_component_ref (yyval.ttype, yyvsp[0].ttype); ; - break;} - case 193: - #line 1163 "parse.y" - { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; - break;} case 194: ! #line 1165 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 195: ! #line 1167 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 196: ! #line 1169 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 197: ! #line 1171 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 198: ! #line 1173 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 199: ! #line 1175 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 200: ! #line 1177 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 201: - #line 1179 "parse.y" - { yyval.ttype = build_x_binary_op (LT_EXPR, yyval.ttype, yyvsp[0].ttype); ; - break;} - case 202: #line 1181 "parse.y" ! { yyval.ttype = build_x_binary_op (GT_EXPR, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 203: #line 1183 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 204: #line 1185 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 205: #line 1187 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 206: #line 1189 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 207: ! #line 1191 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 208: ! #line 1193 "parse.y" ! { yyval.ttype = build_x_binary_op (TRUTH_ANDIF_EXPR, yyval.ttype, yyvsp[0].ttype); ; break;} case 209: ! #line 1195 "parse.y" ! { yyval.ttype = build_x_binary_op (TRUTH_ORIF_EXPR, yyval.ttype, yyvsp[0].ttype); ; break;} case 210: ! #line 1197 "parse.y" ! { yyval.ttype = build_x_conditional_expr (yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} case 211: ! #line 1199 "parse.y" ! { yyval.ttype = build_modify_expr (yyval.ttype, NOP_EXPR, yyvsp[0].ttype); ; break;} case 212: ! #line 1201 "parse.y" { register tree rval; if ((rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, yyval.ttype, yyvsp[0].ttype, --- 4655,4744 ---- ; break;} case 194: ! #line 1167 "parse.y" ! { yyval.ttype = build_x_binary_op (MEMBER_REF, yyval.ttype, yyvsp[0].ttype); ; break;} case 195: ! #line 1169 "parse.y" ! { yyval.ttype = build_m_component_ref (yyval.ttype, yyvsp[0].ttype); ; break;} case 196: ! #line 1171 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 197: ! #line 1173 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 198: ! #line 1175 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 199: ! #line 1177 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 200: ! #line 1179 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 201: #line 1181 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 202: #line 1183 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 203: #line 1185 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 204: #line 1187 "parse.y" ! { yyval.ttype = build_x_binary_op (LT_EXPR, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 205: #line 1189 "parse.y" + { yyval.ttype = build_x_binary_op (GT_EXPR, yyval.ttype, yyvsp[0].ttype); ; + break;} + case 206: + #line 1191 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 207: ! #line 1193 "parse.y" { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 208: ! #line 1195 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 209: ! #line 1197 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 210: ! #line 1199 "parse.y" ! { yyval.ttype = build_x_binary_op (yyvsp[-1].code, yyval.ttype, yyvsp[0].ttype); ; break;} case 211: ! #line 1201 "parse.y" ! { yyval.ttype = build_x_binary_op (TRUTH_ANDIF_EXPR, yyval.ttype, yyvsp[0].ttype); ; break;} case 212: ! #line 1203 "parse.y" ! { yyval.ttype = build_x_binary_op (TRUTH_ORIF_EXPR, yyval.ttype, yyvsp[0].ttype); ; ! break;} ! case 213: ! #line 1205 "parse.y" ! { yyval.ttype = build_x_conditional_expr (yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; ! break;} ! case 214: ! #line 1207 "parse.y" ! { yyval.ttype = build_modify_expr (yyval.ttype, NOP_EXPR, yyvsp[0].ttype); ; ! break;} ! case 215: ! #line 1209 "parse.y" { register tree rval; if ((rval = build_opfncall (MODIFY_EXPR, LOOKUP_NORMAL, yyval.ttype, yyvsp[0].ttype, *************** *** 4710,4740 **** yyval.ttype = build_modify_expr (yyval.ttype, yyvsp[-1].code, yyvsp[0].ttype); ; break;} ! case 213: ! #line 1208 "parse.y" { yyval.ttype = build_throw (NULL_TREE); ; break;} ! case 214: ! #line 1210 "parse.y" { yyval.ttype = build_throw (yyvsp[0].ttype); ; break;} ! case 215: ! #line 1228 "parse.y" { yyval.ttype = build_parse_node (BIT_NOT_EXPR, yyvsp[0].ttype); ; break;} ! case 223: ! #line 1243 "parse.y" { yyval.ttype = build_parse_node (INDIRECT_REF, yyvsp[0].ttype); ; break;} ! case 224: ! #line 1245 "parse.y" { yyval.ttype = build_parse_node (ADDR_EXPR, yyvsp[0].ttype); ; break;} ! case 227: ! #line 1252 "parse.y" { push_nested_class (TREE_TYPE (OP0 (yyval.ttype)), 3); TREE_COMPLEXITY (yyval.ttype) = current_class_depth; ; break;} ! case 228: ! #line 1258 "parse.y" { if (TREE_CODE (yyval.ttype) == BIT_NOT_EXPR) --- 4748,4786 ---- yyval.ttype = build_modify_expr (yyval.ttype, yyvsp[-1].code, yyvsp[0].ttype); ; break;} ! case 216: ! #line 1216 "parse.y" { yyval.ttype = build_throw (NULL_TREE); ; break;} ! case 217: ! #line 1218 "parse.y" { yyval.ttype = build_throw (yyvsp[0].ttype); ; break;} ! case 218: ! #line 1236 "parse.y" { yyval.ttype = build_parse_node (BIT_NOT_EXPR, yyvsp[0].ttype); ; break;} ! case 226: ! #line 1251 "parse.y" { yyval.ttype = build_parse_node (INDIRECT_REF, yyvsp[0].ttype); ; break;} ! case 227: ! #line 1253 "parse.y" { yyval.ttype = build_parse_node (ADDR_EXPR, yyvsp[0].ttype); ; break;} ! case 228: ! #line 1255 "parse.y" ! { yyval.ttype = yyvsp[-1].ttype; ; ! break;} ! case 231: ! #line 1262 "parse.y" { push_nested_class (TREE_TYPE (OP0 (yyval.ttype)), 3); TREE_COMPLEXITY (yyval.ttype) = current_class_depth; ; break;} ! case 232: ! #line 1265 "parse.y" ! { yyval.ttype = finish_decl_parsing (yyvsp[-1].ttype); ; ! break;} ! case 233: ! #line 1270 "parse.y" { if (TREE_CODE (yyval.ttype) == BIT_NOT_EXPR) *************** *** 4756,4773 **** ; break;} ! case 231: ! #line 1279 "parse.y" { yyval.ttype = combine_strings (yyval.ttype); ; break;} ! case 232: ! #line 1281 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 233: ! #line 1283 "parse.y" { yyval.ttype = error_mark_node; ; break;} ! case 234: ! #line 1285 "parse.y" { if (current_function_decl == 0) { --- 4802,4819 ---- ; break;} ! case 236: ! #line 1291 "parse.y" { yyval.ttype = combine_strings (yyval.ttype); ; break;} ! case 237: ! #line 1293 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 238: ! #line 1295 "parse.y" { yyval.ttype = error_mark_node; ; break;} ! case 239: ! #line 1297 "parse.y" { if (current_function_decl == 0) { *************** *** 4778,4783 **** yyval.ttype = expand_start_stmt_expr (); ; break;} ! case 235: ! #line 1293 "parse.y" { tree rtl_exp; if (flag_ansi) --- 4824,4829 ---- yyval.ttype = expand_start_stmt_expr (); ; break;} ! case 240: ! #line 1305 "parse.y" { tree rtl_exp; if (flag_ansi) *************** *** 4801,4806 **** ; break;} ! case 236: ! #line 1314 "parse.y" { /* [eichin:19911016.1902EST] */ yyval.ttype = build_x_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype, current_class_decl); --- 4847,4852 ---- ; break;} ! case 241: ! #line 1326 "parse.y" { /* [eichin:19911016.1902EST] */ yyval.ttype = build_x_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype, current_class_decl); *************** *** 4809,4814 **** ; break;} ! case 237: ! #line 1318 "parse.y" { if (TREE_CODE (yyvsp[-1].ttype) == CALL_EXPR --- 4855,4860 ---- ; break;} ! case 242: ! #line 1330 "parse.y" { if (TREE_CODE (yyvsp[-1].ttype) == CALL_EXPR *************** *** 4819,4824 **** ; break;} ! case 238: ! #line 1326 "parse.y" { yyval.ttype = build_x_function_call (yyval.ttype, NULL_TREE, current_class_decl); --- 4865,4870 ---- ; break;} ! case 243: ! #line 1338 "parse.y" { yyval.ttype = build_x_function_call (yyval.ttype, NULL_TREE, current_class_decl); *************** *** 4828,4837 **** ; break;} ! case 239: ! #line 1333 "parse.y" { yyval.ttype = grok_array_decl (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 240: ! #line 1335 "parse.y" { /* If we get an OFFSET_REF, turn it into what it really means (e.g., a COMPONENT_REF). This way if we've got, --- 4874,4883 ---- ; break;} ! case 244: ! #line 1345 "parse.y" { yyval.ttype = grok_array_decl (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 245: ! #line 1347 "parse.y" { /* If we get an OFFSET_REF, turn it into what it really means (e.g., a COMPONENT_REF). This way if we've got, *************** *** 4843,4848 **** yyval.ttype = build_x_unary_op (POSTINCREMENT_EXPR, yyval.ttype); ; break;} ! case 241: ! #line 1344 "parse.y" { if (TREE_CODE (yyval.ttype) == OFFSET_REF) yyval.ttype = resolve_offset_ref (yyval.ttype); --- 4889,4894 ---- yyval.ttype = build_x_unary_op (POSTINCREMENT_EXPR, yyval.ttype); ; break;} ! case 246: ! #line 1356 "parse.y" { if (TREE_CODE (yyval.ttype) == OFFSET_REF) yyval.ttype = resolve_offset_ref (yyval.ttype); *************** *** 4849,4854 **** yyval.ttype = build_x_unary_op (POSTDECREMENT_EXPR, yyval.ttype); ; break;} ! case 242: ! #line 1349 "parse.y" { if (current_class_decl) { --- 4895,4900 ---- yyval.ttype = build_x_unary_op (POSTDECREMENT_EXPR, yyval.ttype); ; break;} ! case 247: ! #line 1361 "parse.y" { if (current_class_decl) { *************** *** 4874,4879 **** ; break;} ! case 243: ! #line 1372 "parse.y" { tree type; --- 4920,4925 ---- ; break;} ! case 248: ! #line 1384 "parse.y" { tree type; *************** *** 4920,4954 **** ; break;} ! case 245: ! #line 1417 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_dynamic_cast (type, yyvsp[-1].ttype); ; break;} ! case 246: ! #line 1420 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_static_cast (type, yyvsp[-1].ttype); ; break;} ! case 247: ! #line 1423 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_reinterpret_cast (type, yyvsp[-1].ttype); ; break;} ! case 248: ! #line 1426 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_const_cast (type, yyvsp[-1].ttype); ; break;} ! case 249: ! #line 1429 "parse.y" { yyval.ttype = build_typeid (yyvsp[-1].ttype); ; break;} ! case 250: ! #line 1431 "parse.y" { tree type = groktypename (yyvsp[-1].ttype); yyval.ttype = get_typeid (type); ; break;} ! case 251: ! #line 1434 "parse.y" { do_scoped_id: --- 4966,5000 ---- ; break;} ! case 250: ! #line 1429 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_dynamic_cast (type, yyvsp[-1].ttype); ; break;} ! case 251: ! #line 1432 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_static_cast (type, yyvsp[-1].ttype); ; break;} ! case 252: ! #line 1435 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_reinterpret_cast (type, yyvsp[-1].ttype); ; break;} ! case 253: ! #line 1438 "parse.y" { tree type = groktypename (yyvsp[-4].ttype); yyval.ttype = build_const_cast (type, yyvsp[-1].ttype); ; break;} ! case 254: ! #line 1441 "parse.y" { yyval.ttype = build_typeid (yyvsp[-1].ttype); ; break;} ! case 255: ! #line 1443 "parse.y" { tree type = groktypename (yyvsp[-1].ttype); yyval.ttype = get_typeid (type); ; break;} ! case 256: ! #line 1446 "parse.y" { do_scoped_id: *************** *** 4990,4995 **** ; break;} ! case 252: ! #line 1473 "parse.y" { got_scope = NULL_TREE; --- 5036,5041 ---- ; break;} ! case 257: ! #line 1485 "parse.y" { got_scope = NULL_TREE; *************** *** 4999,5024 **** ; break;} ! case 253: ! #line 1480 "parse.y" { yyval.ttype = build_offset_ref (OP0 (yyval.ttype), OP1 (yyval.ttype)); ; break;} ! case 254: ! #line 1482 "parse.y" { yyval.ttype = build_member_call (OP0 (yyval.ttype), OP1 (yyval.ttype), yyvsp[-1].ttype); ; break;} ! case 255: ! #line 1484 "parse.y" { yyval.ttype = build_member_call (OP0 (yyval.ttype), OP1 (yyval.ttype), NULL_TREE); ; break;} ! case 256: ! #line 1486 "parse.y" { yyval.ttype = build_component_ref (yyval.ttype, yyvsp[0].ttype, NULL_TREE, 1); ; break;} ! case 257: ! #line 1488 "parse.y" { yyval.ttype = build_object_ref (yyval.ttype, OP0 (yyvsp[0].ttype), OP1 (yyvsp[0].ttype)); ; break;} ! case 258: ! #line 1490 "parse.y" { #if 0 --- 5045,5070 ---- ; break;} ! case 258: ! #line 1492 "parse.y" { yyval.ttype = build_offset_ref (OP0 (yyval.ttype), OP1 (yyval.ttype)); ; break;} ! case 259: ! #line 1494 "parse.y" { yyval.ttype = build_member_call (OP0 (yyval.ttype), OP1 (yyval.ttype), yyvsp[-1].ttype); ; break;} ! case 260: ! #line 1496 "parse.y" { yyval.ttype = build_member_call (OP0 (yyval.ttype), OP1 (yyval.ttype), NULL_TREE); ; break;} ! case 261: ! #line 1498 "parse.y" { yyval.ttype = build_component_ref (yyval.ttype, yyvsp[0].ttype, NULL_TREE, 1); ; break;} ! case 262: ! #line 1500 "parse.y" { yyval.ttype = build_object_ref (yyval.ttype, OP0 (yyvsp[0].ttype), OP1 (yyvsp[0].ttype)); ; break;} ! case 263: ! #line 1502 "parse.y" { #if 0 *************** *** 5036,5041 **** ; break;} ! case 259: ! #line 1505 "parse.y" { #if 0 --- 5082,5087 ---- ; break;} ! case 264: ! #line 1517 "parse.y" { #if 0 *************** *** 5053,5058 **** ; break;} ! case 260: ! #line 1520 "parse.y" { if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 (yyvsp[-3].ttype)))) --- 5099,5104 ---- ; break;} ! case 265: ! #line 1532 "parse.y" { if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 (yyvsp[-3].ttype)))) *************** *** 5066,5071 **** ; break;} ! case 261: ! #line 1531 "parse.y" { if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 (yyvsp[-1].ttype)))) --- 5112,5117 ---- ; break;} ! case 266: ! #line 1543 "parse.y" { if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (OP0 (yyvsp[-1].ttype)))) *************** *** 5079,5084 **** ; break;} ! case 262: ! #line 1543 "parse.y" { if (TREE_CODE (TREE_TYPE (yyvsp[-3].ttype)) --- 5125,5130 ---- ; break;} ! case 267: ! #line 1555 "parse.y" { if (TREE_CODE (TREE_TYPE (yyvsp[-3].ttype)) *************** *** 5085,5093 **** != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (yyvsp[-1].ttype)))) cp_error ("`%E' is not of type `%T'", yyvsp[-3].ttype, yyvsp[-1].ttype); ! yyval.ttype = void_zero_node; ; break;} ! case 263: ! #line 1550 "parse.y" { if (yyvsp[-4].ttype != yyvsp[-1].ttype) --- 5131,5139 ---- != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (yyvsp[-1].ttype)))) cp_error ("`%E' is not of type `%T'", yyvsp[-3].ttype, yyvsp[-1].ttype); ! yyval.ttype = convert (void_type_node, yyvsp[-3].ttype); ; break;} ! case 268: ! #line 1562 "parse.y" { if (yyvsp[-4].ttype != yyvsp[-1].ttype) *************** *** 5096,5132 **** != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (yyvsp[-4].ttype)))) cp_error ("`%E' is not of type `%T'", yyvsp[-5].ttype, yyvsp[-4].ttype); ! yyval.ttype = void_zero_node; ; break;} ! case 264: ! #line 1599 "parse.y" { yyval.itype = 0; ; break;} ! case 265: ! #line 1601 "parse.y" { got_scope = NULL_TREE; yyval.itype = 1; ; break;} ! case 266: ! #line 1605 "parse.y" { yyval.itype = 0; ; break;} ! case 267: ! #line 1607 "parse.y" { got_scope = NULL_TREE; yyval.itype = 1; ; break;} ! case 268: ! #line 1612 "parse.y" { yyval.ttype = true_node; ; break;} ! case 269: ! #line 1614 "parse.y" { yyval.ttype = false_node; ; break;} ! case 271: ! #line 1621 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 272: ! #line 1626 "parse.y" { if (! current_function_parms_stored) --- 5142,5178 ---- != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (yyvsp[-4].ttype)))) cp_error ("`%E' is not of type `%T'", yyvsp[-5].ttype, yyvsp[-4].ttype); ! yyval.ttype = convert (void_type_node, yyvsp[-5].ttype); ; break;} ! case 269: ! #line 1611 "parse.y" { yyval.itype = 0; ; break;} ! case 270: ! #line 1613 "parse.y" { got_scope = NULL_TREE; yyval.itype = 1; ; break;} ! case 271: ! #line 1617 "parse.y" { yyval.itype = 0; ; break;} ! case 272: ! #line 1619 "parse.y" { got_scope = NULL_TREE; yyval.itype = 1; ; break;} ! case 273: ! #line 1624 "parse.y" { yyval.ttype = true_node; ; break;} ! case 274: ! #line 1626 "parse.y" { yyval.ttype = false_node; ; break;} ! case 276: ! #line 1633 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 277: ! #line 1638 "parse.y" { if (! current_function_parms_stored) *************** *** 5139,5144 **** ; break;} ! case 274: ! #line 1639 "parse.y" { yyval.ttype = build_x_arrow (yyval.ttype); --- 5185,5190 ---- ; break;} ! case 279: ! #line 1651 "parse.y" { yyval.ttype = build_x_arrow (yyval.ttype); *************** *** 5145,5150 **** ; break;} ! case 275: ! #line 1647 "parse.y" { tree d = get_decl_list (yyvsp[-2].ttype); int yes = suspend_momentary (); --- 5191,5196 ---- ; break;} ! case 280: ! #line 1659 "parse.y" { tree d = get_decl_list (yyvsp[-2].ttype); int yes = suspend_momentary (); *************** *** 5156,5161 **** ; break;} ! case 276: ! #line 1656 "parse.y" { tree d = yyvsp[-2].ttype; int yes = suspend_momentary (); --- 5202,5207 ---- ; break;} ! case 281: ! #line 1668 "parse.y" { tree d = yyvsp[-2].ttype; int yes = suspend_momentary (); *************** *** 5166,5171 **** ; break;} ! case 277: ! #line 1664 "parse.y" { resume_momentary (yyvsp[-1].itype); --- 5212,5217 ---- ; break;} ! case 282: ! #line 1676 "parse.y" { resume_momentary (yyvsp[-1].itype); *************** *** 5174,5179 **** ; break;} ! case 278: ! #line 1670 "parse.y" { resume_momentary (yyvsp[-1].itype); --- 5220,5225 ---- ; break;} ! case 283: ! #line 1682 "parse.y" { resume_momentary (yyvsp[-1].itype); *************** *** 5181,5190 **** ; break;} ! case 279: ! #line 1675 "parse.y" { resume_momentary (yyvsp[-1].itype); ; break;} ! case 280: ! #line 1677 "parse.y" { shadow_tag (yyvsp[-1].ttype); --- 5227,5236 ---- ; break;} ! case 284: ! #line 1687 "parse.y" { resume_momentary (yyvsp[-1].itype); ; break;} ! case 285: ! #line 1689 "parse.y" { shadow_tag (yyvsp[-1].ttype); *************** *** 5192,5252 **** ; break;} ! case 281: ! #line 1682 "parse.y" { warning ("empty declaration"); ; break;} ! case 284: ! #line 1696 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), NULL_TREE); ; break;} ! case 285: ! #line 1699 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), NULL_TREE); ; break;} ! case 286: ! #line 1706 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 287: ! #line 1708 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 288: ! #line 1710 "parse.y" { yyval.ttype = build_decl_list (get_decl_list (yyval.ttype), yyvsp[0].ttype); ; break;} ! case 289: ! #line 1712 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 290: ! #line 1714 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 293: ! #line 1727 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 294: ! #line 1729 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 295: ! #line 1731 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 296: ! #line 1733 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 297: ! #line 1735 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-2].ttype, chainon (yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype))); ; break;} ! case 298: ! #line 1741 "parse.y" { if (extra_warnings) warning ("`%s' is not at beginning of declaration", --- 5238,5298 ---- ; break;} ! case 286: ! #line 1694 "parse.y" { warning ("empty declaration"); ; break;} ! case 289: ! #line 1708 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, empty_parms (), NULL_TREE); ; break;} ! case 290: ! #line 1711 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), NULL_TREE); ; break;} ! case 291: ! #line 1718 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 292: ! #line 1720 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 293: ! #line 1722 "parse.y" { yyval.ttype = build_decl_list (get_decl_list (yyval.ttype), yyvsp[0].ttype); ; break;} ! case 294: ! #line 1724 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 295: ! #line 1726 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 298: ! #line 1739 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 299: ! #line 1741 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 300: ! #line 1743 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 301: ! #line 1745 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 302: ! #line 1747 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-2].ttype, chainon (yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype))); ; break;} ! case 303: ! #line 1753 "parse.y" { if (extra_warnings) warning ("`%s' is not at beginning of declaration", *************** *** 5254,5263 **** yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 299: ! #line 1746 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 300: ! #line 1748 "parse.y" { if (extra_warnings) warning ("`%s' is not at beginning of declaration", --- 5300,5309 ---- yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 304: ! #line 1758 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 305: ! #line 1760 "parse.y" { if (extra_warnings) warning ("`%s' is not at beginning of declaration", *************** *** 5265,5283 **** yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 301: ! #line 1760 "parse.y" { TREE_STATIC (yyval.ttype) = 1; ; break;} ! case 302: ! #line 1762 "parse.y" { yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ; break;} ! case 303: ! #line 1764 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); TREE_STATIC (yyval.ttype) = 1; ; break;} ! case 304: ! #line 1767 "parse.y" { if (extra_warnings && TREE_STATIC (yyval.ttype)) warning ("`%s' is not at beginning of declaration", --- 5311,5329 ---- yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 306: ! #line 1772 "parse.y" { TREE_STATIC (yyval.ttype) = 1; ; break;} ! case 307: ! #line 1774 "parse.y" { yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ; break;} ! case 308: ! #line 1776 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); TREE_STATIC (yyval.ttype) = 1; ; break;} ! case 309: ! #line 1779 "parse.y" { if (extra_warnings && TREE_STATIC (yyval.ttype)) warning ("`%s' is not at beginning of declaration", *************** *** 5286,5315 **** TREE_STATIC (yyval.ttype) = TREE_STATIC (yyvsp[-1].ttype); ; break;} ! case 305: ! #line 1783 "parse.y" { yyval.ttype = get_decl_list (yyval.ttype); ; break;} ! case 306: ! #line 1785 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 307: ! #line 1787 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 308: ! #line 1789 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 309: ! #line 1794 "parse.y" { yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 310: ! #line 1796 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 314: ! #line 1807 "parse.y" { yyval.ttype = TREE_TYPE (yyvsp[-1].ttype); if (flag_ansi) --- 5332,5361 ---- TREE_STATIC (yyval.ttype) = TREE_STATIC (yyvsp[-1].ttype); ; break;} ! case 310: ! #line 1795 "parse.y" { yyval.ttype = get_decl_list (yyval.ttype); ; break;} ! case 311: ! #line 1797 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 312: ! #line 1799 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 313: ! #line 1801 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[-1].ttype, chainon (yyvsp[0].ttype, yyval.ttype)); ; break;} ! case 314: ! #line 1806 "parse.y" { yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 315: ! #line 1808 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 319: ! #line 1819 "parse.y" { yyval.ttype = TREE_TYPE (yyvsp[-1].ttype); if (flag_ansi) *************** *** 5316,5321 **** pedwarn ("ANSI C++ forbids `typeof'"); ; break;} ! case 315: ! #line 1811 "parse.y" { yyval.ttype = groktypename (yyvsp[-1].ttype); if (flag_ansi) --- 5362,5367 ---- pedwarn ("ANSI C++ forbids `typeof'"); ; break;} ! case 320: ! #line 1823 "parse.y" { yyval.ttype = groktypename (yyvsp[-1].ttype); if (flag_ansi) *************** *** 5322,5327 **** pedwarn ("ANSI C++ forbids `typeof'"); ; break;} ! case 316: ! #line 1815 "parse.y" { tree type = TREE_TYPE (yyvsp[-1].ttype); --- 5368,5373 ---- pedwarn ("ANSI C++ forbids `typeof'"); ; break;} ! case 321: ! #line 1827 "parse.y" { tree type = TREE_TYPE (yyvsp[-1].ttype); *************** *** 5338,5343 **** ; break;} ! case 317: ! #line 1829 "parse.y" { tree type = groktypename (yyvsp[-1].ttype); --- 5384,5389 ---- ; break;} ! case 322: ! #line 1841 "parse.y" { tree type = groktypename (yyvsp[-1].ttype); *************** *** 5354,5367 **** ; break;} ! case 327: ! #line 1868 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 328: ! #line 1870 "parse.y" { if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype); yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 329: ! #line 1875 "parse.y" { current_declspecs = yyvsp[-5].ttype; if (TREE_CODE (current_declspecs) != TREE_LIST) --- 5400,5413 ---- ; break;} ! case 332: ! #line 1880 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 333: ! #line 1882 "parse.y" { if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype); yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 334: ! #line 1887 "parse.y" { current_declspecs = yyvsp[-5].ttype; if (TREE_CODE (current_declspecs) != TREE_LIST) *************** *** 5378,5388 **** cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 330: ! #line 1890 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 331: ! #line 1893 "parse.y" { tree d; current_declspecs = yyvsp[-4].ttype; --- 5424,5434 ---- cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 335: ! #line 1902 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 336: ! #line 1905 "parse.y" { tree d; current_declspecs = yyvsp[-4].ttype; *************** *** 5401,5415 **** finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 332: ! #line 1912 "parse.y" { yyval.ttype = start_decl (yyvsp[-4].ttype, current_declspecs, 1, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 333: ! #line 1916 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); ; break;} ! case 334: ! #line 1918 "parse.y" { yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 0, yyvsp[-2].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); --- 5447,5461 ---- finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 337: ! #line 1924 "parse.y" { yyval.ttype = start_decl (yyvsp[-4].ttype, current_declspecs, 1, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 338: ! #line 1928 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); ; break;} ! case 339: ! #line 1930 "parse.y" { yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 0, yyvsp[-2].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); *************** *** 5416,5421 **** finish_decl (yyval.ttype, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 335: ! #line 1925 "parse.y" { current_declspecs = yyvsp[-5].ttype; yyvsp[0].itype = suspend_momentary (); --- 5462,5467 ---- finish_decl (yyval.ttype, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 340: ! #line 1937 "parse.y" { current_declspecs = yyvsp[-5].ttype; yyvsp[0].itype = suspend_momentary (); *************** *** 5423,5433 **** cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 336: ! #line 1931 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 337: ! #line 1934 "parse.y" { tree d; current_declspecs = yyvsp[-4].ttype; --- 5469,5479 ---- cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 341: ! #line 1943 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 342: ! #line 1946 "parse.y" { tree d; current_declspecs = yyvsp[-4].ttype; *************** *** 5437,5442 **** finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 338: ! #line 1944 "parse.y" { current_declspecs = NULL_TREE; yyvsp[0].itype = suspend_momentary (); --- 5483,5488 ---- finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 343: ! #line 1956 "parse.y" { current_declspecs = NULL_TREE; yyvsp[0].itype = suspend_momentary (); *************** *** 5444,5454 **** cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 339: ! #line 1950 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 340: ! #line 1953 "parse.y" { tree d; current_declspecs = NULL_TREE; --- 5490,5500 ---- cplus_decl_attributes (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 344: ! #line 1962 "parse.y" { finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype, 0); yyval.itype = yyvsp[-2].itype; ; break;} ! case 345: ! #line 1965 "parse.y" { tree d; current_declspecs = NULL_TREE; *************** *** 5458,5567 **** finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 341: ! #line 1965 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 342: ! #line 1967 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 343: ! #line 1972 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 344: ! #line 1974 "parse.y" { yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 345: ! #line 1979 "parse.y" { yyval.ttype = yyvsp[-2].ttype; ; break;} ! case 346: ! #line 1984 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 347: ! #line 1986 "parse.y" { yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 348: ! #line 1991 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 349: ! #line 1993 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 350: ! #line 1995 "parse.y" { yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, build_tree_list (NULL_TREE, yyvsp[-1].ttype)); ; break;} ! case 351: ! #line 1997 "parse.y" { yyval.ttype = tree_cons (yyvsp[-5].ttype, NULL_TREE, tree_cons (NULL_TREE, yyvsp[-3].ttype, yyvsp[-1].ttype)); ; break;} ! case 352: ! #line 1999 "parse.y" { yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 357: ! #line 2015 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 358: ! #line 2017 "parse.y" { yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 360: ! #line 2023 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 361: ! #line 2026 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-1].ttype)); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 362: ! #line 2029 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 363: ! #line 2032 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 364: ! #line 2039 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 365: ! #line 2041 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 366: ! #line 2044 "parse.y" { yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 367: ! #line 2046 "parse.y" { yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 368: ! #line 2048 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 369: ! #line 2050 "parse.y" { yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 370: ! #line 2055 "parse.y" { yyvsp[0].itype = suspend_momentary (); yyval.ttype = start_enum (yyvsp[-1].ttype); ; break;} ! case 371: ! #line 2058 "parse.y" { yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype); resume_momentary ((int) yyvsp[-4].itype); --- 5504,5613 ---- finish_decl (d, NULL_TREE, yyvsp[-1].ttype, 0); ; break;} ! case 346: ! #line 1977 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 347: ! #line 1979 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 348: ! #line 1984 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 349: ! #line 1986 "parse.y" { yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 350: ! #line 1991 "parse.y" { yyval.ttype = yyvsp[-2].ttype; ; break;} ! case 351: ! #line 1996 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 352: ! #line 1998 "parse.y" { yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 353: ! #line 2003 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 354: ! #line 2005 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 355: ! #line 2007 "parse.y" { yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, build_tree_list (NULL_TREE, yyvsp[-1].ttype)); ; break;} ! case 356: ! #line 2009 "parse.y" { yyval.ttype = tree_cons (yyvsp[-5].ttype, NULL_TREE, tree_cons (NULL_TREE, yyvsp[-3].ttype, yyvsp[-1].ttype)); ; break;} ! case 357: ! #line 2011 "parse.y" { yyval.ttype = tree_cons (yyvsp[-3].ttype, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 362: ! #line 2027 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 363: ! #line 2029 "parse.y" { yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 365: ! #line 2035 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, NULL_TREE); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 366: ! #line 2038 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-1].ttype)); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 367: ! #line 2041 "parse.y" { yyval.ttype = build_nt (CONSTRUCTOR, NULL_TREE, nreverse (yyvsp[-2].ttype)); TREE_HAS_CONSTRUCTOR (yyval.ttype) = 1; ; break;} ! case 368: ! #line 2044 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 369: ! #line 2051 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 370: ! #line 2053 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 371: ! #line 2056 "parse.y" { yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 372: ! #line 2058 "parse.y" { yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 373: ! #line 2060 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 374: ! #line 2062 "parse.y" { yyval.ttype = tree_cons (yyvsp[-2].ttype, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 375: ! #line 2067 "parse.y" { yyvsp[0].itype = suspend_momentary (); yyval.ttype = start_enum (yyvsp[-1].ttype); ; break;} ! case 376: ! #line 2070 "parse.y" { yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype); resume_momentary ((int) yyvsp[-4].itype); *************** *** 5568,5583 **** check_for_missing_semicolon (yyvsp[-3].ttype); ; break;} ! case 372: ! #line 2062 "parse.y" { yyval.ttype = finish_enum (start_enum (yyvsp[-2].ttype), NULL_TREE); check_for_missing_semicolon (yyval.ttype); ; break;} ! case 373: ! #line 2065 "parse.y" { yyvsp[0].itype = suspend_momentary (); yyval.ttype = start_enum (make_anon_name ()); ; break;} ! case 374: ! #line 2068 "parse.y" { yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype); resume_momentary ((int) yyvsp[-5].itype); --- 5614,5629 ---- check_for_missing_semicolon (yyvsp[-3].ttype); ; break;} ! case 377: ! #line 2074 "parse.y" { yyval.ttype = finish_enum (start_enum (yyvsp[-2].ttype), NULL_TREE); check_for_missing_semicolon (yyval.ttype); ; break;} ! case 378: ! #line 2077 "parse.y" { yyvsp[0].itype = suspend_momentary (); yyval.ttype = start_enum (make_anon_name ()); ; break;} ! case 379: ! #line 2080 "parse.y" { yyval.ttype = finish_enum (yyvsp[-3].ttype, yyvsp[-2].ttype); resume_momentary ((int) yyvsp[-5].itype); *************** *** 5584,5602 **** check_for_missing_semicolon (yyvsp[-3].ttype); ; break;} ! case 375: ! #line 2072 "parse.y" { yyval.ttype = finish_enum (start_enum (make_anon_name()), NULL_TREE); check_for_missing_semicolon (yyval.ttype); ; break;} ! case 376: ! #line 2075 "parse.y" { yyval.ttype = xref_tag (enum_type_node, yyvsp[0].ttype, NULL_TREE, 0); ; break;} ! case 377: ! #line 2077 "parse.y" { yyval.ttype = xref_tag (enum_type_node, yyvsp[0].ttype, NULL_TREE, 0); ; break;} ! case 378: ! #line 2081 "parse.y" { int semi; --- 5630,5648 ---- check_for_missing_semicolon (yyvsp[-3].ttype); ; break;} ! case 380: ! #line 2084 "parse.y" { yyval.ttype = finish_enum (start_enum (make_anon_name()), NULL_TREE); check_for_missing_semicolon (yyval.ttype); ; break;} ! case 381: ! #line 2087 "parse.y" { yyval.ttype = xref_tag (enum_type_node, yyvsp[0].ttype, NULL_TREE, 0); ; break;} ! case 382: ! #line 2089 "parse.y" { yyval.ttype = xref_tag (enum_type_node, yyvsp[0].ttype, NULL_TREE, 0); ; break;} ! case 383: ! #line 2093 "parse.y" { int semi; *************** *** 5650,5655 **** check_for_missing_semicolon (yyval.ttype); ; break;} ! case 379: ! #line 2132 "parse.y" { #if 0 --- 5696,5701 ---- check_for_missing_semicolon (yyval.ttype); ; break;} ! case 384: ! #line 2144 "parse.y" { #if 0 *************** *** 5665,5690 **** ; break;} ! case 383: ! #line 2154 "parse.y" { if (pedantic) pedwarn ("comma at end of enumerator list"); ; break;} ! case 385: ! #line 2159 "parse.y" { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 386: ! #line 2161 "parse.y" { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 387: ! #line 2163 "parse.y" { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 388: ! #line 2165 "parse.y" { error ("no body nor ';' separates two class, struct or union declarations"); ; break;} ! case 389: ! #line 2170 "parse.y" { yyungetc (';', 1); current_aggr = yyval.ttype; yyval.ttype = yyvsp[-1].ttype; --- 5711,5736 ---- ; break;} ! case 388: ! #line 2166 "parse.y" { if (pedantic) pedwarn ("comma at end of enumerator list"); ; break;} ! case 390: ! #line 2171 "parse.y" { error ("storage class specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 391: ! #line 2173 "parse.y" { error ("type specifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 392: ! #line 2175 "parse.y" { error ("type qualifier `%s' not allowed after struct or class", IDENTIFIER_POINTER (yyvsp[0].ttype)); ; break;} ! case 393: ! #line 2177 "parse.y" { error ("no body nor ';' separates two class, struct or union declarations"); ; break;} ! case 394: ! #line 2182 "parse.y" { yyungetc (';', 1); current_aggr = yyval.ttype; yyval.ttype = yyvsp[-1].ttype; *************** *** 5693,5710 **** ; break;} ! case 390: ! #line 2179 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 391: ! #line 2181 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 392: ! #line 2183 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 393: ! #line 2185 "parse.y" { yyungetc ('{', 1); aggr2: --- 5739,5756 ---- ; break;} ! case 395: ! #line 2191 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 396: ! #line 2193 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 397: ! #line 2195 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 398: ! #line 2197 "parse.y" { yyungetc ('{', 1); aggr2: *************** *** 5713,5734 **** overload_template_name (yyval.ttype, 0); ; break;} ! case 394: ! #line 2191 "parse.y" { yyungetc (':', 1); goto aggr2; ; break;} ! case 396: ! #line 2197 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 397: ! #line 2201 "parse.y" { yyval.ttype = xref_tag (current_aggr, yyvsp[0].ttype, NULL_TREE, 1); ; break;} ! case 398: ! #line 2204 "parse.y" { yyval.ttype = xref_defn_tag (current_aggr, yyvsp[0].ttype, NULL_TREE); ; break;} ! case 399: ! #line 2209 "parse.y" { if (yyvsp[0].ttype) --- 5759,5780 ---- overload_template_name (yyval.ttype, 0); ; break;} ! case 399: ! #line 2203 "parse.y" { yyungetc (':', 1); goto aggr2; ; break;} ! case 401: ! #line 2209 "parse.y" { current_aggr = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 402: ! #line 2213 "parse.y" { yyval.ttype = xref_tag (current_aggr, yyvsp[0].ttype, NULL_TREE, 1); ; break;} ! case 403: ! #line 2216 "parse.y" { yyval.ttype = xref_defn_tag (current_aggr, yyvsp[0].ttype, NULL_TREE); ; break;} ! case 404: ! #line 2221 "parse.y" { if (yyvsp[0].ttype) *************** *** 5738,5743 **** ; break;} ! case 400: ! #line 2218 "parse.y" { if (yyvsp[0].ttype) --- 5784,5789 ---- ; break;} ! case 405: ! #line 2230 "parse.y" { if (yyvsp[0].ttype) *************** *** 5747,5773 **** ; break;} ! case 401: ! #line 2227 "parse.y" { yyval.ttype = xref_tag (yyval.ttype, make_anon_name (), NULL_TREE, 0); yyungetc ('{', 1); ; break;} ! case 404: ! #line 2235 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 405: ! #line 2237 "parse.y" { yyungetc(':', 1); yyval.ttype = NULL_TREE; ; break;} ! case 406: ! #line 2239 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 408: ! #line 2245 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 409: ! #line 2250 "parse.y" { tree type; --- 5793,5819 ---- ; break;} ! case 406: ! #line 2239 "parse.y" { yyval.ttype = xref_tag (yyval.ttype, make_anon_name (), NULL_TREE, 0); yyungetc ('{', 1); ; break;} ! case 409: ! #line 2247 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 410: ! #line 2249 "parse.y" { yyungetc(':', 1); yyval.ttype = NULL_TREE; ; break;} ! case 411: ! #line 2251 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 413: ! #line 2257 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 414: ! #line 2262 "parse.y" { tree type; *************** *** 5797,5802 **** ; break;} ! case 410: ! #line 2277 "parse.y" { tree type; --- 5843,5848 ---- ; break;} ! case 415: ! #line 2289 "parse.y" { tree type; *************** *** 5828,5833 **** ; break;} ! case 412: ! #line 2310 "parse.y" { if (current_aggr == signature_type_node) --- 5874,5879 ---- ; break;} ! case 417: ! #line 2322 "parse.y" { if (current_aggr == signature_type_node) *************** *** 5852,5857 **** ; break;} ! case 413: ! #line 2332 "parse.y" { if (current_aggr == signature_type_node) --- 5898,5903 ---- ; break;} ! case 418: ! #line 2344 "parse.y" { if (current_aggr == signature_type_node) *************** *** 5876,5881 **** ; break;} ! case 415: ! #line 2358 "parse.y" { if (yyval.ttype != ridpointers[(int)RID_VIRTUAL]) sorry ("non-virtual access"); --- 5922,5927 ---- ; break;} ! case 420: ! #line 2370 "parse.y" { if (yyval.ttype != ridpointers[(int)RID_VIRTUAL]) sorry ("non-virtual access"); *************** *** 5882,5887 **** yyval.itype = access_default_virtual; ; break;} ! case 416: ! #line 2362 "parse.y" { int err = 0; if (yyvsp[0].itype == access_protected) --- 5928,5933 ---- yyval.itype = access_default_virtual; ; break;} ! case 421: ! #line 2374 "parse.y" { int err = 0; if (yyvsp[0].itype == access_protected) *************** *** 5910,5915 **** ; break;} ! case 417: ! #line 2388 "parse.y" { if (yyvsp[0].ttype != ridpointers[(int)RID_VIRTUAL]) sorry ("non-virtual access"); --- 5956,5961 ---- ; break;} ! case 422: ! #line 2400 "parse.y" { if (yyvsp[0].ttype != ridpointers[(int)RID_VIRTUAL]) sorry ("non-virtual access"); *************** *** 5919,5943 **** yyval.itype = access_private_virtual; ; break;} ! case 418: ! #line 2397 "parse.y" ! { tree t; push_obstacks_nochange (); end_temporary_allocation (); ! if (! IS_AGGR_TYPE (yyvsp[-1].ttype)) { ! yyvsp[-1].ttype = make_lang_type (RECORD_TYPE); ! TYPE_NAME (yyvsp[-1].ttype) = get_identifier ("erroneous type"); } ! if (TYPE_SIZE (yyvsp[-1].ttype)) ! duplicate_tag_error (yyvsp[-1].ttype); ! if (TYPE_SIZE (yyvsp[-1].ttype) || TYPE_BEING_DEFINED (yyvsp[-1].ttype)) { ! t = make_lang_type (TREE_CODE (yyvsp[-1].ttype)); pushtag (TYPE_IDENTIFIER (yyvsp[-1].ttype), t, 0); yyvsp[-1].ttype = t; } ! pushclass (yyvsp[-1].ttype, 0); ! TYPE_BEING_DEFINED (yyvsp[-1].ttype) = 1; #if 0 t = TYPE_IDENTIFIER (yyvsp[-1].ttype); --- 5965,6023 ---- yyval.itype = access_private_virtual; ; break;} ! case 423: ! #line 2409 "parse.y" ! { tree t = yyvsp[-1].ttype; push_obstacks_nochange (); end_temporary_allocation (); ! if (! IS_AGGR_TYPE (t)) { ! t = yyvsp[-1].ttype = make_lang_type (RECORD_TYPE); ! TYPE_NAME (t) = get_identifier ("erroneous type"); } ! if (TYPE_SIZE (t)) ! duplicate_tag_error (t); ! if (TYPE_SIZE (t) || TYPE_BEING_DEFINED (t)) { ! t = make_lang_type (TREE_CODE (t)); pushtag (TYPE_IDENTIFIER (yyvsp[-1].ttype), t, 0); yyvsp[-1].ttype = t; } ! pushclass (t, 0); ! TYPE_BEING_DEFINED (t) = 1; ! /* Reset the interface data, at the earliest possible ! moment, as it might have been set via a class foo; ! before. */ ! /* Don't change signatures. */ ! if (! IS_SIGNATURE (t)) ! { ! extern tree pending_vtables; ! int needs_writing; ! tree name = TYPE_IDENTIFIER (t); ! ! CLASSTYPE_INTERFACE_ONLY (t) = interface_only; ! SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown); ! ! /* Record how to set the access of this class's ! virtual functions. If write_virtuals == 2 or 3, then ! inline virtuals are ``extern inline''. */ ! switch (write_virtuals) ! { ! case 0: ! case 1: ! needs_writing = 1; ! break; ! case 2: ! needs_writing = !! value_member (name, pending_vtables); ! break; ! case 3: ! needs_writing = ! CLASSTYPE_INTERFACE_ONLY (t) ! && CLASSTYPE_INTERFACE_KNOWN (t); ! break; ! default: ! needs_writing = 0; ! } ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = needs_writing; ! } #if 0 t = TYPE_IDENTIFIER (yyvsp[-1].ttype); *************** *** 5947,5956 **** ; break;} ! case 419: ! #line 2426 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 420: ! #line 2428 "parse.y" { if (current_aggr == signature_type_node) --- 6027,6036 ---- ; break;} ! case 424: ! #line 2472 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 425: ! #line 2474 "parse.y" { if (current_aggr == signature_type_node) *************** *** 5960,5965 **** ; break;} ! case 421: ! #line 2435 "parse.y" { tree visspec = (tree) yyvsp[-2].itype; --- 6040,6045 ---- ; break;} ! case 426: ! #line 2481 "parse.y" { tree visspec = (tree) yyvsp[-2].itype; *************** *** 5973,5978 **** ; break;} ! case 422: ! #line 2446 "parse.y" { if (current_aggr == signature_type_node) --- 6053,6058 ---- ; break;} ! case 427: ! #line 2492 "parse.y" { if (current_aggr == signature_type_node) *************** *** 5980,5990 **** ; break;} ! case 423: ! #line 2456 "parse.y" { if (yyval.ttype == void_type_node) yyval.ttype = NULL_TREE; ; break;} ! case 424: ! #line 2459 "parse.y" { /* In pushdecl, we created a reverse list of names in this binding level. Make sure that the chain --- 6060,6070 ---- ; break;} ! case 428: ! #line 2502 "parse.y" { if (yyval.ttype == void_type_node) yyval.ttype = NULL_TREE; ; break;} ! case 429: ! #line 2505 "parse.y" { /* In pushdecl, we created a reverse list of names in this binding level. Make sure that the chain *************** *** 6000,6018 **** ; break;} ! case 427: ! #line 2477 "parse.y" { error ("missing ';' before right brace"); yyungetc ('}', 0); ; break;} ! case 428: ! #line 2482 "parse.y" { yyval.ttype = finish_method (yyval.ttype); ; break;} ! case 429: ! #line 2484 "parse.y" { yyval.ttype = finish_method (yyval.ttype); ; break;} ! case 430: ! #line 2492 "parse.y" { yyval.ttype = grok_x_components (yyval.ttype, yyvsp[0].ttype); --- 6080,6098 ---- ; break;} ! case 432: ! #line 2523 "parse.y" { error ("missing ';' before right brace"); yyungetc ('}', 0); ; break;} ! case 433: ! #line 2528 "parse.y" { yyval.ttype = finish_method (yyval.ttype); ; break;} ! case 434: ! #line 2530 "parse.y" { yyval.ttype = finish_method (yyval.ttype); ; break;} ! case 435: ! #line 2538 "parse.y" { yyval.ttype = grok_x_components (yyval.ttype, yyvsp[0].ttype); *************** *** 6019,6024 **** ; break;} ! case 431: ! #line 2496 "parse.y" { yyval.ttype = grok_x_components (yyval.ttype, yyvsp[0].ttype); --- 6099,6104 ---- ; break;} ! case 436: ! #line 2542 "parse.y" { yyval.ttype = grok_x_components (yyval.ttype, yyvsp[0].ttype); *************** *** 6025,6043 **** ; break;} ! case 432: ! #line 2500 "parse.y" { yyval.ttype = grokfield (yyval.ttype, NULL_TREE, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 433: ! #line 2503 "parse.y" { yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[0].ttype); ; break;} ! case 434: ! #line 2505 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 435: ! #line 2516 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-4].ttype), yyvsp[-2].ttype, yyvsp[0].ttype); --- 6105,6123 ---- ; break;} ! case 437: ! #line 2546 "parse.y" { yyval.ttype = grokfield (yyval.ttype, NULL_TREE, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 438: ! #line 2549 "parse.y" { yyval.ttype = grokbitfield (NULL_TREE, NULL_TREE, yyvsp[0].ttype); ; break;} ! case 439: ! #line 2551 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 440: ! #line 2562 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-4].ttype), yyvsp[-2].ttype, yyvsp[0].ttype); *************** *** 6045,6050 **** NULL_TREE); ; break;} ! case 436: ! #line 2521 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-2].ttype), empty_parms (), yyvsp[0].ttype); --- 6125,6130 ---- NULL_TREE); ; break;} ! case 441: ! #line 2567 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, TREE_VALUE (yyvsp[-2].ttype), empty_parms (), yyvsp[0].ttype); *************** *** 6052,6061 **** NULL_TREE); ; break;} ! case 437: ! #line 2530 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 439: ! #line 2533 "parse.y" { /* In this context, void_type_node encodes --- 6132,6141 ---- NULL_TREE); ; break;} ! case 442: ! #line 2576 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 444: ! #line 2579 "parse.y" { /* In this context, void_type_node encodes *************** *** 6067,6076 **** ; break;} ! case 440: ! #line 2545 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 442: ! #line 2548 "parse.y" { /* In this context, void_type_node encodes --- 6147,6156 ---- ; break;} ! case 445: ! #line 2591 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 447: ! #line 2594 "parse.y" { /* In this context, void_type_node encodes *************** *** 6082,6087 **** ; break;} ! case 447: ! #line 2570 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); --- 6162,6167 ---- ; break;} ! case 452: ! #line 2616 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); *************** *** 6088,6093 **** cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 448: ! #line 2574 "parse.y" { current_declspecs = yyvsp[-6].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); --- 6168,6173 ---- cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 453: ! #line 2620 "parse.y" { current_declspecs = yyvsp[-6].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); *************** *** 6094,6099 **** cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 449: ! #line 2578 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); --- 6174,6179 ---- cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 454: ! #line 2624 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); *************** *** 6100,6105 **** cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 450: ! #line 2585 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); --- 6180,6185 ---- cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 455: ! #line 2631 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); *************** *** 6106,6111 **** cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 451: ! #line 2589 "parse.y" { current_declspecs = yyvsp[-6].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); --- 6186,6191 ---- cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 456: ! #line 2635 "parse.y" { current_declspecs = yyvsp[-6].ttype; yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); *************** *** 6112,6117 **** cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 452: ! #line 2593 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); --- 6192,6197 ---- cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 457: ! #line 2639 "parse.y" { current_declspecs = yyvsp[-4].ttype; yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); *************** *** 6118,6123 **** cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 453: ! #line 2597 "parse.y" { current_declspecs = yyvsp[-3].ttype; yyval.ttype = grokbitfield (NULL_TREE, current_declspecs, yyvsp[-1].ttype); --- 6198,6203 ---- cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 458: ! #line 2643 "parse.y" { current_declspecs = yyvsp[-3].ttype; yyval.ttype = grokbitfield (NULL_TREE, current_declspecs, yyvsp[-1].ttype); *************** *** 6124,6184 **** cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 454: ! #line 2604 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 455: ! #line 2607 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 456: ! #line 2610 "parse.y" { yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 457: ! #line 2616 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 458: ! #line 2619 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 459: ! #line 2622 "parse.y" { yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 460: ! #line 2625 "parse.y" { yyval.ttype = grokbitfield (NULL_TREE, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 462: ! #line 2636 "parse.y" { TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 463: ! #line 2641 "parse.y" { yyval.ttype = build_enumerator (yyval.ttype, NULL_TREE); ; break;} ! case 464: ! #line 2643 "parse.y" { yyval.ttype = build_enumerator (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 465: ! #line 2649 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 466: ! #line 2651 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 467: ! #line 2655 "parse.y" { if (flag_ansi) --- 6204,6264 ---- cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 459: ! #line 2650 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 460: ! #line 2653 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 461: ! #line 2656 "parse.y" { yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 462: ! #line 2662 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 463: ! #line 2665 "parse.y" { yyval.ttype = grokfield (yyval.ttype, current_declspecs, yyvsp[-4].ttype, yyvsp[0].ttype, yyvsp[-3].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[-2].ttype); ; break;} ! case 464: ! #line 2668 "parse.y" { yyval.ttype = grokbitfield (yyval.ttype, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 465: ! #line 2671 "parse.y" { yyval.ttype = grokbitfield (NULL_TREE, current_declspecs, yyvsp[-1].ttype); cplus_decl_attributes (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 467: ! #line 2682 "parse.y" { TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype; yyval.ttype = yyvsp[0].ttype; ; break;} ! case 468: ! #line 2687 "parse.y" { yyval.ttype = build_enumerator (yyval.ttype, NULL_TREE); ; break;} ! case 469: ! #line 2689 "parse.y" { yyval.ttype = build_enumerator (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 470: ! #line 2695 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 471: ! #line 2697 "parse.y" { yyval.ttype = build_decl_list (yyval.ttype, NULL_TREE); ; break;} ! case 472: ! #line 2701 "parse.y" { if (flag_ansi) *************** *** 6188,6233 **** ; break;} ! case 468: ! #line 2665 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 469: ! #line 2667 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 470: ! #line 2672 "parse.y" { yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ; break;} ! case 471: ! #line 2674 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 472: ! #line 2682 "parse.y" { yyval.itype = suspend_momentary (); ; break;} ! case 473: ! #line 2683 "parse.y" { resume_momentary ((int) yyvsp[-1].itype); yyval.ttype = yyvsp[0].ttype; ; break;} ! case 474: ! #line 2690 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 475: ! #line 2692 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 476: ! #line 2694 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 477: ! #line 2696 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 478: ! #line 2698 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 6268,6313 ---- ; break;} ! case 473: ! #line 2711 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 474: ! #line 2713 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 475: ! #line 2718 "parse.y" { yyval.ttype = IDENTIFIER_AS_LIST (yyval.ttype); ; break;} ! case 476: ! #line 2720 "parse.y" { yyval.ttype = decl_tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 477: ! #line 2728 "parse.y" { yyval.itype = suspend_momentary (); ; break;} ! case 478: ! #line 2729 "parse.y" { resume_momentary ((int) yyvsp[-1].itype); yyval.ttype = yyvsp[0].ttype; ; break;} ! case 479: ! #line 2736 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 480: ! #line 2738 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 481: ! #line 2740 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 482: ! #line 2742 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 483: ! #line 2744 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 6234,6239 **** ; break;} ! case 480: ! #line 2706 "parse.y" { /* Remember that this name has been used in the class --- 6314,6319 ---- ; break;} ! case 485: ! #line 2752 "parse.y" { /* Remember that this name has been used in the class *************** *** 6249,6286 **** ; break;} ! case 482: ! #line 2723 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 483: ! #line 2728 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 484: ! #line 2730 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 485: ! #line 2732 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 486: ! #line 2734 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ; break;} ! case 487: ! #line 2736 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 488: ! #line 2738 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 489: ! #line 2740 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 490: ! #line 2742 "parse.y" { push_nested_class (TREE_TYPE (yyval.ttype), 3); yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); --- 6329,6366 ---- ; break;} ! case 487: ! #line 2769 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 488: ! #line 2774 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 489: ! #line 2776 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 490: ! #line 2778 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 491: ! #line 2780 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ; break;} ! case 492: ! #line 2782 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 493: ! #line 2784 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 494: ! #line 2786 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 495: ! #line 2788 "parse.y" { push_nested_class (TREE_TYPE (yyval.ttype), 3); yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); *************** *** 6287,6308 **** TREE_COMPLEXITY (yyval.ttype) = current_class_depth; ; break;} ! case 492: ! #line 2753 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 493: ! #line 2755 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 494: ! #line 2757 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 495: ! #line 2759 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 496: ! #line 2761 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 6367,6388 ---- TREE_COMPLEXITY (yyval.ttype) = current_class_depth; ; break;} ! case 497: ! #line 2799 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 498: ! #line 2801 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 499: ! #line 2803 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 500: ! #line 2805 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 501: ! #line 2807 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 6309,6330 **** ; break;} ! case 498: ! #line 2769 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 499: ! #line 2771 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 500: ! #line 2773 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 501: ! #line 2775 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 502: ! #line 2777 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 6389,6410 ---- ; break;} ! case 503: ! #line 2815 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 504: ! #line 2817 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 505: ! #line 2819 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 506: ! #line 2821 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 507: ! #line 2823 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 6331,6442 **** ; break;} ! case 504: ! #line 2785 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 505: ! #line 2787 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 506: ! #line 2789 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 507: ! #line 2791 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ; break;} ! case 508: ! #line 2793 "parse.y" ! { yyval.ttype = finish_decl_parsing (yyvsp[-1].ttype); ; ! break;} ! case 509: ! #line 2795 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 510: ! #line 2797 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 511: ! #line 2799 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 512: ! #line 2804 "parse.y" { got_scope = NULL_TREE; yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 513: ! #line 2810 "parse.y" { got_scope = NULL_TREE; yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 515: ! #line 2817 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 516: ! #line 2822 "parse.y" { yyval.ttype = build_functional_cast (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 517: ! #line 2824 "parse.y" { yyval.ttype = reparse_decl_as_expr (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 518: ! #line 2826 "parse.y" { yyval.ttype = reparse_absdcl_as_expr (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 522: ! #line 2837 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 523: ! #line 2844 "parse.y" { got_scope = TREE_TYPE (yyval.ttype); ; break;} ! case 524: ! #line 2846 "parse.y" { got_scope = TREE_TYPE (yyval.ttype); ; break;} ! case 526: ! #line 2862 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 528: ! #line 2868 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 529: ! #line 2873 "parse.y" { got_scope = NULL_TREE; ; break;} ! case 530: ! #line 2875 "parse.y" { yyval.ttype = yyvsp[-1].ttype; got_scope = NULL_TREE; ; break;} ! case 531: ! #line 2882 "parse.y" { got_scope = void_type_node; ; break;} ! case 532: ! #line 2888 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 533: ! #line 2890 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 534: ! #line 2892 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 535: ! #line 2894 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 536: ! #line 2896 "parse.y" { tree arg = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-1].ttype, arg); --- 6411,6518 ---- ; break;} ! case 509: ! #line 2831 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 510: ! #line 2833 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 511: ! #line 2835 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 512: ! #line 2837 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, NULL_TREE, NULL_TREE); ; break;} ! case 513: ! #line 2839 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 514: ! #line 2841 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 515: ! #line 2843 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 516: ! #line 2848 "parse.y" { got_scope = NULL_TREE; yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 517: ! #line 2854 "parse.y" { got_scope = NULL_TREE; yyval.ttype = build_parse_node (SCOPE_REF, yyval.ttype, yyvsp[0].ttype); ; break;} ! case 519: ! #line 2861 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 520: ! #line 2866 "parse.y" { yyval.ttype = build_functional_cast (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 521: ! #line 2868 "parse.y" { yyval.ttype = reparse_decl_as_expr (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 522: ! #line 2870 "parse.y" { yyval.ttype = reparse_absdcl_as_expr (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 526: ! #line 2881 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 527: ! #line 2888 "parse.y" { got_scope = TREE_TYPE (yyval.ttype); ; break;} ! case 528: ! #line 2890 "parse.y" { got_scope = TREE_TYPE (yyval.ttype); ; break;} ! case 530: ! #line 2906 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 532: ! #line 2912 "parse.y" { yyval.ttype = yyvsp[0].ttype; ; break;} ! case 533: ! #line 2917 "parse.y" { got_scope = NULL_TREE; ; break;} ! case 534: ! #line 2919 "parse.y" { yyval.ttype = yyvsp[-1].ttype; got_scope = NULL_TREE; ; break;} ! case 535: ! #line 2926 "parse.y" { got_scope = void_type_node; ; break;} ! case 536: ! #line 2932 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 537: ! #line 2934 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 538: ! #line 2936 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 539: ! #line 2938 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 540: ! #line 2940 "parse.y" { tree arg = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-1].ttype, arg); *************** *** 6443,6448 **** ; break;} ! case 537: ! #line 2900 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 6519,6524 ---- ; break;} ! case 541: ! #line 2944 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 6449,6494 **** ; break;} ! case 539: ! #line 2909 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 540: ! #line 2911 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 541: ! #line 2917 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 542: ! #line 2919 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 543: ! #line 2921 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 544: ! #line 2923 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, NULL_TREE); ; break;} ! case 545: ! #line 2925 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 546: ! #line 2927 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 547: ! #line 2929 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 548: ! #line 2931 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, NULL_TREE); ; break;} ! case 549: ! #line 2933 "parse.y" { tree arg = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-1].ttype, arg); --- 6525,6570 ---- ; break;} ! case 543: ! #line 2953 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 544: ! #line 2955 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 545: ! #line 2961 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 546: ! #line 2963 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 547: ! #line 2965 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 548: ! #line 2967 "parse.y" { yyval.ttype = make_pointer_declarator (NULL_TREE, NULL_TREE); ; break;} ! case 549: ! #line 2969 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 550: ! #line 2971 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, yyvsp[0].ttype); ; break;} ! case 551: ! #line 2973 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[0].ttype, NULL_TREE); ; break;} ! case 552: ! #line 2975 "parse.y" { yyval.ttype = make_reference_declarator (NULL_TREE, NULL_TREE); ; break;} ! case 553: ! #line 2977 "parse.y" { tree arg = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-1].ttype, arg); *************** *** 6495,6500 **** ; break;} ! case 550: ! #line 2937 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 6571,6576 ---- ; break;} ! case 554: ! #line 2981 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 6501,6546 **** ; break;} ! case 552: ! #line 2946 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 554: ! #line 2950 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 555: ! #line 2952 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 556: ! #line 2954 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 557: ! #line 2956 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 558: ! #line 2958 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 559: ! #line 2960 "parse.y" { TREE_OPERAND (yyval.ttype, 2) = yyvsp[0].ttype; ; break;} ! case 560: ! #line 2962 "parse.y" { TREE_OPERAND (yyval.ttype, 2) = yyvsp[0].ttype; ; break;} ! case 561: ! #line 2964 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 562: ! #line 2966 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); ; break;} ! case 568: ! #line 2988 "parse.y" { emit_line_note (input_filename, lineno); pushlevel (0); --- 6577,6622 ---- ; break;} ! case 556: ! #line 2990 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 558: ! #line 2994 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 559: ! #line 2996 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, yyval.ttype, empty_parms (), yyvsp[0].ttype); ; break;} ! case 560: ! #line 2998 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 561: ! #line 3000 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, yyval.ttype, NULL_TREE); ; break;} ! case 562: ! #line 3002 "parse.y" { yyval.ttype = build_parse_node (CALL_EXPR, NULL_TREE, yyvsp[-2].ttype, yyvsp[0].ttype); ; break;} ! case 563: ! #line 3004 "parse.y" { TREE_OPERAND (yyval.ttype, 2) = yyvsp[0].ttype; ; break;} ! case 564: ! #line 3006 "parse.y" { TREE_OPERAND (yyval.ttype, 2) = yyvsp[0].ttype; ; break;} ! case 565: ! #line 3008 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ; break;} ! case 566: ! #line 3010 "parse.y" { yyval.ttype = build_parse_node (ARRAY_REF, NULL_TREE, NULL_TREE); ; break;} ! case 572: ! #line 3032 "parse.y" { emit_line_note (input_filename, lineno); pushlevel (0); *************** *** 6549,6559 **** expand_start_bindings (0); ; break;} ! case 570: ! #line 3000 "parse.y" { if (flag_ansi) pedwarn ("ANSI C++ forbids label declarations"); ; break;} ! case 573: ! #line 3011 "parse.y" { tree link; for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link)) --- 6625,6635 ---- expand_start_bindings (0); ; break;} ! case 574: ! #line 3044 "parse.y" { if (flag_ansi) pedwarn ("ANSI C++ forbids label declarations"); ; break;} ! case 577: ! #line 3055 "parse.y" { tree link; for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link)) *************** *** 6565,6574 **** ; break;} ! case 574: ! #line 3025 "parse.y" {; break;} ! case 576: ! #line 3030 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); --- 6641,6650 ---- ; break;} ! case 578: ! #line 3069 "parse.y" {; break;} ! case 580: ! #line 3074 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); *************** *** 6575,6580 **** pop_momentary (); ; break;} ! case 577: ! #line 3034 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); --- 6651,6656 ---- pop_momentary (); ; break;} ! case 581: ! #line 3078 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); *************** *** 6581,6586 **** pop_momentary (); ; break;} ! case 578: ! #line 3038 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 0, 0); --- 6657,6662 ---- pop_momentary (); ; break;} ! case 582: ! #line 3082 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 0, 0); *************** *** 6587,6592 **** pop_momentary (); ; break;} ! case 579: ! #line 3042 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 0, 0); --- 6663,6668 ---- pop_momentary (); ; break;} ! case 583: ! #line 3086 "parse.y" { expand_end_bindings (getdecls (), kept_level_p(), 1); yyval.ttype = poplevel (kept_level_p (), 0, 0); *************** *** 6593,6611 **** pop_momentary (); ; break;} ! case 580: ! #line 3049 "parse.y" { cond_stmt_keyword = "if"; ; break;} ! case 581: ! #line 3051 "parse.y" { emit_line_note (input_filename, lineno); ! expand_start_cond (bool_truthvalue_conversion (yyvsp[0].ttype), 0); ; break;} ! case 583: ! #line 3058 "parse.y" { finish_stmt (); ; break;} ! case 584: ! #line 3060 "parse.y" { expand_end_bindings (getdecls (), kept_level_p (), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); --- 6669,6687 ---- pop_momentary (); ; break;} ! case 584: ! #line 3093 "parse.y" { cond_stmt_keyword = "if"; ; break;} ! case 585: ! #line 3095 "parse.y" { emit_line_note (input_filename, lineno); ! expand_start_cond (yyvsp[0].ttype, 0); ; break;} ! case 587: ! #line 3102 "parse.y" { finish_stmt (); ; break;} ! case 588: ! #line 3104 "parse.y" { expand_end_bindings (getdecls (), kept_level_p (), 1); yyval.ttype = poplevel (kept_level_p (), 1, 0); *************** *** 6612,6625 **** pop_momentary (); ; break;} ! case 585: ! #line 3067 "parse.y" { finish_stmt (); ; break;} ! case 587: ! #line 3073 "parse.y" { finish_stmt (); ; break;} ! case 588: ! #line 3075 "parse.y" { tree expr = yyvsp[-1].ttype; --- 6688,6701 ---- pop_momentary (); ; break;} ! case 589: ! #line 3111 "parse.y" { finish_stmt (); ; break;} ! case 591: ! #line 3117 "parse.y" { finish_stmt (); ; break;} ! case 592: ! #line 3119 "parse.y" { tree expr = yyvsp[-1].ttype; *************** *** 6635,6644 **** finish_stmt (); ; break;} ! case 589: ! #line 3088 "parse.y" { expand_start_else (); ; break;} ! case 590: ! #line 3090 "parse.y" { expand_end_cond (); expand_end_bindings (getdecls (), kept_level_p (), 1); --- 6711,6720 ---- finish_stmt (); ; break;} ! case 593: ! #line 3132 "parse.y" { expand_start_else (); ; break;} ! case 594: ! #line 3134 "parse.y" { expand_end_cond (); expand_end_bindings (getdecls (), kept_level_p (), 1); *************** *** 6647,6652 **** finish_stmt (); ; break;} ! case 591: ! #line 3096 "parse.y" { expand_end_cond (); expand_end_bindings (getdecls (), kept_level_p (), 1); --- 6723,6728 ---- finish_stmt (); ; break;} ! case 595: ! #line 3140 "parse.y" { expand_end_cond (); expand_end_bindings (getdecls (), kept_level_p (), 1); *************** *** 6655,6660 **** finish_stmt (); ; break;} ! case 592: ! #line 3102 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); --- 6731,6736 ---- finish_stmt (); ; break;} ! case 596: ! #line 3146 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); *************** *** 6662,6671 **** cond_stmt_keyword = "while"; ; break;} ! case 593: ! #line 3107 "parse.y" ! { expand_exit_loop_if_false (0, bool_truthvalue_conversion (yyvsp[0].ttype)); ; break;} ! case 594: ! #line 3109 "parse.y" { expand_end_bindings (getdecls (), kept_level_p (), 1); poplevel (kept_level_p (), 1, 0); --- 6738,6747 ---- cond_stmt_keyword = "while"; ; break;} ! case 597: ! #line 3151 "parse.y" ! { expand_exit_loop_if_false (0, yyvsp[0].ttype); ; break;} ! case 598: ! #line 3153 "parse.y" { expand_end_bindings (getdecls (), kept_level_p (), 1); poplevel (kept_level_p (), 1, 0); *************** *** 6674,6679 **** finish_stmt (); ; break;} ! case 595: ! #line 3115 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); --- 6750,6755 ---- finish_stmt (); ; break;} ! case 599: ! #line 3159 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); *************** *** 6680,6692 **** expand_start_loop_continue_elsewhere (1); ; break;} ! case 596: ! #line 3119 "parse.y" { expand_loop_continue_here (); cond_stmt_keyword = "do"; ; break;} ! case 597: ! #line 3122 "parse.y" { emit_line_note (input_filename, lineno); ! expand_exit_loop_if_false (0, bool_truthvalue_conversion (yyvsp[-1].ttype)); expand_end_loop (); clear_momentary (); --- 6756,6768 ---- expand_start_loop_continue_elsewhere (1); ; break;} ! case 600: ! #line 3163 "parse.y" { expand_loop_continue_here (); cond_stmt_keyword = "do"; ; break;} ! case 601: ! #line 3166 "parse.y" { emit_line_note (input_filename, lineno); ! expand_exit_loop_if_false (0, yyvsp[-1].ttype); expand_end_loop (); clear_momentary (); *************** *** 6693,6698 **** finish_stmt (); ; break;} ! case 598: ! #line 3128 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); --- 6769,6774 ---- finish_stmt (); ; break;} ! case 602: ! #line 3172 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); *************** *** 6700,6714 **** expand_start_loop_continue_elsewhere (1); ; break;} ! case 599: ! #line 3133 "parse.y" { emit_line_note (input_filename, lineno); ! if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, bool_truthvalue_conversion (yyvsp[-1].ttype)); ; break;} ! case 600: ! #line 3138 "parse.y" { push_momentary (); ; break;} ! case 601: ! #line 3140 "parse.y" { emit_line_note (input_filename, lineno); expand_end_bindings (getdecls (), kept_level_p (), 1); --- 6776,6790 ---- expand_start_loop_continue_elsewhere (1); ; break;} ! case 603: ! #line 3177 "parse.y" { emit_line_note (input_filename, lineno); ! if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, yyvsp[-1].ttype); ; break;} ! case 604: ! #line 3182 "parse.y" { push_momentary (); ; break;} ! case 605: ! #line 3184 "parse.y" { emit_line_note (input_filename, lineno); expand_end_bindings (getdecls (), kept_level_p (), 1); *************** *** 6721,6726 **** finish_stmt (); ; break;} ! case 602: ! #line 3150 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); --- 6797,6802 ---- finish_stmt (); ; break;} ! case 606: ! #line 3194 "parse.y" { emit_nop (); emit_line_note (input_filename, lineno); *************** *** 6727,6742 **** expand_start_loop_continue_elsewhere (1); ; break;} ! case 603: ! #line 3154 "parse.y" { emit_line_note (input_filename, lineno); ! if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, bool_truthvalue_conversion (yyvsp[-1].ttype)); ; break;} ! case 604: ! #line 3159 "parse.y" { push_momentary (); yyvsp[0].itype = lineno; ; break;} ! case 605: ! #line 3162 "parse.y" { emit_line_note (input_filename, (int) yyvsp[-2].itype); expand_end_bindings (getdecls (), kept_level_p (), 1); --- 6803,6818 ---- expand_start_loop_continue_elsewhere (1); ; break;} ! case 607: ! #line 3198 "parse.y" { emit_line_note (input_filename, lineno); ! if (yyvsp[-1].ttype) expand_exit_loop_if_false (0, yyvsp[-1].ttype); ; break;} ! case 608: ! #line 3203 "parse.y" { push_momentary (); yyvsp[0].itype = lineno; ; break;} ! case 609: ! #line 3206 "parse.y" { emit_line_note (input_filename, (int) yyvsp[-2].itype); expand_end_bindings (getdecls (), kept_level_p (), 1); *************** *** 6750,6757 **** ; break;} ! case 606: ! #line 3173 "parse.y" { emit_line_note (input_filename, lineno); ! c_expand_start_case (yyvsp[-1].ttype); /* Don't let the tree nodes for $4 be discarded by clear_momentary during the parsing of the next stmt. */ --- 6826,6833 ---- ; break;} ! case 610: ! #line 3217 "parse.y" { emit_line_note (input_filename, lineno); ! c_expand_start_case (yyvsp[-1].ttype); /* Don't let the tree nodes for $4 be discarded by clear_momentary during the parsing of the next stmt. */ *************** *** 6758,6763 **** push_momentary (); ; break;} ! case 607: ! #line 3179 "parse.y" { expand_end_case (yyvsp[-3].ttype); pop_momentary (); --- 6834,6839 ---- push_momentary (); ; break;} ! case 611: ! #line 3223 "parse.y" { expand_end_case (yyvsp[-3].ttype); pop_momentary (); *************** *** 6767,6772 **** finish_stmt (); ; break;} ! case 608: ! #line 3186 "parse.y" { register tree value = check_cp_case_value (yyvsp[-1].ttype); register tree label --- 6843,6848 ---- finish_stmt (); ; break;} ! case 612: ! #line 3230 "parse.y" { register tree value = check_cp_case_value (yyvsp[-1].ttype); register tree label *************** *** 6793,6798 **** ; break;} ! case 610: ! #line 3211 "parse.y" { register tree value1 = check_cp_case_value (yyvsp[-3].ttype); register tree value2 = check_cp_case_value (yyvsp[-1].ttype); --- 6869,6874 ---- ; break;} ! case 614: ! #line 3255 "parse.y" { register tree value1 = check_cp_case_value (yyvsp[-3].ttype); register tree value2 = check_cp_case_value (yyvsp[-1].ttype); *************** *** 6826,6831 **** ; break;} ! case 612: ! #line 3243 "parse.y" { tree duplicate; --- 6902,6907 ---- ; break;} ! case 616: ! #line 3287 "parse.y" { tree duplicate; *************** *** 6843,6848 **** ; break;} ! case 614: ! #line 3259 "parse.y" { emit_line_note (input_filename, lineno); if ( ! expand_exit_something ()) --- 6919,6924 ---- ; break;} ! case 618: ! #line 3303 "parse.y" { emit_line_note (input_filename, lineno); if ( ! expand_exit_something ()) *************** *** 6849,6854 **** error ("break statement not within loop or switch"); ; break;} ! case 615: ! #line 3263 "parse.y" { emit_line_note (input_filename, lineno); if (! expand_continue_loop (0)) --- 6925,6930 ---- error ("break statement not within loop or switch"); ; break;} ! case 619: ! #line 3307 "parse.y" { emit_line_note (input_filename, lineno); if (! expand_continue_loop (0)) *************** *** 6855,6865 **** error ("continue statement not within a loop"); ; break;} ! case 616: ! #line 3267 "parse.y" { emit_line_note (input_filename, lineno); c_expand_return (NULL_TREE); ; break;} ! case 617: ! #line 3270 "parse.y" { emit_line_note (input_filename, lineno); c_expand_return (yyvsp[-1].ttype); --- 6931,6941 ---- error ("continue statement not within a loop"); ; break;} ! case 620: ! #line 3311 "parse.y" { emit_line_note (input_filename, lineno); c_expand_return (NULL_TREE); ; break;} ! case 621: ! #line 3314 "parse.y" { emit_line_note (input_filename, lineno); c_expand_return (yyvsp[-1].ttype); *************** *** 6867,6872 **** ; break;} ! case 618: ! #line 3275 "parse.y" { if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype); emit_line_note (input_filename, lineno); --- 6943,6948 ---- ; break;} ! case 622: ! #line 3319 "parse.y" { if (TREE_CHAIN (yyvsp[-2].ttype)) yyvsp[-2].ttype = combine_strings (yyvsp[-2].ttype); emit_line_note (input_filename, lineno); *************** *** 6875,6880 **** ; break;} ! case 619: ! #line 3282 "parse.y" { if (TREE_CHAIN (yyvsp[-4].ttype)) yyvsp[-4].ttype = combine_strings (yyvsp[-4].ttype); emit_line_note (input_filename, lineno); --- 6951,6956 ---- ; break;} ! case 623: ! #line 3326 "parse.y" { if (TREE_CHAIN (yyvsp[-4].ttype)) yyvsp[-4].ttype = combine_strings (yyvsp[-4].ttype); emit_line_note (input_filename, lineno); *************** *** 6885,6890 **** ; break;} ! case 620: ! #line 3291 "parse.y" { if (TREE_CHAIN (yyvsp[-6].ttype)) yyvsp[-6].ttype = combine_strings (yyvsp[-6].ttype); emit_line_note (input_filename, lineno); --- 6961,6966 ---- ; break;} ! case 624: ! #line 3335 "parse.y" { if (TREE_CHAIN (yyvsp[-6].ttype)) yyvsp[-6].ttype = combine_strings (yyvsp[-6].ttype); emit_line_note (input_filename, lineno); *************** *** 6895,6900 **** ; break;} ! case 621: ! #line 3301 "parse.y" { if (TREE_CHAIN (yyvsp[-8].ttype)) yyvsp[-8].ttype = combine_strings (yyvsp[-8].ttype); emit_line_note (input_filename, lineno); --- 6971,6976 ---- ; break;} ! case 625: ! #line 3345 "parse.y" { if (TREE_CHAIN (yyvsp[-8].ttype)) yyvsp[-8].ttype = combine_strings (yyvsp[-8].ttype); emit_line_note (input_filename, lineno); *************** *** 6905,6915 **** ; break;} ! case 622: ! #line 3309 "parse.y" { emit_line_note (input_filename, lineno); expand_computed_goto (yyvsp[-1].ttype); ; break;} ! case 623: ! #line 3312 "parse.y" { tree decl; emit_line_note (input_filename, lineno); --- 6981,6991 ---- ; break;} ! case 626: ! #line 3353 "parse.y" { emit_line_note (input_filename, lineno); expand_computed_goto (yyvsp[-1].ttype); ; break;} ! case 627: ! #line 3356 "parse.y" { tree decl; emit_line_note (input_filename, lineno); *************** *** 6918,6927 **** expand_goto (decl); ; break;} ! case 624: ! #line 3318 "parse.y" { finish_stmt (); ; break;} ! case 625: ! #line 3320 "parse.y" { error ("label must be followed by statement"); yyungetc ('}', 0); --- 6994,7003 ---- expand_goto (decl); ; break;} ! case 628: ! #line 3362 "parse.y" { finish_stmt (); ; break;} ! case 629: ! #line 3364 "parse.y" { error ("label must be followed by statement"); yyungetc ('}', 0); *************** *** 6928,6950 **** finish_stmt (); ; break;} ! case 626: ! #line 3324 "parse.y" { finish_stmt (); ; break;} ! case 628: ! #line 3330 "parse.y" { expand_start_try_stmts (); ; break;} ! case 629: ! #line 3332 "parse.y" { expand_end_try_stmts (); expand_start_all_catch (); ; break;} ! case 630: ! #line 3335 "parse.y" { expand_end_all_catch (); ; break;} ! case 631: ! #line 3343 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); --- 7004,7026 ---- finish_stmt (); ; break;} ! case 630: ! #line 3368 "parse.y" { finish_stmt (); ; break;} ! case 632: ! #line 3374 "parse.y" { expand_start_try_stmts (); ; break;} ! case 633: ! #line 3376 "parse.y" { expand_end_try_stmts (); expand_start_all_catch (); ; break;} ! case 634: ! #line 3379 "parse.y" { expand_end_all_catch (); ; break;} ! case 635: ! #line 3387 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); *************** *** 6951,6956 **** ; break;} ! case 632: ! #line 3347 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); --- 7027,7032 ---- ; break;} ! case 636: ! #line 3391 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); *************** *** 6957,6962 **** ; break;} ! case 633: ! #line 3351 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); --- 7033,7038 ---- ; break;} ! case 637: ! #line 3395 "parse.y" { expand_end_bindings (0,1,1); poplevel (2,0,0); *************** *** 6963,6985 **** ; break;} ! case 635: ! #line 3359 "parse.y" { emit_line_note (input_filename, lineno); ; break;} ! case 636: ! #line 3361 "parse.y" { expand_end_catch_block (); ; break;} ! case 639: ! #line 3371 "parse.y" { expand_start_catch_block (NULL_TREE, NULL_TREE); ; break;} ! case 640: ! #line 3383 "parse.y" { expand_start_catch_block (TREE_PURPOSE (yyvsp[-1].ttype), TREE_VALUE (yyvsp[-1].ttype)); ; break;} ! case 641: ! #line 3389 "parse.y" { tree label; do_label: --- 7039,7061 ---- ; break;} ! case 639: ! #line 3403 "parse.y" { emit_line_note (input_filename, lineno); ; break;} ! case 640: ! #line 3405 "parse.y" { expand_end_catch_block (); ; break;} ! case 643: ! #line 3415 "parse.y" { expand_start_catch_block (NULL_TREE, NULL_TREE); ; break;} ! case 644: ! #line 3427 "parse.y" { expand_start_catch_block (TREE_PURPOSE (yyvsp[-1].ttype), TREE_VALUE (yyvsp[-1].ttype)); ; break;} ! case 645: ! #line 3433 "parse.y" { tree label; do_label: *************** *** 6989,7063 **** ; break;} ! case 642: ! #line 3396 "parse.y" { goto do_label; ; break;} ! case 643: ! #line 3401 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 644: ! #line 3403 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 645: ! #line 3405 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 646: ! #line 3410 "parse.y" { yyval.itype = 0; ; break;} ! case 647: ! #line 3412 "parse.y" { yyval.itype = 0; ; break;} ! case 648: ! #line 3414 "parse.y" { yyval.itype = 1; ; break;} ! case 649: ! #line 3416 "parse.y" { yyval.itype = -1; ; break;} ! case 650: ! #line 3423 "parse.y" { emit_line_note (input_filename, lineno); yyval.ttype = NULL_TREE; ; break;} ! case 651: ! #line 3426 "parse.y" { emit_line_note (input_filename, lineno); ; break;} ! case 652: ! #line 3431 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 654: ! #line 3434 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 655: ! #line 3440 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 658: ! #line 3447 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 659: ! #line 3452 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 660: ! #line 3457 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, NULL_TREE); ; break;} ! case 661: ! #line 3459 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 662: ! #line 3469 "parse.y" { if (strict_prototype) --- 7065,7143 ---- ; break;} ! case 646: ! #line 3440 "parse.y" ! { goto do_label; ; ! break;} ! case 647: ! #line 3442 "parse.y" { goto do_label; ; break;} ! case 648: ! #line 3447 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 649: ! #line 3449 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 650: ! #line 3451 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 651: ! #line 3456 "parse.y" { yyval.itype = 0; ; break;} ! case 652: ! #line 3458 "parse.y" { yyval.itype = 0; ; break;} ! case 653: ! #line 3460 "parse.y" { yyval.itype = 1; ; break;} ! case 654: ! #line 3462 "parse.y" { yyval.itype = -1; ; break;} ! case 655: ! #line 3469 "parse.y" { emit_line_note (input_filename, lineno); yyval.ttype = NULL_TREE; ; break;} ! case 656: ! #line 3472 "parse.y" { emit_line_note (input_filename, lineno); ; break;} ! case 657: ! #line 3477 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 659: ! #line 3480 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 660: ! #line 3486 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 663: ! #line 3493 "parse.y" { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 664: ! #line 3498 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[-1].ttype); ; break;} ! case 665: ! #line 3503 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, NULL_TREE); ; break;} ! case 666: ! #line 3505 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ; break;} ! case 667: ! #line 3515 "parse.y" { if (strict_prototype) *************** *** 7067,7077 **** ; break;} ! case 664: ! #line 3477 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, void_list_node); TREE_PARMLIST (yyval.ttype) = 1; ; break;} ! case 665: ! #line 3485 "parse.y" { yyval.ttype = chainon (yyval.ttype, void_list_node); --- 7147,7157 ---- ; break;} ! case 669: ! #line 3523 "parse.y" { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, void_list_node); TREE_PARMLIST (yyval.ttype) = 1; ; break;} ! case 670: ! #line 3531 "parse.y" { yyval.ttype = chainon (yyval.ttype, void_list_node); *************** *** 7079,7084 **** ; break;} ! case 666: ! #line 3490 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; --- 7159,7164 ---- ; break;} ! case 671: ! #line 3536 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; *************** *** 7085,7090 **** ; break;} ! case 667: ! #line 3495 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; --- 7165,7170 ---- ; break;} ! case 672: ! #line 3541 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; *************** *** 7091,7096 **** ; break;} ! case 668: ! #line 3499 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); --- 7171,7176 ---- ; break;} ! case 673: ! #line 3545 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); *************** *** 7098,7103 **** ; break;} ! case 669: ! #line 3504 "parse.y" { /* ARM $8.2.5 has this as a boxed-off comment. */ --- 7178,7183 ---- ; break;} ! case 674: ! #line 3550 "parse.y" { /* ARM $8.2.5 has this as a boxed-off comment. */ *************** *** 7107,7112 **** ; break;} ! case 670: ! #line 3511 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; --- 7187,7192 ---- ; break;} ! case 675: ! #line 3557 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; *************** *** 7113,7118 **** ; break;} ! case 671: ! #line 3515 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; --- 7193,7198 ---- ; break;} ! case 676: ! #line 3561 "parse.y" { TREE_PARMLIST (yyval.ttype) = 1; *************** *** 7119,7124 **** ; break;} ! case 672: ! #line 3519 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); --- 7199,7204 ---- ; break;} ! case 677: ! #line 3565 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); *************** *** 7126,7131 **** ; break;} ! case 673: ! #line 3524 "parse.y" { /* This helps us recover from really nasty --- 7206,7211 ---- ; break;} ! case 678: ! #line 3570 "parse.y" { /* This helps us recover from really nasty *************** *** 7139,7144 **** ; break;} ! case 674: ! #line 3535 "parse.y" { /* This helps us recover from really nasty --- 7219,7224 ---- ; break;} ! case 679: ! #line 3581 "parse.y" { /* This helps us recover from really nasty *************** *** 7152,7213 **** ; break;} ! case 675: ! #line 3550 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 676: ! #line 3552 "parse.y" { yyval.ttype = build_tree_list (yyvsp[0].ttype, yyval.ttype); ; break;} ! case 677: ! #line 3554 "parse.y" ! { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; ! break;} ! case 678: ! #line 3556 "parse.y" ! { yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ; break;} ! case 679: ! #line 3558 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 680: ! #line 3560 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ; break;} ! case 682: ! #line 3566 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 683: ! #line 3589 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 684: ! #line 3591 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 685: ! #line 3593 "parse.y" { yyval.ttype = build_tree_list (get_decl_list (yyval.ttype), yyvsp[0].ttype); ; break;} ! case 686: ! #line 3595 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 687: ! #line 3597 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, NULL_TREE); ; break;} ! case 688: ! #line 3599 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 691: ! #line 3608 "parse.y" { see_typename (); ; break;} ! case 692: ! #line 3631 "parse.y" { warning ("type specifier omitted for parameter"); --- 7232,7297 ---- ; break;} ! case 680: ! #line 3596 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 681: ! #line 3598 "parse.y" { yyval.ttype = build_tree_list (yyvsp[0].ttype, yyval.ttype); ; break;} ! case 682: ! #line 3600 "parse.y" ! { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 683: ! #line 3602 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ; break;} ! case 684: ! #line 3604 "parse.y" { yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ; break;} ! case 686: ! #line 3610 "parse.y" { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; break;} ! case 687: ! #line 3633 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 688: ! #line 3635 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 689: ! #line 3637 "parse.y" { yyval.ttype = build_tree_list (get_decl_list (yyval.ttype), yyvsp[0].ttype); ; break;} ! case 690: ! #line 3639 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 691: ! #line 3641 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, NULL_TREE); ; break;} ! case 692: ! #line 3643 "parse.y" { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[0].ttype); ; break;} ! case 693: ! #line 3648 "parse.y" ! { yyval.ttype = build_tree_list (NULL_TREE, yyval.ttype); ; ! break;} ! case 694: ! #line 3650 "parse.y" ! { yyval.ttype = build_tree_list (yyvsp[0].ttype, yyval.ttype); ; ! break;} ! case 697: ! #line 3659 "parse.y" { see_typename (); ; break;} ! case 698: ! #line 3682 "parse.y" { warning ("type specifier omitted for parameter"); *************** *** 7215,7220 **** ; break;} ! case 693: ! #line 3636 "parse.y" { warning ("type specifier omitted for parameter"); --- 7299,7304 ---- ; break;} ! case 699: ! #line 3687 "parse.y" { warning ("type specifier omitted for parameter"); *************** *** 7222,7239 **** ; break;} ! case 694: ! #line 3644 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 695: ! #line 3646 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 696: ! #line 3651 "parse.y" { yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 698: ! #line 3657 "parse.y" { TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype; --- 7306,7323 ---- ; break;} ! case 700: ! #line 3695 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 701: ! #line 3697 "parse.y" { yyval.ttype = yyvsp[-1].ttype; ; break;} ! case 702: ! #line 3702 "parse.y" { yyval.ttype = build_decl_list (NULL_TREE, yyval.ttype); ; break;} ! case 704: ! #line 3708 "parse.y" { TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype; *************** *** 7241,7258 **** ; break;} ! case 699: ! #line 3665 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 700: ! #line 3667 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 701: ! #line 3669 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 702: ! #line 3671 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); --- 7325,7342 ---- ; break;} ! case 705: ! #line 3716 "parse.y" { yyval.ttype = NULL_TREE; ; break;} ! case 706: ! #line 3718 "parse.y" { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 707: ! #line 3720 "parse.y" { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 708: ! #line 3722 "parse.y" { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg); *************** *** 7259,7404 **** ; break;} ! case 703: ! #line 3677 "parse.y" { got_scope = NULL_TREE; ; break;} ! case 704: ! #line 3682 "parse.y" { yyval.ttype = ansi_opname[MULT_EXPR]; ; break;} ! case 705: ! #line 3684 "parse.y" { yyval.ttype = ansi_opname[TRUNC_DIV_EXPR]; ; break;} ! case 706: ! #line 3686 "parse.y" { yyval.ttype = ansi_opname[TRUNC_MOD_EXPR]; ; break;} ! case 707: ! #line 3688 "parse.y" { yyval.ttype = ansi_opname[PLUS_EXPR]; ; break;} ! case 708: ! #line 3690 "parse.y" { yyval.ttype = ansi_opname[MINUS_EXPR]; ; break;} ! case 709: ! #line 3692 "parse.y" { yyval.ttype = ansi_opname[BIT_AND_EXPR]; ; break;} ! case 710: ! #line 3694 "parse.y" { yyval.ttype = ansi_opname[BIT_IOR_EXPR]; ; break;} ! case 711: ! #line 3696 "parse.y" { yyval.ttype = ansi_opname[BIT_XOR_EXPR]; ; break;} ! case 712: ! #line 3698 "parse.y" { yyval.ttype = ansi_opname[BIT_NOT_EXPR]; ; break;} ! case 713: ! #line 3700 "parse.y" { yyval.ttype = ansi_opname[COMPOUND_EXPR]; ; break;} ! case 714: ! #line 3702 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 715: ! #line 3704 "parse.y" { yyval.ttype = ansi_opname[LT_EXPR]; ; break;} ! case 716: ! #line 3706 "parse.y" { yyval.ttype = ansi_opname[GT_EXPR]; ; break;} ! case 717: ! #line 3708 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 718: ! #line 3710 "parse.y" { yyval.ttype = ansi_assopname[yyvsp[0].code]; ; break;} ! case 719: ! #line 3712 "parse.y" { yyval.ttype = ansi_opname [MODIFY_EXPR]; ; break;} ! case 720: ! #line 3714 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 721: ! #line 3716 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 722: ! #line 3718 "parse.y" { yyval.ttype = ansi_opname[POSTINCREMENT_EXPR]; ; break;} ! case 723: ! #line 3720 "parse.y" { yyval.ttype = ansi_opname[PREDECREMENT_EXPR]; ; break;} ! case 724: ! #line 3722 "parse.y" { yyval.ttype = ansi_opname[TRUTH_ANDIF_EXPR]; ; break;} ! case 725: ! #line 3724 "parse.y" { yyval.ttype = ansi_opname[TRUTH_ORIF_EXPR]; ; break;} ! case 726: ! #line 3726 "parse.y" { yyval.ttype = ansi_opname[TRUTH_NOT_EXPR]; ; break;} ! case 727: ! #line 3728 "parse.y" { yyval.ttype = ansi_opname[COND_EXPR]; ; break;} ! case 728: ! #line 3730 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 729: ! #line 3732 "parse.y" { yyval.ttype = ansi_opname[COMPONENT_REF]; ; break;} ! case 730: ! #line 3734 "parse.y" { yyval.ttype = ansi_opname[MEMBER_REF]; ; break;} ! case 731: ! #line 3736 "parse.y" { yyval.ttype = ansi_opname[CALL_EXPR]; ; break;} ! case 732: ! #line 3738 "parse.y" { yyval.ttype = ansi_opname[ARRAY_REF]; ; break;} ! case 733: ! #line 3740 "parse.y" { yyval.ttype = ansi_opname[NEW_EXPR]; ; break;} ! case 734: ! #line 3742 "parse.y" { yyval.ttype = ansi_opname[DELETE_EXPR]; ; break;} ! case 735: ! #line 3744 "parse.y" { yyval.ttype = ansi_opname[VEC_NEW_EXPR]; ; break;} ! case 736: ! #line 3746 "parse.y" { yyval.ttype = ansi_opname[VEC_DELETE_EXPR]; ; break;} ! case 737: ! #line 3749 "parse.y" { yyval.ttype = grokoptypename (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 738: ! #line 3751 "parse.y" { yyval.ttype = ansi_opname[ERROR_MARK]; ; break;} --- 7343,7488 ---- ; break;} ! case 709: ! #line 3728 "parse.y" { got_scope = NULL_TREE; ; break;} ! case 710: ! #line 3733 "parse.y" { yyval.ttype = ansi_opname[MULT_EXPR]; ; break;} ! case 711: ! #line 3735 "parse.y" { yyval.ttype = ansi_opname[TRUNC_DIV_EXPR]; ; break;} ! case 712: ! #line 3737 "parse.y" { yyval.ttype = ansi_opname[TRUNC_MOD_EXPR]; ; break;} ! case 713: ! #line 3739 "parse.y" { yyval.ttype = ansi_opname[PLUS_EXPR]; ; break;} ! case 714: ! #line 3741 "parse.y" { yyval.ttype = ansi_opname[MINUS_EXPR]; ; break;} ! case 715: ! #line 3743 "parse.y" { yyval.ttype = ansi_opname[BIT_AND_EXPR]; ; break;} ! case 716: ! #line 3745 "parse.y" { yyval.ttype = ansi_opname[BIT_IOR_EXPR]; ; break;} ! case 717: ! #line 3747 "parse.y" { yyval.ttype = ansi_opname[BIT_XOR_EXPR]; ; break;} ! case 718: ! #line 3749 "parse.y" { yyval.ttype = ansi_opname[BIT_NOT_EXPR]; ; break;} ! case 719: ! #line 3751 "parse.y" { yyval.ttype = ansi_opname[COMPOUND_EXPR]; ; break;} ! case 720: ! #line 3753 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 721: ! #line 3755 "parse.y" { yyval.ttype = ansi_opname[LT_EXPR]; ; break;} ! case 722: ! #line 3757 "parse.y" { yyval.ttype = ansi_opname[GT_EXPR]; ; break;} ! case 723: ! #line 3759 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 724: ! #line 3761 "parse.y" { yyval.ttype = ansi_assopname[yyvsp[0].code]; ; break;} ! case 725: ! #line 3763 "parse.y" { yyval.ttype = ansi_opname [MODIFY_EXPR]; ; break;} ! case 726: ! #line 3765 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 727: ! #line 3767 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 728: ! #line 3769 "parse.y" { yyval.ttype = ansi_opname[POSTINCREMENT_EXPR]; ; break;} ! case 729: ! #line 3771 "parse.y" { yyval.ttype = ansi_opname[PREDECREMENT_EXPR]; ; break;} ! case 730: ! #line 3773 "parse.y" { yyval.ttype = ansi_opname[TRUTH_ANDIF_EXPR]; ; break;} ! case 731: ! #line 3775 "parse.y" { yyval.ttype = ansi_opname[TRUTH_ORIF_EXPR]; ; break;} ! case 732: ! #line 3777 "parse.y" { yyval.ttype = ansi_opname[TRUTH_NOT_EXPR]; ; break;} ! case 733: ! #line 3779 "parse.y" { yyval.ttype = ansi_opname[COND_EXPR]; ; break;} ! case 734: ! #line 3781 "parse.y" { yyval.ttype = ansi_opname[yyvsp[0].code]; ; break;} ! case 735: ! #line 3783 "parse.y" { yyval.ttype = ansi_opname[COMPONENT_REF]; ; break;} ! case 736: ! #line 3785 "parse.y" { yyval.ttype = ansi_opname[MEMBER_REF]; ; break;} ! case 737: ! #line 3787 "parse.y" { yyval.ttype = ansi_opname[CALL_EXPR]; ; break;} ! case 738: ! #line 3789 "parse.y" { yyval.ttype = ansi_opname[ARRAY_REF]; ; break;} ! case 739: ! #line 3791 "parse.y" { yyval.ttype = ansi_opname[NEW_EXPR]; ; break;} ! case 740: ! #line 3793 "parse.y" { yyval.ttype = ansi_opname[DELETE_EXPR]; ; break;} ! case 741: ! #line 3795 "parse.y" { yyval.ttype = ansi_opname[VEC_NEW_EXPR]; ; break;} ! case 742: ! #line 3797 "parse.y" { yyval.ttype = ansi_opname[VEC_DELETE_EXPR]; ; break;} ! case 743: ! #line 3800 "parse.y" { yyval.ttype = grokoptypename (yyvsp[-1].ttype, yyvsp[0].ttype); ; break;} ! case 744: ! #line 3802 "parse.y" { yyval.ttype = ansi_opname[ERROR_MARK]; ; break;} *************** *** 7601,7604 **** goto yynewstate; } ! #line 3754 "parse.y" --- 7685,7698 ---- goto yynewstate; } ! #line 3805 "parse.y" ! ! ! #ifdef SPEW_DEBUG ! const char * ! debug_yytranslate (value) ! int value; ! { ! return yytname[YYTRANSLATE (value)]; ! } + #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/parse.y gcc-2.6.1/cp/parse.y *** gcc-2.6.0/cp/parse.y Thu Jul 7 00:18:25 1994 --- gcc-2.6.1/cp/parse.y Tue Oct 11 14:30:48 1994 *************** *** 222,226 **** %type direct_abstract_declarator conversion_declarator %type new_type_id new_declarator direct_new_declarator ! %type xexpr parmlist parms parm bad_parm %type identifiers_or_typenames %type fcast_or_absdcl regcast_or_absdcl sub_cast_expr --- 222,226 ---- %type direct_abstract_declarator conversion_declarator %type new_type_id new_declarator direct_new_declarator ! %type xexpr parmlist parms parm bad_parm full_parm %type identifiers_or_typenames %type fcast_or_absdcl regcast_or_absdcl sub_cast_expr *************** *** 251,254 **** --- 251,255 ---- %type forhead.2 initdcl0 notype_initdcl0 member_init_list %type template_header template_parm_list template_parm + %type template_type_parm %type template_type template_arg_list template_arg %type template_instantiation template_type_name tmpl.2 *************** *** 374,377 **** --- 375,392 ---- ; + template_type_parm: + aggr + { + $$ = build_tree_list ($1, NULL_TREE); + ttpa: + if (TREE_PURPOSE ($$) == signature_type_node) + sorry ("signature as template type parameter"); + else if (TREE_PURPOSE ($$) != class_type_node) + pedwarn ("template type parameters must use the keyword `class'"); + } + | aggr identifier + { $$ = build_tree_list ($1, $2); goto ttpa; } + ; + template_parm: /* The following rules introduce a new reduce/reduce *************** *** 382,403 **** their match before considering them nameless parameter declarations. */ ! aggr identifier ! { ! if ($1 == signature_type_node) ! sorry ("signature as template type parameter"); ! else if ($1 != class_type_node) ! error ("template type parameter must use keyword `class'"); ! $$ = build_tree_list ($2, NULL_TREE); ! } ! | aggr identifier_defn ':' base_class.1 ! { ! if ($1 == signature_type_node) ! sorry ("signature as template type parameter"); ! else if ($1 != class_type_node) ! error ("template type parameter must use keyword `class'"); ! warning ("restricted template type parameters not yet implemented"); ! $$ = build_tree_list ($2, $4); ! } ! | parm ; --- 397,405 ---- their match before considering them nameless parameter declarations. */ ! template_type_parm ! { $$ = build_tree_list (NULL_TREE, $$); } ! | template_type_parm '=' typespec ! { $$ = build_tree_list ($3, $$); } ! | full_parm ; *************** *** 783,786 **** --- 785,790 ---- PTYPENAME '<' template_arg_list '>' { $$ = lookup_template_class ($$, $3, NULL_TREE); } + | PTYPENAME '<' '>' + { $$ = lookup_template_class ($$, NULL_TREE, NULL_TREE); } | TYPENAME '<' template_arg_list '>' { $$ = lookup_template_class ($$, $3, NULL_TREE); } *************** *** 892,896 **** $$ = integer_zero_node; } | '(' expr ')' ! { $$ = $2; } ; --- 896,901 ---- $$ = integer_zero_node; } | '(' expr ')' ! { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, ! bool_truthvalue_conversion ($2)); } ; *************** *** 901,905 **** $$ = integer_zero_node; } | '(' condition ')' ! { $$ = $2; } ; --- 906,911 ---- $$ = integer_zero_node; } | '(' condition ')' ! { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, ! bool_truthvalue_conversion ($2)); } ; *************** *** 908,911 **** --- 914,919 ---- { $$ = NULL_TREE; } | condition + { $$ = build1 (CLEANUP_POINT_EXPR, bool_type_node, + bool_truthvalue_conversion ($$)); } | error { $$ = NULL_TREE; } *************** *** 1244,1247 **** --- 1252,1257 ---- | '&' expr_or_declarator %prec UNARY { $$ = build_parse_node (ADDR_EXPR, $2); } + | '(' expr_or_declarator ')' + { $$ = $2; } ; *************** *** 1252,1255 **** --- 1262,1267 ---- { push_nested_class (TREE_TYPE (OP0 ($$)), 3); TREE_COMPLEXITY ($$) = current_class_depth; } + | '(' expr_or_declarator ')' + { $$ = finish_decl_parsing ($2); } ; *************** *** 1545,1549 **** != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3)))) cp_error ("`%E' is not of type `%T'", $1, $3); ! $$ = void_zero_node; } | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT --- 1557,1561 ---- != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($3)))) cp_error ("`%E' is not of type `%T'", $1, $3); ! $$ = convert (void_type_node, $1); } | object TYPESPEC SCOPE '~' TYPESPEC LEFT_RIGHT *************** *** 1554,1558 **** != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($2)))) cp_error ("`%E' is not of type `%T'", $1, $2); ! $$ = void_zero_node; } ; --- 1566,1570 ---- != TREE_CODE (TREE_TYPE (IDENTIFIER_GLOBAL_VALUE ($2)))) cp_error ("`%E' is not of type `%T'", $1, $2); ! $$ = convert (void_type_node, $1); } ; *************** *** 2395,2417 **** left_curly: '{' ! { tree t; push_obstacks_nochange (); end_temporary_allocation (); ! if (! IS_AGGR_TYPE ($0)) { ! $0 = make_lang_type (RECORD_TYPE); ! TYPE_NAME ($0) = get_identifier ("erroneous type"); } ! if (TYPE_SIZE ($0)) ! duplicate_tag_error ($0); ! if (TYPE_SIZE ($0) || TYPE_BEING_DEFINED ($0)) { ! t = make_lang_type (TREE_CODE ($0)); pushtag (TYPE_IDENTIFIER ($0), t, 0); $0 = t; } ! pushclass ($0, 0); ! TYPE_BEING_DEFINED ($0) = 1; #if 0 t = TYPE_IDENTIFIER ($0); --- 2407,2463 ---- left_curly: '{' ! { tree t = $0; push_obstacks_nochange (); end_temporary_allocation (); ! if (! IS_AGGR_TYPE (t)) { ! t = $0 = make_lang_type (RECORD_TYPE); ! TYPE_NAME (t) = get_identifier ("erroneous type"); } ! if (TYPE_SIZE (t)) ! duplicate_tag_error (t); ! if (TYPE_SIZE (t) || TYPE_BEING_DEFINED (t)) { ! t = make_lang_type (TREE_CODE (t)); pushtag (TYPE_IDENTIFIER ($0), t, 0); $0 = t; } ! pushclass (t, 0); ! TYPE_BEING_DEFINED (t) = 1; ! /* Reset the interface data, at the earliest possible ! moment, as it might have been set via a class foo; ! before. */ ! /* Don't change signatures. */ ! if (! IS_SIGNATURE (t)) ! { ! extern tree pending_vtables; ! int needs_writing; ! tree name = TYPE_IDENTIFIER (t); ! ! CLASSTYPE_INTERFACE_ONLY (t) = interface_only; ! SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, interface_unknown); ! ! /* Record how to set the access of this class's ! virtual functions. If write_virtuals == 2 or 3, then ! inline virtuals are ``extern inline''. */ ! switch (write_virtuals) ! { ! case 0: ! case 1: ! needs_writing = 1; ! break; ! case 2: ! needs_writing = !! value_member (name, pending_vtables); ! break; ! case 3: ! needs_writing = ! CLASSTYPE_INTERFACE_ONLY (t) ! && CLASSTYPE_INTERFACE_KNOWN (t); ! break; ! default: ! needs_writing = 0; ! } ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = needs_writing; ! } #if 0 t = TYPE_IDENTIFIER ($0); *************** *** 2790,2795 **** | direct_notype_declarator '(' error ')' type_quals %prec '.' { $$ = build_parse_node (CALL_EXPR, $$, NULL_TREE, NULL_TREE); } - | '(' expr_or_declarator ')' - { $$ = finish_decl_parsing ($2); } | '(' complex_notype_declarator ')' { $$ = $2; } --- 2836,2839 ---- *************** *** 3050,3054 **** .pushlevel paren_cond_or_null { emit_line_note (input_filename, lineno); ! expand_start_cond (bool_truthvalue_conversion ($4), 0); } implicitly_scoped_stmt ; --- 3094,3098 ---- .pushlevel paren_cond_or_null { emit_line_note (input_filename, lineno); ! expand_start_cond ($4, 0); } implicitly_scoped_stmt ; *************** *** 3105,3109 **** cond_stmt_keyword = "while"; } .pushlevel paren_cond_or_null ! { expand_exit_loop_if_false (0, bool_truthvalue_conversion ($4)); } already_scoped_stmt { expand_end_bindings (getdecls (), kept_level_p (), 1); --- 3149,3153 ---- cond_stmt_keyword = "while"; } .pushlevel paren_cond_or_null ! { expand_exit_loop_if_false (0, $4); } already_scoped_stmt { expand_end_bindings (getdecls (), kept_level_p (), 1); *************** *** 3121,3125 **** paren_expr_or_null ';' { emit_line_note (input_filename, lineno); ! expand_exit_loop_if_false (0, bool_truthvalue_conversion ($6)); expand_end_loop (); clear_momentary (); --- 3165,3169 ---- paren_expr_or_null ';' { emit_line_note (input_filename, lineno); ! expand_exit_loop_if_false (0, $6); expand_end_loop (); clear_momentary (); *************** *** 3132,3136 **** .pushlevel xcond ';' { emit_line_note (input_filename, lineno); ! if ($4) expand_exit_loop_if_false (0, bool_truthvalue_conversion ($4)); } xexpr ')' /* Don't let the tree nodes for $7 be discarded --- 3176,3180 ---- .pushlevel xcond ';' { emit_line_note (input_filename, lineno); ! if ($4) expand_exit_loop_if_false (0, $4); } xexpr ')' /* Don't let the tree nodes for $7 be discarded *************** *** 3153,3157 **** .pushlevel xcond ';' { emit_line_note (input_filename, lineno); ! if ($4) expand_exit_loop_if_false (0, bool_truthvalue_conversion ($4)); } xexpr ')' /* Don't let the tree nodes for $7 be discarded --- 3197,3201 ---- .pushlevel xcond ';' { emit_line_note (input_filename, lineno); ! if ($4) expand_exit_loop_if_false (0, $4); } xexpr ')' /* Don't let the tree nodes for $7 be discarded *************** *** 3172,3176 **** | SWITCH .pushlevel '(' condition ')' { emit_line_note (input_filename, lineno); ! c_expand_start_case ($4); /* Don't let the tree nodes for $4 be discarded by clear_momentary during the parsing of the next stmt. */ --- 3216,3220 ---- | SWITCH .pushlevel '(' condition ')' { emit_line_note (input_filename, lineno); ! c_expand_start_case ($4); /* Don't let the tree nodes for $4 be discarded by clear_momentary during the parsing of the next stmt. */ *************** *** 3395,3398 **** --- 3439,3444 ---- | PTYPENAME ':' { goto do_label; } + | TYPENAME ':' + { goto do_label; } ; *************** *** 3551,3558 **** | parm '=' init { $$ = build_tree_list ($3, $$); } ! | parms_comma parm ! { $$ = chainon ($$, build_tree_list (NULL_TREE, $2)); } ! | parms_comma parm '=' init ! { $$ = chainon ($$, build_tree_list ($4, $2)); } | parms_comma bad_parm { $$ = chainon ($$, build_tree_list (NULL_TREE, $2)); } --- 3597,3602 ---- | parm '=' init { $$ = build_tree_list ($3, $$); } ! | parms_comma full_parm ! { $$ = chainon ($$, $2); } | parms_comma bad_parm { $$ = chainon ($$, build_tree_list (NULL_TREE, $2)); } *************** *** 3600,3603 **** --- 3644,3654 ---- ; + full_parm: + parm + { $$ = build_tree_list (NULL_TREE, $$); } + | parm '=' init + { $$ = build_tree_list ($3, $$); } + ; + parm: named_parm *************** *** 3753,3754 **** --- 3804,3815 ---- %% + + #ifdef SPEW_DEBUG + const char * + debug_yytranslate (value) + int value; + { + return yytname[YYTRANSLATE (value)]; + } + + #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/pt.c gcc-2.6.1/cp/pt.c *** gcc-2.6.0/cp/pt.c Wed Jun 29 21:48:56 1994 --- gcc-2.6.1/cp/pt.c Wed Oct 12 12:43:34 1994 *************** *** 82,97 **** tree parm; tree decl = 0; int is_type; parm = next; my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); ! is_type = TREE_CODE (TREE_PURPOSE (parm)) == IDENTIFIER_NODE; if (!is_type) { tree tinfo = 0; ! parm = TREE_PURPOSE (parm); ! my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 260); ! parm = TREE_VALUE (parm); /* is a const-param */ ! parm = grokdeclarator (TREE_VALUE (next), TREE_PURPOSE (next), PARM, 0, NULL_TREE); /* A template parameter is not modifiable. */ --- 82,98 ---- tree parm; tree decl = 0; + tree defval; int is_type; parm = next; my_friendly_assert (TREE_CODE (parm) == TREE_LIST, 259); ! defval = TREE_PURPOSE (parm); ! parm = TREE_VALUE (parm); ! is_type = TREE_PURPOSE (parm) == class_type_node; if (!is_type) { tree tinfo = 0; ! my_friendly_assert (TREE_CODE (TREE_PURPOSE (parm)) == TREE_LIST, 260); /* is a const-param */ ! parm = grokdeclarator (TREE_VALUE (parm), TREE_PURPOSE (parm), PARM, 0, NULL_TREE); /* A template parameter is not modifiable. */ *************** *** 118,126 **** { tree t = make_node (TEMPLATE_TYPE_PARM); ! decl = build_decl (TYPE_DECL, TREE_PURPOSE (parm), t); ! TYPE_NAME (t) = decl; ! TREE_VALUE (parm) = t; } pushdecl (decl); return chainon (list, parm); } --- 119,135 ---- { tree t = make_node (TEMPLATE_TYPE_PARM); ! decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t); ! TYPE_MAIN_DECL (t) = decl; ! parm = decl; ! if (defval) ! { ! if (IDENTIFIER_HAS_TYPE_VALUE (defval)) ! defval = IDENTIFIER_TYPE_VALUE (defval); ! else ! defval = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (defval)); ! } } pushdecl (decl); + parm = build_tree_list (defval, parm); return chainon (list, parm); } *************** *** 136,139 **** --- 145,149 ---- { int nparms = 0; + int saw_default = 0; tree saved_parmlist; tree parm; *************** *** 144,154 **** for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++) { ! tree p = parm; ! if (TREE_CODE (p) == TREE_LIST) { ! tree t = TREE_VALUE (p); ! TREE_VALUE (p) = NULL_TREE; ! p = TREE_PURPOSE (p); ! my_friendly_assert (TREE_CODE (p) == IDENTIFIER_NODE, 261); TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms); } --- 154,170 ---- for (parm = parms, nparms = 0; parm; parm = TREE_CHAIN (parm), nparms++) { ! tree p = TREE_VALUE (parm); ! if (TREE_PURPOSE (parm)) ! saw_default = 1; ! else if (saw_default) ! { ! error ("if a default argument is given for one template parameter"); ! error ("default arguments must be given for all subsequent"); ! error ("parameters as well"); ! } ! ! if (TREE_CODE (p) == TYPE_DECL) { ! tree t = TREE_TYPE (p); TEMPLATE_TYPE_SET_INFO (t, saved_parmlist, nparms); } *************** *** 159,163 **** TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms); } ! TREE_VEC_ELT (saved_parmlist, nparms) = p; } set_current_level_tags_transparency (1); --- 175,179 ---- TEMPLATE_CONST_SET_INFO (tinfo, saved_parmlist, nparms); } ! TREE_VEC_ELT (saved_parmlist, nparms) = parm; } set_current_level_tags_transparency (1); *************** *** 318,322 **** /* we are here for cases like const T* etc. */ grok_template_type (tvec, &TYPE_MAIN_VARIANT (*type)); ! *type = c_build_type_variant (TYPE_MAIN_VARIANT (*type), TYPE_READONLY (*type), TYPE_VOLATILE (*type)); --- 334,338 ---- /* we are here for cases like const T* etc. */ grok_template_type (tvec, &TYPE_MAIN_VARIANT (*type)); ! *type = cp_build_type_variant (TYPE_MAIN_VARIANT (*type), TYPE_READONLY (*type), TYPE_VOLATILE (*type)); *************** *** 355,369 **** tree in_decl; { ! int nparms, i, lost = 0; tree vec; ! if (TREE_CODE (arglist) == TREE_VEC) ! nparms = TREE_VEC_LENGTH (arglist); else ! nparms = list_length (arglist); ! if (nparms != TREE_VEC_LENGTH (parms)) { error ("incorrect number of parameters (%d, should be %d)", ! nparms, TREE_VEC_LENGTH (parms)); if (in_decl) cp_error_at ("in template expansion for decl `%D'", in_decl); --- 371,392 ---- tree in_decl; { ! int nparms, nargs, i, lost = 0; tree vec; ! if (arglist == NULL_TREE) ! nargs = 0; ! else if (TREE_CODE (arglist) == TREE_VEC) ! nargs = TREE_VEC_LENGTH (arglist); else ! nargs = list_length (arglist); ! ! nparms = TREE_VEC_LENGTH (parms); ! ! if (nargs > nparms ! || (nargs < nparms ! && TREE_PURPOSE (TREE_VEC_ELT (parms, nargs)) == NULL_TREE)) { error ("incorrect number of parameters (%d, should be %d)", ! nargs, nparms); if (in_decl) cp_error_at ("in template expansion for decl `%D'", in_decl); *************** *** 371,375 **** } ! if (TREE_CODE (arglist) == TREE_VEC) vec = copy_node (arglist); else --- 394,398 ---- } ! if (arglist && TREE_CODE (arglist) == TREE_VEC) vec = copy_node (arglist); else *************** *** 378,387 **** for (i = 0; i < nparms; i++) { ! tree arg = arglist; ! arglist = TREE_CHAIN (arglist); ! if (arg == error_mark_node) ! lost++; else ! arg = TREE_VALUE (arg); TREE_VEC_ELT (vec, i) = arg; } --- 401,419 ---- for (i = 0; i < nparms; i++) { ! tree arg; ! ! if (arglist) ! { ! arg = arglist; ! arglist = TREE_CHAIN (arglist); ! ! if (arg == error_mark_node) ! lost++; ! else ! arg = TREE_VALUE (arg); ! } else ! arg = TREE_PURPOSE (TREE_VEC_ELT (parms, i)); ! TREE_VEC_ELT (vec, i) = arg; } *************** *** 390,394 **** { tree arg = TREE_VEC_ELT (vec, i); ! tree parm = TREE_VEC_ELT (parms, i); tree val = 0; int is_type, requires_type; --- 422,426 ---- { tree arg = TREE_VEC_ELT (vec, i); ! tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); tree val = 0; int is_type, requires_type; *************** *** 395,403 **** is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; ! requires_type = TREE_CODE (parm) == IDENTIFIER_NODE; if (is_type != requires_type) { if (in_decl) ! cp_error_at ("type/value mismatch in template parameter list for `%D'", in_decl); lost++; TREE_VEC_ELT (vec, i) = error_mark_node; --- 427,436 ---- is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; ! requires_type = TREE_CODE (parm) == TYPE_DECL; if (is_type != requires_type) { if (in_decl) ! cp_error ("type/value mismatch in template parameter list for `%D'", ! in_decl); lost++; TREE_VEC_ELT (vec, i) = error_mark_node; *************** *** 416,420 **** grok_template_type (vec, &TREE_TYPE (parm)); val = digest_init (TREE_TYPE (parm), arg, (tree *) 0); ! if (val == error_mark_node) ; --- 449,453 ---- grok_template_type (vec, &TREE_TYPE (parm)); val = digest_init (TREE_TYPE (parm), arg, (tree *) 0); ! if (val == error_mark_node) ; *************** *** 490,494 **** for (i = 0; i < nparms; i++) { ! tree parm = TREE_VEC_ELT (parms, i), arg = TREE_VEC_ELT (arglist, i); if (i) --- 523,528 ---- for (i = 0; i < nparms; i++) { ! tree parm = TREE_VALUE (TREE_VEC_ELT (parms, i)); ! tree arg = TREE_VEC_ELT (arglist, i); if (i) *************** *** 495,499 **** ccat (','); ! if (TREE_CODE (parm) == IDENTIFIER_NODE) { cat (type_as_string (arg, 0)); --- 529,533 ---- ccat (','); ! if (TREE_CODE (parm) == TYPE_DECL) { cat (type_as_string (arg, 0)); *************** *** 574,578 **** parmlist = DECL_TEMPLATE_PARMS (template); ! arglist = coerce_template_parms (parmlist, arglist, in_decl); if (arglist == error_mark_node) return error_mark_node; --- 608,612 ---- parmlist = DECL_TEMPLATE_PARMS (template); ! arglist = coerce_template_parms (parmlist, arglist, template); if (arglist == error_mark_node) return error_mark_node; *************** *** 620,628 **** { int requires_type, is_type; ! tree parm = TREE_VEC_ELT (parmlist, i); tree arg = TREE_VEC_ELT (arglist, i); tree decl = 0; ! requires_type = TREE_CODE (parm) == IDENTIFIER_NODE; is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; if (is_type) --- 654,662 ---- { int requires_type, is_type; ! tree parm = TREE_VALUE (TREE_VEC_ELT (parmlist, i)); tree arg = TREE_VEC_ELT (arglist, i); tree decl = 0; ! requires_type = TREE_CODE (parm) == TYPE_DECL; is_type = TREE_CODE_CLASS (TREE_CODE (arg)) == 't'; if (is_type) *************** *** 636,640 **** decl = arg; my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 't', 273); ! decl = build_decl (TYPE_DECL, parm, decl); } else --- 670,674 ---- decl = arg; my_friendly_assert (TREE_CODE_CLASS (TREE_CODE (decl)) == 't', 273); ! decl = build_decl (TYPE_DECL, DECL_NAME (parm), decl); } else *************** *** 865,877 **** type = IDENTIFIER_TYPE_VALUE (id); my_friendly_assert (type != 0, 277); ! if (CLASSTYPE_INTERFACE_UNKNOWN (type)) ! { ! DECL_EXTERNAL (t2) = 0; ! TREE_PUBLIC (t2) = 0; ! } ! else { ! DECL_EXTERNAL (t2) = CLASSTYPE_INTERFACE_ONLY (type); ! TREE_PUBLIC (t2) = 1; } break; --- 899,914 ---- type = IDENTIFIER_TYPE_VALUE (id); my_friendly_assert (type != 0, 277); ! if (flag_external_templates) { ! if (CLASSTYPE_INTERFACE_UNKNOWN (type)) ! { ! DECL_EXTERNAL (t2) = 0; ! TREE_PUBLIC (t2) = 0; ! } ! else ! { ! DECL_EXTERNAL (t2) = CLASSTYPE_INTERFACE_ONLY (type); ! TREE_PUBLIC (t2) = 1; ! } } break; *************** *** 879,885 **** /* Failure. */ failure: ! cp_error ("type unification error instantiating %T::%D", ! classname, tdecl); ! cp_error_at ("for template declaration `%D'", tdecl); continue /* loop of members */; --- 916,921 ---- /* Failure. */ failure: ! cp_error_at ("type unification error instantiating `%D'", tdecl); ! cp_error ("while instantiating members of `%T'", classname); continue /* loop of members */; *************** *** 1126,1130 **** && type != void_type_node && type != char_type_node) ! type = c_build_type_variant (tsubst (type, args, nargs, in_decl), TYPE_READONLY (type), TYPE_VOLATILE (type)); --- 1162,1166 ---- && type != void_type_node && type != char_type_node) ! type = cp_build_type_variant (tsubst (type, args, nargs, in_decl), TYPE_READONLY (type), TYPE_VOLATILE (type)); *************** *** 1163,1167 **** case TEMPLATE_TYPE_PARM: ! return c_build_type_variant (args[TEMPLATE_TYPE_IDX (t)], TYPE_READONLY (t), TYPE_VOLATILE (t)); --- 1199,1203 ---- case TEMPLATE_TYPE_PARM: ! return cp_build_type_variant (args[TEMPLATE_TYPE_IDX (t)], TYPE_READONLY (t), TYPE_VOLATILE (t)); *************** *** 1357,1363 **** if (!got_it) { ! r = build_decl_overload (r, TYPE_VALUES (type), ! DECL_CONTEXT (t) != NULL_TREE); r = build_lang_decl (FUNCTION_DECL, r, type); } else if (DECL_INLINE (r) && DECL_SAVED_INSNS (r)) --- 1393,1400 ---- if (!got_it) { ! tree a = build_decl_overload (r, TYPE_VALUES (type), ! DECL_CONTEXT (t) != NULL_TREE); r = build_lang_decl (FUNCTION_DECL, r, type); + DECL_ASSEMBLER_NAME (r) = a; } else if (DECL_INLINE (r) && DECL_SAVED_INSNS (r)) *************** *** 1393,1399 **** --- 1430,1438 ---- DECL_ARGUMENTS (r) = fnargs; DECL_RESULT (r) = result; + #if 0 if (DECL_CONTEXT (t) == NULL_TREE || TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (t))) != 't') push_overloaded_decl_top_level (r, 0); + #endif return r; } *************** *** 1443,1447 **** int len = TREE_VEC_LENGTH (t), need_new = 0, i; tree *elts = (tree *) alloca (len * sizeof (tree)); ! bzero (elts, len * sizeof (tree)); for (i = 0; i < len; i++) --- 1482,1486 ---- int len = TREE_VEC_LENGTH (t), need_new = 0, i; tree *elts = (tree *) alloca (len * sizeof (tree)); ! bzero ((char *) elts, len * sizeof (tree)); for (i = 0; i < len; i++) *************** *** 1473,1477 **** else r = build_reference_type (type); ! r = c_build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t)); /* Will this ever be needed for TYPE_..._TO values? */ layout_type (r); --- 1512,1516 ---- else r = build_reference_type (type); ! r = cp_build_type_variant (r, TYPE_READONLY (t), TYPE_VOLATILE (t)); /* Will this ever be needed for TYPE_..._TO values? */ layout_type (r); *************** *** 1782,1785 **** --- 1821,1825 ---- decl = build_decl (TYPE_DECL, template, t); + SET_DECL_ARTIFICIAL (decl); #if 0 /* fix this later */ *************** *** 1891,1895 **** { template_info = (struct template_info *) permalloc (sizeof (struct template_info)); ! bzero (template_info, sizeof (struct template_info)); DECL_TEMPLATE_INFO (d2) = template_info; } --- 1931,1935 ---- { template_info = (struct template_info *) permalloc (sizeof (struct template_info)); ! bzero ((char *) template_info, sizeof (struct template_info)); DECL_TEMPLATE_INFO (d2) = template_info; } *************** *** 1941,1945 **** if (!subr) ! bzero (targs, sizeof (tree) * ntparms); while (parms --- 1981,1985 ---- if (!subr) ! bzero ((char *) targs, sizeof (tree) * ntparms); while (parms *************** *** 1969,1975 **** } #endif ! if (TREE_CODE (arg) == FUNCTION_TYPE ! || TREE_CODE (arg) == METHOD_TYPE) ! arg = build_pointer_type (arg); switch (unify (tparms, targs, ntparms, parm, arg, nsubsts)) --- 2009,2022 ---- } #endif ! if (TREE_CODE (parm) != REFERENCE_TYPE) ! { ! if (TREE_CODE (arg) == FUNCTION_TYPE ! || TREE_CODE (arg) == METHOD_TYPE) ! arg = build_pointer_type (arg); ! else if (TREE_CODE (arg) == ARRAY_TYPE) ! arg = build_pointer_type (TREE_TYPE (arg)); ! else ! arg = TYPE_MAIN_VARIANT (arg); ! } switch (unify (tparms, targs, ntparms, parm, arg, nsubsts)) *************** *** 2036,2039 **** --- 2083,2093 ---- } idx = TEMPLATE_TYPE_IDX (parm); + /* Template type parameters cannot contain cv-quals; i.e. + template void f (T& a, T& b) will not generate + void f (const int& a, const int& b). */ + if (TYPE_READONLY (arg) > TYPE_READONLY (parm) + || TYPE_VOLATILE (arg) > TYPE_VOLATILE (parm)) + return 1; + arg = TYPE_MAIN_VARIANT (arg); /* Simple cases: Value already set, does match or doesn't. */ if (targs[idx] == arg) *************** *** 2040,2055 **** return 0; else if (targs[idx]) - { - if (TYPE_MAIN_VARIANT (targs[idx]) == TYPE_MAIN_VARIANT (arg)) - /* allow different parms to have different cv-qualifiers */; - else - return 1; - } - /* Check for mixed types and values. */ - if (TREE_CODE (TREE_VEC_ELT (tparms, idx)) != IDENTIFIER_NODE) return 1; ! /* Allow trivial conversions. */ ! if (TYPE_READONLY (parm) < TYPE_READONLY (arg) ! || TYPE_VOLATILE (parm) < TYPE_VOLATILE (arg)) return 1; targs[idx] = arg; --- 2094,2100 ---- return 0; else if (targs[idx]) return 1; ! /* Check for mixed types and values. */ ! if (TREE_CODE (TREE_VALUE (TREE_VEC_ELT (tparms, idx))) != TYPE_DECL) return 1; targs[idx] = arg; *************** *** 2107,2111 **** case REAL_TYPE: case INTEGER_TYPE: ! if (TREE_CODE (parm) == INTEGER_TYPE && TREE_CODE (arg) == INTEGER_TYPE) { if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) --- 2152,2159 ---- case REAL_TYPE: case INTEGER_TYPE: ! if (TREE_CODE (arg) != TREE_CODE (parm)) ! return 1; ! ! if (TREE_CODE (parm) == INTEGER_TYPE) { if (TYPE_MIN_VALUE (parm) && TYPE_MIN_VALUE (arg) *************** *** 2378,2391 **** return; ! if (DECL_EXPLICIT_INSTANTIATION (result) && ! DECL_EXTERNAL (result)) return; SET_DECL_EXPLICIT_INSTANTIATION (result); - TREE_PUBLIC (result) = 1; if (storage == NULL_TREE) ! DECL_EXTERNAL (result) = DECL_INLINE (result) && ! flag_implement_inlines; else if (storage == ridpointers[(int) RID_EXTERN]) ! DECL_EXTERNAL (result) = 1; else cp_error ("storage class `%D' applied to template instantiation", --- 2426,2443 ---- return; ! if (DECL_EXPLICIT_INSTANTIATION (result) && TREE_PUBLIC (result)) return; SET_DECL_EXPLICIT_INSTANTIATION (result); if (storage == NULL_TREE) ! { ! TREE_PUBLIC (result) = 1; ! DECL_EXTERNAL (result) = (DECL_INLINE (result) ! && ! flag_implement_inlines); ! TREE_STATIC (result) = ! DECL_EXTERNAL (result); ! } else if (storage == ridpointers[(int) RID_EXTERN]) ! ; else cp_error ("storage class `%D' applied to template instantiation", *************** *** 2400,2409 **** int extern_p; if (flag_external_templates) return; - if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && ! CLASSTYPE_INTERFACE_ONLY (t)) - return; - if (TYPE_SIZE (t) == NULL_TREE) { --- 2452,2460 ---- int extern_p; + /* With -fexternal-templates, explicit instantiations are treated the same + as implicit ones. */ if (flag_external_templates) return; if (TYPE_SIZE (t) == NULL_TREE) { *************** *** 2424,2451 **** } ! SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = ! extern_p; ! SET_CLASSTYPE_INTERFACE_KNOWN (t); ! CLASSTYPE_INTERFACE_ONLY (t) = extern_p; ! if (! extern_p) ! { ! CLASSTYPE_DEBUG_REQUESTED (t) = 1; ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0; ! rest_of_type_compilation (t, 1); } /* this should really be done by instantiate_member_templates */ { ! tree method = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0); ! for (; method; method = TREE_CHAIN (method)) { ! SET_DECL_EXPLICIT_INSTANTIATION (method); ! TREE_PUBLIC (method) = 1; ! DECL_EXTERNAL (method) ! = (extern_p || (DECL_INLINE (method) && ! flag_implement_inlines)); } ! } ! /* and data member templates, too */ } --- 2475,2534 ---- } ! /* We've already instantiated this. */ ! if (CLASSTYPE_EXPLICIT_INSTANTIATION (t) && CLASSTYPE_INTERFACE_KNOWN (t)) ! { ! if (! extern_p) ! cp_pedwarn ("multiple explicit instantiation of `%#T'", t); ! return; ! } ! ! if (! CLASSTYPE_TEMPLATE_SPECIALIZATION (t)) ! { ! SET_CLASSTYPE_EXPLICIT_INSTANTIATION (t); ! if (! extern_p) ! { ! SET_CLASSTYPE_INTERFACE_KNOWN (t); ! CLASSTYPE_INTERFACE_ONLY (t) = 0; ! CLASSTYPE_VTABLE_NEEDS_WRITING (t) = 1; ! CLASSTYPE_DEBUG_REQUESTED (t) = 1; ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (t)) = 0; ! rest_of_type_compilation (t, 1); ! } } + instantiate_member_templates (TYPE_IDENTIFIER (t)); + /* this should really be done by instantiate_member_templates */ { ! tree tmp = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (t), 0); ! for (; tmp; tmp = TREE_CHAIN (tmp)) ! { ! if (DECL_TEMPLATE_SPECIALIZATION (tmp) ! || (DECL_USE_TEMPLATE (tmp) == 0 ! && CLASSTYPE_TEMPLATE_SPECIALIZATION (t))) ! continue; ! ! SET_DECL_EXPLICIT_INSTANTIATION (tmp); ! if (! extern_p) ! { ! TREE_PUBLIC (tmp) = 1; ! DECL_EXTERNAL (tmp) = (DECL_INLINE (tmp) ! && ! flag_implement_inlines); ! TREE_STATIC (tmp) = ! DECL_EXTERNAL (tmp); ! } ! } ! ! #if 0 ! for (tmp = TYPE_FIELDS (t); tmp; tmp = TREE_CHAIN (tmp)) { ! if (TREE_CODE (tmp) == VAR_DECL) ! /* eventually do something */; } ! #endif ! for (tmp = CLASSTYPE_TAGS (t); tmp; tmp = TREE_CHAIN (tmp)) ! if (IS_AGGR_TYPE (TREE_VALUE (tmp))) ! do_type_instantiation (TYPE_MAIN_DECL (TREE_VALUE (tmp)), storage); ! } } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/search.c gcc-2.6.1/cp/search.c *** gcc-2.6.0/cp/search.c Wed Jun 15 14:29:35 1994 --- gcc-2.6.1/cp/search.c Wed Oct 26 21:19:41 1994 *************** *** 237,241 **** (struct memoized_entry *)obstack_alloc (&type_obstack_entries, sizeof (struct memoized_entry)); ! bzero (p, sizeof (struct memoized_entry)); MEMOIZED_CHAIN (p) = chain; MEMOIZED_UID (p) = ++my_memoized_entry_counter; --- 237,241 ---- (struct memoized_entry *)obstack_alloc (&type_obstack_entries, sizeof (struct memoized_entry)); ! bzero ((char *) p, sizeof (struct memoized_entry)); MEMOIZED_CHAIN (p) = chain; MEMOIZED_UID (p) = ++my_memoized_entry_counter; *************** *** 769,772 **** --- 769,773 ---- tree context; int protected_ok, via_protected; + extern int flag_access_control; #if 1 /* Replaces static decl above. */ *************** *** 777,780 **** --- 778,784 ---- || (TREE_CODE (field) != FUNCTION_DECL && TREE_STATIC (field))); + if (! flag_access_control) + return access_public; + /* The field lives in the current class. */ if (BINFO_TYPE (basetype_path) == current_class_type) *************** *** 1914,1917 **** --- 1918,1925 ---- return NULL_TREE; + baselink = get_virtuals_named_this (binfo); + if (baselink == NULL_TREE) + return NULL_TREE; + drettype = TREE_TYPE (TREE_TYPE (fndecl)); dtypes = TYPE_ARG_TYPES (TREE_TYPE (fndecl)); *************** *** 1921,1926 **** instptr_type = TREE_TYPE (TREE_VALUE (dtypes)); ! for (baselink = get_virtuals_named_this (binfo); ! baselink; baselink = next_baselink (baselink)) { for (tmp = TREE_VALUE (baselink); tmp; tmp = DECL_CHAIN (tmp)) --- 1929,1933 ---- instptr_type = TREE_TYPE (TREE_VALUE (dtypes)); ! for (; baselink; baselink = next_baselink (baselink)) { for (tmp = TREE_VALUE (baselink); tmp; tmp = DECL_CHAIN (tmp)) *************** *** 1946,1950 **** { cp_error ("conflicting return type specified for virtual function `%#D'", fndecl); ! cp_error ("overriding definition as `%#D'", tmp); SET_IDENTIFIER_ERROR_LOCUS (name, basetype); } --- 1953,1957 ---- { cp_error ("conflicting return type specified for virtual function `%#D'", fndecl); ! cp_error_at ("overriding definition as `%#D'", tmp); SET_IDENTIFIER_ERROR_LOCUS (name, basetype); } *************** *** 2698,2702 **** are also marked as being potentially interesting. This avoids the problem of not writing any debug info for intermediate basetypes ! that have abstract virtual functions. */ void --- 2705,2709 ---- are also marked as being potentially interesting. This avoids the problem of not writing any debug info for intermediate basetypes ! that have abstract virtual functions. Also mark member types. */ void *************** *** 2704,2708 **** --- 2711,2724 ---- tree type; { + tree field; dfs_walk (TYPE_BINFO (type), dfs_debug_mark, dfs_debug_unmarkedp); + for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) + { + tree ttype; + if (TREE_CODE (field) == FIELD_DECL + && IS_AGGR_TYPE (ttype = target_type (TREE_TYPE (field))) + && dfs_debug_unmarkedp (TYPE_BINFO (ttype))) + note_debug_info_needed (ttype); + } } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/sig.c gcc-2.6.1/cp/sig.c *** gcc-2.6.0/cp/sig.c Fri Jul 8 16:21:40 1994 --- gcc-2.6.1/cp/sig.c Mon Sep 26 16:13:21 1994 *************** *** 178,182 **** else { ! tree sig_tbl_type = c_build_type_variant (to_type, 1, 0); sptr = build_lang_field_decl (FIELD_DECL, --- 178,182 ---- else { ! tree sig_tbl_type = cp_build_type_variant (to_type, 1, 0); sptr = build_lang_field_decl (FIELD_DECL, diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/spew.c gcc-2.6.1/cp/spew.c *** gcc-2.6.0/cp/spew.c Fri Jun 3 17:37:26 1994 --- gcc-2.6.1/cp/spew.c Wed Oct 12 12:43:51 1994 *************** *** 203,208 **** /* This move does not rely on the system being able to handle overlapping moves. */ ! bcopy (nth_token (0), tmp, old_token_count * sizeof (struct token)); ! bcopy (tmp, nth_token (n), old_token_count * sizeof (struct token)); } first_token = 0; --- 203,210 ---- /* This move does not rely on the system being able to handle overlapping moves. */ ! bcopy ((char *) nth_token (0), tmp, ! old_token_count * sizeof (struct token)); ! bcopy (tmp, (char *) nth_token (n), ! old_token_count * sizeof (struct token)); } first_token = 0; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/tree.c gcc-2.6.1/cp/tree.c *** gcc-2.6.0/cp/tree.c Wed Jul 13 07:04:52 1994 --- gcc-2.6.1/cp/tree.c Wed Oct 26 21:15:44 1994 *************** *** 36,99 **** tree ref; { ! register enum tree_code code = TREE_CODE (ref); ! if (language_lvalue_valid (ref)) { ! if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE) return 1; ! ! switch (code) ! { ! /* preincrements and predecrements are valid lvals, provided ! what they refer to are valid lvals. */ ! case PREINCREMENT_EXPR: ! case PREDECREMENT_EXPR: ! case COMPONENT_REF: ! case SAVE_EXPR: ! return lvalue_p (TREE_OPERAND (ref, 0)); ! ! case STRING_CST: ! return 1; ! ! case VAR_DECL: ! if (TREE_READONLY (ref) && ! TREE_STATIC (ref) ! && DECL_LANG_SPECIFIC (ref) ! && DECL_IN_AGGR_P (ref)) ! return 0; ! case INDIRECT_REF: ! case ARRAY_REF: ! case PARM_DECL: ! case RESULT_DECL: ! case ERROR_MARK: ! if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE ! && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE) ! return 1; ! break; ! case TARGET_EXPR: ! case WITH_CLEANUP_EXPR: ! return 1; ! ! /* A currently unresolved scope ref. */ ! case SCOPE_REF: ! my_friendly_abort (103); ! case OFFSET_REF: ! if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL) ! return 1; ! return lvalue_p (TREE_OPERAND (ref, 0)) ! && lvalue_p (TREE_OPERAND (ref, 1)); ! break; ! case COND_EXPR: ! return (lvalue_p (TREE_OPERAND (ref, 1)) ! && lvalue_p (TREE_OPERAND (ref, 2))); ! case MODIFY_EXPR: ! return 1; ! case COMPOUND_EXPR: ! return lvalue_p (TREE_OPERAND (ref, 1)); ! } } return 0; } --- 36,108 ---- tree ref; { ! if (! language_lvalue_valid (ref)) ! return 0; ! ! if (TREE_CODE (TREE_TYPE (ref)) == REFERENCE_TYPE) ! return 1; ! ! if (ref == current_class_decl && flag_this_is_variable <= 0) ! return 0; ! switch (TREE_CODE (ref)) { ! /* preincrements and predecrements are valid lvals, provided ! what they refer to are valid lvals. */ ! case PREINCREMENT_EXPR: ! case PREDECREMENT_EXPR: ! case COMPONENT_REF: ! case SAVE_EXPR: ! return lvalue_p (TREE_OPERAND (ref, 0)); ! ! case STRING_CST: ! return 1; ! ! case VAR_DECL: ! if (TREE_READONLY (ref) && ! TREE_STATIC (ref) ! && DECL_LANG_SPECIFIC (ref) ! && DECL_IN_AGGR_P (ref)) ! return 0; ! case INDIRECT_REF: ! case ARRAY_REF: ! case PARM_DECL: ! case RESULT_DECL: ! case ERROR_MARK: ! if (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE ! && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE) return 1; ! break; ! case WITH_CLEANUP_EXPR: ! return lvalue_p (TREE_OPERAND (ref, 0)); ! case TARGET_EXPR: ! return 1; ! case CALL_EXPR: ! if (TREE_ADDRESSABLE (TREE_TYPE (ref))) ! return 1; ! break; ! /* A currently unresolved scope ref. */ ! case SCOPE_REF: ! my_friendly_abort (103); ! case OFFSET_REF: ! if (TREE_CODE (TREE_OPERAND (ref, 1)) == FUNCTION_DECL) ! return 1; ! return lvalue_p (TREE_OPERAND (ref, 0)) ! && lvalue_p (TREE_OPERAND (ref, 1)); ! break; ! ! case COND_EXPR: ! return (lvalue_p (TREE_OPERAND (ref, 1)) ! && lvalue_p (TREE_OPERAND (ref, 2))); ! ! case MODIFY_EXPR: ! return 1; ! ! case COMPOUND_EXPR: ! return lvalue_p (TREE_OPERAND (ref, 1)); } + return 0; } *************** *** 222,225 **** --- 231,236 ---- case 'd': /* A decl node */ + #if 0 /* This is bogus. jason 9/21/94 */ + t1 = break_out_calls (DECL_INITIAL (exp)); if (t1 != DECL_INITIAL (exp)) *************** *** 228,231 **** --- 239,243 ---- DECL_INITIAL (exp) = t1; } + #endif return exp; *************** *** 380,383 **** --- 392,429 ---- } + /* Make a variant type in the proper way for C/C++, propagating qualifiers + down to the element type of an array. */ + + tree + cp_build_type_variant (type, constp, volatilep) + tree type; + int constp, volatilep; + { + if (TREE_CODE (type) == ARRAY_TYPE) + { + tree real_main_variant = TYPE_MAIN_VARIANT (type); + + push_obstacks (TYPE_OBSTACK (real_main_variant), + TYPE_OBSTACK (real_main_variant)); + type = build_cplus_array_type (cp_build_type_variant (TREE_TYPE (type), + constp, volatilep), + TYPE_DOMAIN (type)); + + /* TYPE must be on same obstack as REAL_MAIN_VARIANT. If not, + make a copy. (TYPE might have come from the hash table and + REAL_MAIN_VARIANT might be in some function's obstack.) */ + + if (TYPE_OBSTACK (type) != TYPE_OBSTACK (real_main_variant)) + { + type = copy_node (type); + TYPE_POINTER_TO (type) = TYPE_REFERENCE_TO (type) = 0; + } + + TYPE_MAIN_VARIANT (type) = real_main_variant; + pop_obstacks (); + } + return build_type_variant (type, constp, volatilep); + } + /* Add OFFSET to all base types of T. *************** *** 1185,1232 **** } - /* Return the offset (as an INTEGER_CST) for ELEM in LIST. - INITIAL_OFFSET is the value to add to the offset that ELEM's - binfo entry in LIST provides. - - Returns NULL if ELEM does not have an binfo value in LIST. */ - - tree - virtual_offset (elem, list, initial_offset) - tree elem; - tree list; - tree initial_offset; - { - tree vb, offset; - tree rval, nval; - - for (vb = list; vb; vb = TREE_CHAIN (vb)) - if (elem == BINFO_TYPE (vb)) - return size_binop (PLUS_EXPR, initial_offset, BINFO_OFFSET (vb)); - rval = 0; - for (vb = list; vb; vb = TREE_CHAIN (vb)) - { - tree binfos = BINFO_BASETYPES (vb); - int i; - - if (binfos == NULL_TREE) - continue; - - for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--) - { - nval = binfo_value (elem, BINFO_TYPE (TREE_VEC_ELT (binfos, i))); - if (nval) - { - if (rval && BINFO_OFFSET (nval) != BINFO_OFFSET (rval)) - my_friendly_abort (105); - offset = BINFO_OFFSET (vb); - rval = nval; - } - } - } - if (rval == NULL_TREE) - return rval; - return size_binop (PLUS_EXPR, offset, BINFO_OFFSET (rval)); - } - void debug_binfo (elem) --- 1231,1234 ---- *************** *** 1662,1665 **** --- 1664,1692 ---- return t; + case POINTER_TYPE: + return build_pointer_type (make_deep_copy (TREE_TYPE (t))); + case REFERENCE_TYPE: + return build_reference_type (make_deep_copy (TREE_TYPE (t))); + case FUNCTION_TYPE: + return build_function_type (make_deep_copy (TREE_TYPE (t)), + make_deep_copy (TYPE_ARG_TYPES (t))); + case ARRAY_TYPE: + return build_array_type (make_deep_copy (TREE_TYPE (t)), + make_deep_copy (TYPE_DOMAIN (t))); + case OFFSET_TYPE: + return build_offset_type (make_deep_copy (TYPE_OFFSET_BASETYPE (t)), + make_deep_copy (TREE_TYPE (t))); + case METHOD_TYPE: + return build_method_type + (make_deep_copy (TYPE_METHOD_BASETYPE (t)), + build_function_type + (make_deep_copy (TREE_TYPE (t)), + make_deep_copy (TREE_CHAIN (TYPE_ARG_TYPES (t))))); + case RECORD_TYPE: + if (TYPE_PTRMEMFUNC_P (t)) + return build_ptrmemfunc_type + (make_deep_copy (TYPE_PTRMEMFUNC_FN_TYPE (t))); + /* else fall through */ + /* This list is incomplete, but should suffice for now. It is very important that `sorry' does not call *************** *** 1739,1743 **** tree type; { ! return fold (build (PLUS_EXPR, integer_type_node, array_type_nelts (type), integer_one_node)); --- 1766,1770 ---- tree type; { ! return fold (build (PLUS_EXPR, sizetype, array_type_nelts (type), integer_one_node)); *************** *** 1757,1761 **** { tree n = array_type_nelts_top (type); ! sz = fold (build (MULT_EXPR, integer_type_node, sz, n)); type = TREE_TYPE (type); } --- 1784,1788 ---- { tree n = array_type_nelts_top (type); ! sz = fold (build (MULT_EXPR, sizetype, sz, n)); type = TREE_TYPE (type); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/typeck.c gcc-2.6.1/cp/typeck.c *** gcc-2.6.0/cp/typeck.c Sat Jul 9 03:12:25 1994 --- gcc-2.6.1/cp/typeck.c Fri Oct 14 20:31:32 1994 *************** *** 162,166 **** int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like); /* @@ Must do member pointers here. */ ! return c_build_type_variant (type, constflag, volflag); } --- 162,166 ---- int volflag = TYPE_VOLATILE (type) || TYPE_VOLATILE (like); /* @@ Must do member pointers here. */ ! return cp_build_type_variant (type, constflag, volflag); } *************** *** 373,377 **** int volatilep = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2)); ! target = c_build_type_variant (target, constp, volatilep); if (code1 == POINTER_TYPE) t1 = build_pointer_type (target); --- 373,377 ---- int volatilep = TYPE_VOLATILE (TREE_TYPE (t1)) || TYPE_VOLATILE (TREE_TYPE (t2)); ! target = cp_build_type_variant (target, constp, volatilep); if (code1 == POINTER_TYPE) t1 = build_pointer_type (target); *************** *** 735,740 **** if (ttl == ttr) return 1; - if (TREE_CODE (ttr) == TEMPLATE_TYPE_PARM) - return 1; if (TREE_CODE (ttr) != TREE_CODE (ttl)) --- 735,738 ---- *************** *** 814,817 **** --- 812,816 ---- return tt2; + #if 0 /* If they share a virtual baseclass, that's good enough. */ for (tmp = CLASSTYPE_VBASECLASSES (tt1); tmp; tmp = TREE_CHAIN (tmp)) *************** *** 820,823 **** --- 819,823 ---- return BINFO_TYPE (tmp); } + #endif /* Otherwise, try to find a unique baseclass of TT1 *************** *** 905,908 **** --- 905,910 ---- return TREE_PURPOSE (t1) || TREE_PURPOSE (t2); } + #if 0 + /* Default parms are not part of the type of a function. */ if (strict != 3 && TREE_PURPOSE (t1) && TREE_PURPOSE (t2)) { *************** *** 913,916 **** --- 915,919 ---- return 0; } + #endif t1 = TREE_CHAIN (t1); *************** *** 960,965 **** if (p1 == p2) continue; - if (TREE_CODE (p2) == TEMPLATE_TYPE_PARM) - continue; if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE) --- 963,966 ---- *************** *** 971,977 **** continue; - if (TREE_CODE (TREE_TYPE (p2)) == TEMPLATE_TYPE_PARM) - continue; - /* The following is wrong for contravariance, but many programs depend on it. */ --- 972,975 ---- *************** *** 1309,1313 **** { tree t = type_promotes_to (type); ! if (t != TYPE_MAIN_VARIANT (type)) return convert (t, exp); } --- 1307,1311 ---- { tree t = type_promotes_to (type); ! if (t != type) return convert (t, exp); } *************** *** 1381,1385 **** if (TYPE_READONLY (type) || TYPE_VOLATILE (type) || constp || volatilep) ! restype = c_build_type_variant (restype, TYPE_READONLY (type) || constp, TYPE_VOLATILE (type) || volatilep); --- 1379,1383 ---- if (TYPE_READONLY (type) || TYPE_VOLATILE (type) || constp || volatilep) ! restype = cp_build_type_variant (restype, TYPE_READONLY (type) || constp, TYPE_VOLATILE (type) || volatilep); *************** *** 1411,1416 **** --- 1409,1425 ---- tree datum, basetype, field; { + tree dtype; if (datum == error_mark_node) return error_mark_node; + + dtype = TREE_TYPE (datum); + if (TREE_CODE (dtype) == REFERENCE_TYPE) + dtype = TREE_TYPE (dtype); + if (! IS_AGGR_TYPE_CODE (TREE_CODE (dtype))) + { + cp_error ("request for member `%T::%D' in expression of non-aggregate type `%T'", + basetype, field, dtype); + return error_mark_node; + } else if (IS_SIGNATURE (IDENTIFIER_TYPE_VALUE (basetype))) { *************** *** 1525,1530 **** register tree ref; ! /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it ! unless we are not to support things not strictly ANSI. */ switch (TREE_CODE (datum)) { --- 1534,1538 ---- register tree ref; ! /* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference inside it. */ switch (TREE_CODE (datum)) { *************** *** 1698,1702 **** my_friendly_assert (datum != error_mark_node, 311); } ! ref = build (COMPONENT_REF, TREE_TYPE (field), break_out_cleanups (datum), field); if (TREE_READONLY (datum) || TREE_READONLY (field)) --- 1706,1711 ---- my_friendly_assert (datum != error_mark_node, 311); } ! ref = fold (build (COMPONENT_REF, TREE_TYPE (field), ! break_out_cleanups (datum), field)); if (TREE_READONLY (datum) || TREE_READONLY (field)) *************** *** 2520,2530 **** val = TREE_OPERAND (val, 0); ! if ((type == 0 || TREE_CODE (type) != REFERENCE_TYPE) ! && (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE ! || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE)) ! val = default_conversion (val); ! val = require_complete_type (val); if (val == error_mark_node) --- 2529,2541 ---- val = TREE_OPERAND (val, 0); ! if (type == 0 || TREE_CODE (type) != REFERENCE_TYPE) ! { ! if (TREE_CODE (TREE_TYPE (val)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (val)) == FUNCTION_TYPE ! || TREE_CODE (TREE_TYPE (val)) == METHOD_TYPE) ! val = default_conversion (val); ! val = require_complete_type (val); ! } if (val == error_mark_node) *************** *** 2545,2549 **** else { ! #ifdef PROMOTE_PROTOTYPES /* Rather than truncating and then reextending, convert directly to int, if that's the type we will want. */ --- 2556,2561 ---- else { ! #if 0 && defined (PROMOTE_PROTOTYPES) ! /* This breaks user-defined conversions. */ /* Rather than truncating and then reextending, convert directly to int, if that's the type we will want. */ *************** *** 2608,2612 **** if (TREE_PURPOSE (typetail)) { ! while (typetail != void_list_node) { tree type = TREE_VALUE (typetail); --- 2620,2624 ---- if (TREE_PURPOSE (typetail)) { ! for (; typetail != void_list_node; ++i) { tree type = TREE_VALUE (typetail); *************** *** 3248,3251 **** --- 3260,3264 ---- case LT_EXPR: case GT_EXPR: + result_type = bool_type_node; if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) *************** *** 3296,3300 **** op0 = convert (TREE_TYPE (op1), op0); } ! result_type = bool_type_node; converted = 1; break; --- 3309,3314 ---- op0 = convert (TREE_TYPE (op1), op0); } ! else ! result_type = 0; converted = 1; break; *************** *** 3718,3722 **** else /* This conversion is harmless. */ ! rval = convert (argtype, rval); if (! integer_zerop (DECL_FIELD_BITPOS (field))) --- 3732,3736 ---- else /* This conversion is harmless. */ ! rval = convert_force (argtype, rval); if (! integer_zerop (DECL_FIELD_BITPOS (field))) *************** *** 4089,4128 **** if (TREE_CODE (arg) == TREE_LIST) { ! /* Look at methods with only this name. */ ! if (TREE_CODE (TREE_VALUE (arg)) == FUNCTION_DECL) ! { ! tree targ = TREE_VALUE (arg); ! ! /* If this function is unique, or it is a unique ! constructor, we can take its address easily. */ ! if (DECL_CHAIN (targ) == NULL_TREE ! || (DESTRUCTOR_NAME_P (DECL_ASSEMBLER_NAME (targ)) ! && DECL_CHAIN (DECL_CHAIN (targ)) == NULL_TREE)) ! { ! if (DECL_CHAIN (targ)) ! targ = DECL_CHAIN (targ); ! if (DECL_CLASS_CONTEXT (targ)) ! targ = build (OFFSET_REF, TREE_TYPE (targ), C_C_D, targ); ! ! val = unary_complex_lvalue (ADDR_EXPR, targ); ! if (val) ! return val; ! } ! ! /* This possible setting of TREE_CONSTANT is what makes it possible ! with an initializer list to emit the entire thing in the data ! section, rather than a run-time initialization. */ ! arg = build1 (ADDR_EXPR, unknown_type_node, arg); ! if (staticp (targ)) ! TREE_CONSTANT (arg) = 1; ! return arg; ! } if (TREE_CHAIN (arg) == NULL_TREE && TREE_CODE (TREE_VALUE (arg)) == TREE_LIST && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg))) == NULL_TREE) ! { ! /* Unique overloaded member function. */ ! return build_unary_op (ADDR_EXPR, TREE_VALUE (TREE_VALUE (arg)), 0); ! } return build1 (ADDR_EXPR, unknown_type_node, arg); } --- 4103,4116 ---- if (TREE_CODE (arg) == TREE_LIST) { ! if (TREE_CODE (TREE_VALUE (arg)) == FUNCTION_DECL ! && DECL_CHAIN (TREE_VALUE (arg)) == NULL_TREE) ! /* Unique overloaded non-member function. */ ! return build_unary_op (ADDR_EXPR, TREE_VALUE (arg), 0); if (TREE_CHAIN (arg) == NULL_TREE && TREE_CODE (TREE_VALUE (arg)) == TREE_LIST && DECL_CHAIN (TREE_VALUE (TREE_VALUE (arg))) == NULL_TREE) ! /* Unique overloaded member function. */ ! return build_unary_op (ADDR_EXPR, TREE_VALUE (TREE_VALUE (arg)), ! 0); return build1 (ADDR_EXPR, unknown_type_node, arg); } *************** *** 4166,4170 **** { if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)) ! argtype = c_build_type_variant (argtype, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg)); --- 4154,4158 ---- { if (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg)) ! argtype = cp_build_type_variant (argtype, TREE_READONLY (arg), TREE_THIS_VOLATILE (arg)); *************** *** 4574,4578 **** op2 = decl_constant_value (op2); if (type1 != type2) ! type1 = c_build_type_variant (type1, TREE_READONLY (op1) || TREE_READONLY (op2), --- 4562,4566 ---- op2 = decl_constant_value (op2); if (type1 != type2) ! type1 = cp_build_type_variant (type1, TREE_READONLY (op1) || TREE_READONLY (op2), *************** *** 4623,4627 **** result_type = type1; else ! result_type = c_build_type_variant (type1, TREE_READONLY (op1) || TREE_READONLY (op2), --- 4611,4615 ---- result_type = type1; else ! result_type = cp_build_type_variant (type1, TREE_READONLY (op1) || TREE_READONLY (op2), *************** *** 4670,4678 **** if (result_type == error_mark_node) { ! message_2_types (error, "common base type of types `%s' and `%s' is ambiguous", ! TREE_TYPE (type1), TREE_TYPE (type2)); result_type = ptr_type_node; } ! else result_type = TYPE_POINTER_TO (result_type); } else --- 4658,4675 ---- if (result_type == error_mark_node) { ! cp_error ("common base type of types `%T' and `%T' is ambiguous", ! TREE_TYPE (type1), TREE_TYPE (type2)); result_type = ptr_type_node; } ! else ! { ! if (pedantic ! && result_type != TREE_TYPE (type1) ! && result_type != TREE_TYPE (type2)) ! cp_pedwarn ("`%T' and `%T' converted to `%T *' in conditional expression", ! type1, type2, result_type); ! ! result_type = TYPE_POINTER_TO (result_type); ! } } else *************** *** 4940,4944 **** if (TREE_CODE (type) == VOID_TYPE) ! value = build1 (NOP_EXPR, type, value); else if (TREE_TYPE (value) == NULL_TREE || type_unknown_p (value)) --- 4937,4941 ---- if (TREE_CODE (type) == VOID_TYPE) ! value = build1 (CONVERT_EXPR, type, value); else if (TREE_TYPE (value) == NULL_TREE || type_unknown_p (value)) *************** *** 5003,5006 **** --- 5000,5006 ---- #endif + if (TREE_READONLY_DECL_P (value)) + value = decl_constant_value (value); + ovalue = value; value = convert_force (type, value); *************** *** 5327,5333 **** tree olhs = lhs; - /* Types that aren't fully specified cannot be used in assignments. */ - lhs = require_complete_type (lhs); - /* Avoid duplicate error messages from operands that had errors. */ if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) --- 5327,5330 ---- *************** *** 5334,5337 **** --- 5331,5337 ---- return error_mark_node; + /* Types that aren't fully specified cannot be used in assignments. */ + lhs = require_complete_type (lhs); + /* Decide early if we are going to protect RHS from GC before assigning it to LHS. */ *************** *** 5389,5395 **** tree cond = build_conditional_expr (TREE_OPERAND (lhs, 0), ! build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs), ! build_modify_expr (TREE_OPERAND (lhs, 2), modifycode, rhs)); if (TREE_CODE (cond) == ERROR_MARK) --- 5389,5395 ---- tree cond = build_conditional_expr (TREE_OPERAND (lhs, 0), ! build_modify_expr (convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 1)), modifycode, rhs), ! build_modify_expr (convert (TREE_TYPE (lhs), TREE_OPERAND (lhs, 2)), modifycode, rhs)); if (TREE_CODE (cond) == ERROR_MARK) *************** *** 5764,5771 **** if (TREE_CODE (lhstype) == ARRAY_TYPE) { /* Allow array assignment in compiler-generated code. */ if ((pedantic || flag_ansi) && ! DECL_ARTIFICIAL (current_function_decl)) ! pedwarn ("ANSI C++ forbids assignment between arrays"); /* Have to wrap this in RTL_EXPR for two cases: --- 5764,5773 ---- if (TREE_CODE (lhstype) == ARRAY_TYPE) { + int from_array; + /* Allow array assignment in compiler-generated code. */ if ((pedantic || flag_ansi) && ! DECL_ARTIFICIAL (current_function_decl)) ! pedwarn ("ANSI C++ forbids assignment of arrays"); /* Have to wrap this in RTL_EXPR for two cases: *************** *** 5783,5788 **** emit_note (0, -1); expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs, ! 1 + (modifycode != INIT_EXPR)); do_pending_stack_adjust (); --- 5785,5792 ---- emit_note (0, -1); + from_array = TREE_CODE (TREE_TYPE (newrhs)) == ARRAY_TYPE + ? 1 + (modifycode != INIT_EXPR): 0; expand_vec_init (lhs, lhs, array_type_nelts (lhstype), newrhs, ! from_array); do_pending_stack_adjust (); *************** *** 6102,6106 **** } ! if (TREE_CODE (pfn) == TREE_LIST) { pfn = instantiate_type (type, pfn, 1); --- 6106,6112 ---- } ! if (TREE_CODE (pfn) == TREE_LIST ! || (TREE_CODE (pfn) == ADDR_EXPR ! && TREE_CODE (TREE_OPERAND (pfn, 0)) == TREE_LIST)) { pfn = instantiate_type (type, pfn, 1); *************** *** 6107,6111 **** if (pfn == error_mark_node) return error_mark_node; ! pfn = build_unary_op (ADDR_EXPR, pfn, 0); } --- 6113,6118 ---- if (pfn == error_mark_node) return error_mark_node; ! if (TREE_CODE (pfn) != ADDR_EXPR) ! pfn = build_unary_op (ADDR_EXPR, pfn, 0); } *************** *** 6446,6450 **** left_const &= TYPE_READONLY (ttl); ! if (TREE_CODE (ttl) != POINTER_TYPE) break; } --- 6453,6458 ---- left_const &= TYPE_READONLY (ttl); ! if (TREE_CODE (ttl) != POINTER_TYPE ! || TREE_CODE (ttr) != POINTER_TYPE) break; } *************** *** 6562,6569 **** return null_pointer_node; } ! else if (codel == INTEGER_TYPE && (coder == POINTER_TYPE || (coder == RECORD_TYPE && (IS_SIGNATURE_POINTER (rhstype) || IS_SIGNATURE_REFERENCE (rhstype))))) { --- 6570,6578 ---- return null_pointer_node; } ! else if ((codel == INTEGER_TYPE || codel == BOOLEAN_TYPE) && (coder == POINTER_TYPE || (coder == RECORD_TYPE && (IS_SIGNATURE_POINTER (rhstype) + || TYPE_PTRMEMFUNC_FLAG (rhstype) || IS_SIGNATURE_REFERENCE (rhstype))))) { *************** *** 6718,6722 **** return build_signature_pointer_constructor (type, rhs); ! if (IS_AGGR_TYPE (type) && TYPE_NEEDS_CONSTRUCTING (type)) { if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) --- 6727,6732 ---- return build_signature_pointer_constructor (type, rhs); ! if (IS_AGGR_TYPE (type) ! && (TYPE_NEEDS_CONSTRUCTING (type) || TREE_HAS_CONSTRUCTOR (rhs))) { if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) *************** *** 6974,6979 **** || TREE_CODE (whats_returned) == TARGET_EXPR || TREE_CODE (whats_returned) == WITH_CLEANUP_EXPR) ! /* Get the target. */ ! whats_returned = TREE_OPERAND (whats_returned, 0); } --- 6984,6992 ---- || TREE_CODE (whats_returned) == TARGET_EXPR || TREE_CODE (whats_returned) == WITH_CLEANUP_EXPR) ! { ! /* Get the target. */ ! whats_returned = TREE_OPERAND (whats_returned, 0); ! warning ("returning reference to temporary"); ! } } *************** *** 7029,7032 **** --- 7042,7046 ---- retval = TREE_OPERAND (retval, 0); expand_aggr_init (result, retval, 0); + expand_cleanups_to (NULL_TREE); DECL_INITIAL (result) = NULL_TREE; retval = 0; *************** *** 7047,7050 **** --- 7061,7065 ---- { retval = get_temp_regvar (valtype, retval); + expand_cleanups_to (NULL_TREE); use_temp = obey_regdecls; result = 0; *************** *** 7072,7076 **** /* Everything's great--RETVAL is in RESULT. */ if (original_result_rtx) ! store_expr (result, original_result_rtx, 0); else if (retval && retval != result) { --- 7087,7094 ---- /* Everything's great--RETVAL is in RESULT. */ if (original_result_rtx) ! { ! store_expr (result, original_result_rtx, 0); ! expand_cleanups_to (NULL_TREE); ! } else if (retval && retval != result) { *************** *** 7082,7085 **** --- 7100,7106 ---- `expand_return' does the magic of protecting RESULT from cleanups. */ + retval = build1 (CLEANUP_POINT_EXPR, TREE_TYPE (result), retval); + /* This part _must_ come second, because expand_return looks for + the INIT_EXPR as the toplevel node only. :-( */ retval = build (INIT_EXPR, TREE_TYPE (result), result, retval); TREE_SIDE_EFFECTS (retval) = 1; *************** *** 7191,7195 **** } ! expand_start_case (1, exp, type, "switch statement"); return exp; --- 7212,7217 ---- } ! expand_start_case (1, build1 (CLEANUP_POINT_EXPR, TREE_TYPE (exp), exp), ! type, "switch statement"); return exp; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cp/typeck2.c gcc-2.6.1/cp/typeck2.c *** gcc-2.6.0/cp/typeck2.c Sat Jul 9 03:12:33 1994 --- gcc-2.6.1/cp/typeck2.c Thu Sep 29 20:49:58 1994 *************** *** 330,334 **** same situation (call exit). */ ! /* First used: 0 (reserved), Last used: 360. Free: */ static int abortcount = 0; --- 330,334 ---- same situation (call exit). */ ! /* First used: 0 (reserved), Last used: 360. Free: 261. */ static int abortcount = 0; *************** *** 600,603 **** --- 600,604 ---- return value; + #if 0 /* No, that's C. jason 9/19/94 */ else { *************** *** 614,617 **** --- 615,619 ---- } } + #endif DECL_INITIAL (decl) = value; return NULL_TREE; *************** *** 632,636 **** { enum tree_code code = TREE_CODE (type); ! tree element = 0; tree old_tail_contents; /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR --- 634,638 ---- { enum tree_code code = TREE_CODE (type); ! tree element = NULL_TREE; tree old_tail_contents; /* Nonzero if INIT is a braced grouping, which comes in as a CONSTRUCTOR *************** *** 660,665 **** if (init && TYPE_PTRMEMFUNC_P (type) && ((TREE_CODE (init) == ADDR_EXPR ! && TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE ! && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE) || TREE_CODE (init) == TREE_LIST || integer_zerop (init) --- 662,668 ---- if (init && TYPE_PTRMEMFUNC_P (type) && ((TREE_CODE (init) == ADDR_EXPR ! && ((TREE_CODE (TREE_TYPE (init)) == POINTER_TYPE ! && TREE_CODE (TREE_TYPE (TREE_TYPE (init))) == METHOD_TYPE) ! || TREE_CODE (TREE_OPERAND (init, 0)) == TREE_LIST)) || TREE_CODE (init) == TREE_LIST || integer_zerop (init) *************** *** 904,908 **** error ("non-empty initializer for array of empty elements"); /* Just ignore what we were supposed to use. */ ! tail1 = 0; } tail = tail1; --- 907,911 ---- error ("non-empty initializer for array of empty elements"); /* Just ignore what we were supposed to use. */ ! tail1 = NULL_TREE; } tail = tail1; *************** *** 1152,1156 **** { /* We have some work to do. */ ! struct type_chain { tree type; struct type_chain *next; } *chain = 0, *head = 0, scratch; ref = build_unary_op (ADDR_EXPR, datum, 0); while (TREE_CODE (types) == SCOPE_REF) --- 1155,1161 ---- { /* We have some work to do. */ ! struct type_chain ! { tree type; struct type_chain *next; } ! *chain = NULL, *head = NULL, scratch; ref = build_unary_op (ADDR_EXPR, datum, 0); while (TREE_CODE (types) == SCOPE_REF) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cpp.texi gcc-2.6.1/cpp.texi *** gcc-2.6.0/cpp.texi Mon Jul 11 15:09:35 1994 --- gcc-2.6.1/cpp.texi Sun Aug 7 08:57:31 1994 *************** *** 20,24 **** This file documents the GNU C Preprocessor. ! Copyright 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of --- 20,24 ---- This file documents the GNU C Preprocessor. ! Copyright 1987, 1989, 1991, 1992, 1993, 1994 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of *************** *** 54,58 **** @vskip 0pt plus 1filll ! Copyright @copyright{} 1987, 1989, 1991, 1992 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of --- 54,59 ---- @vskip 0pt plus 1filll ! Copyright @copyright{} 1987, 1989, 1991, 1992, 1994 Free Software ! Foundation, Inc. Permission is granted to make and distribute verbatim copies of diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/cse.c gcc-2.6.1/cse.c *** gcc-2.6.0/cse.c Mon Jul 4 11:14:19 1994 --- gcc-2.6.1/cse.c Tue Nov 1 18:38:40 1994 *************** *** 619,623 **** static void merge_equiv_classes PROTO((struct table_elt *, struct table_elt *)); ! static void invalidate PROTO((rtx)); static void remove_invalid_refs PROTO((int)); static void rehash_using_reg PROTO((rtx)); --- 619,623 ---- static void merge_equiv_classes PROTO((struct table_elt *, struct table_elt *)); ! static void invalidate PROTO((rtx, enum machine_mode)); static void remove_invalid_refs PROTO((int)); static void rehash_using_reg PROTO((rtx)); *************** *** 1467,1471 **** if (insert_regs (exp, class1, 0)) ! hash = HASH (exp, mode); new = insert (exp, class1, hash, mode); new->in_memory = hash_arg_in_memory; --- 1467,1474 ---- if (insert_regs (exp, class1, 0)) ! { ! rehash_using_reg (exp); ! hash = HASH (exp, mode); ! } new = insert (exp, class1, hash, mode); new->in_memory = hash_arg_in_memory; *************** *** 1481,1484 **** --- 1484,1490 ---- all memory references are removed by invalidate_memory so specific invalidation is superfluous). + FULL_MODE, if not VOIDmode, indicates that this much should be invalidated + instead of just the amount indicated by the mode of X. This is only used + for bitfield stores into memory. A nonvarying address may be just a register or just *************** *** 1487,1492 **** static void ! invalidate (x) rtx x; { register int i; --- 1493,1499 ---- static void ! invalidate (x, full_mode) rtx x; + enum machine_mode full_mode; { register int i; *************** *** 1563,1567 **** if (GET_CODE (SUBREG_REG (x)) != REG) abort (); ! invalidate (SUBREG_REG (x)); return; } --- 1570,1574 ---- if (GET_CODE (SUBREG_REG (x)) != REG) abort (); ! invalidate (SUBREG_REG (x), VOIDmode); return; } *************** *** 1574,1578 **** abort (); ! set_nonvarying_address_components (XEXP (x, 0), GET_MODE_SIZE (GET_MODE (x)), &base, &start, &end); --- 1581,1588 ---- abort (); ! if (full_mode == VOIDmode) ! full_mode = GET_MODE (x); ! ! set_nonvarying_address_components (XEXP (x, 0), GET_MODE_SIZE (full_mode), &base, &start, &end); *************** *** 1712,1716 **** reg_tick[regno]++; ! in_table |= TEST_HARD_REG_BIT (hard_regs_in_table, regno); } --- 1722,1726 ---- reg_tick[regno]++; ! in_table |= (TEST_HARD_REG_BIT (hard_regs_in_table, regno) != 0); } *************** *** 1949,1964 **** { rtx tem = XEXP (x, i); - rtx tem1; - /* If the operand is a REG that is equivalent to a constant, hash - as if we were hashing the constant, since we will be comparing - that way. */ - if (tem != 0 && GET_CODE (tem) == REG - && REGNO_QTY_VALID_P (REGNO (tem)) - && qty_mode[reg_qty[REGNO (tem)]] == GET_MODE (tem) - && (tem1 = qty_const[reg_qty[REGNO (tem)]]) != 0 - && CONSTANT_P (tem1)) - tem = tem1; - /* If we are about to do the last recursive call needed at this level, change it into iteration. --- 1959,1963 ---- *************** *** 2231,2237 **** the starting offset, and ending offset respectively. ! ADDR is known to be a nonvarying address. ! cse_address_varies_p returns zero for nonvarying addresses. */ static void --- 2230,2237 ---- the starting offset, and ending offset respectively. ! ADDR is known to be a nonvarying address. */ ! /* ??? Despite what the comments say, this function is in fact frequently ! passed varying addresses. This does not appear to cause any problems. */ static void *************** *** 2324,2327 **** --- 2324,2333 ---- } + if (GET_CODE (base) == CONST_INT) + { + start += INTVAL (base); + base = const0_rtx; + } + end = start + size; *************** *** 2354,2364 **** register char *fmt; - if (GET_CODE (base) == CONST_INT) - { - start += INTVAL (base); - end += INTVAL (base); - base = const0_rtx; - } - repeat: if (x == 0) --- 2360,2363 ---- *************** *** 3087,3091 **** /* We can do some operations on integer CONST_DOUBLEs. Also allow for a DImode operation on a CONST_INT. */ ! else if (GET_MODE (op) == VOIDmode && width == HOST_BITS_PER_INT * 2 && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)) { --- 3086,3090 ---- /* We can do some operations on integer CONST_DOUBLEs. Also allow for a DImode operation on a CONST_INT. */ ! else if (GET_MODE (op) == VOIDmode && width <= HOST_BITS_PER_INT * 2 && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT)) { *************** *** 3124,3131 **** case TRUNCATE: ! if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT) ! return GEN_INT (l1 & GET_MODE_MASK (mode)); ! else ! return 0; break; --- 3123,3128 ---- case TRUNCATE: ! /* This is just a change-of-mode, so do nothing. */ ! lv = l1, hv = h1; break; *************** *** 3221,3225 **** return x; } ! else if (GET_CODE (op) == CONST_DOUBLE && GET_MODE_CLASS (mode) == MODE_INT && width <= HOST_BITS_PER_WIDE_INT && width > 0) { --- 3218,3225 ---- return x; } ! ! else if (GET_CODE (op) == CONST_DOUBLE ! && GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT ! && GET_MODE_CLASS (mode) == MODE_INT && width <= HOST_BITS_PER_WIDE_INT && width > 0) { *************** *** 5002,5006 **** new = gen_rtx (TRUNCATE, GET_MODE (table), new); ! return new; } } --- 5002,5010 ---- new = gen_rtx (TRUNCATE, GET_MODE (table), new); ! /* Indicate this is a constant. This isn't a ! valid form of CONST, but it will only be used ! to fold the next insns and then discarded, so ! it should be safe. */ ! return gen_rtx (CONST, GET_MODE (new), new); } } *************** *** 5175,5185 **** { case '1': ! /* We can't simplify extension ops unless we know the original mode. */ ! if ((code == ZERO_EXTEND || code == SIGN_EXTEND) ! && mode_arg0 == VOIDmode) ! break; ! new = simplify_unary_operation (code, mode, ! const_arg0 ? const_arg0 : folded_arg0, ! mode_arg0); break; --- 5179,5202 ---- { case '1': ! { ! int is_const = 0; ! ! /* We can't simplify extension ops unless we know the ! original mode. */ ! if ((code == ZERO_EXTEND || code == SIGN_EXTEND) ! && mode_arg0 == VOIDmode) ! break; ! ! /* If we had a CONST, strip it off and put it back later if we ! fold. */ ! if (const_arg0 != 0 && GET_CODE (const_arg0) == CONST) ! is_const = 1, const_arg0 = XEXP (const_arg0, 0); ! ! new = simplify_unary_operation (code, mode, ! const_arg0 ? const_arg0 : folded_arg0, ! mode_arg0); ! if (new != 0 && is_const) ! new = gen_rtx (CONST, mode, new); ! } break; *************** *** 5354,5358 **** if (const_arg1 && GET_CODE (const_arg1) == LABEL_REF) { ! rtx y = lookup_as_function (folded_arg0, MINUS); if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF --- 5371,5377 ---- if (const_arg1 && GET_CODE (const_arg1) == LABEL_REF) { ! rtx y ! = GET_CODE (folded_arg0) == MINUS ? folded_arg0 ! : lookup_as_function (folded_arg0, MINUS); if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF *************** *** 5359,5362 **** --- 5378,5409 ---- && XEXP (XEXP (y, 1), 0) == XEXP (const_arg1, 0)) return XEXP (y, 0); + + /* Now try for a CONST of a MINUS like the above. */ + if ((y = (GET_CODE (folded_arg0) == CONST ? folded_arg0 + : lookup_as_function (folded_arg0, CONST))) != 0 + && GET_CODE (XEXP (y, 0)) == MINUS + && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF + && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg1, 0)) + return XEXP (XEXP (y, 0), 0); + } + + /* Likewise if the operands are in the other order. */ + if (const_arg0 && GET_CODE (const_arg0) == LABEL_REF) + { + rtx y + = GET_CODE (folded_arg1) == MINUS ? folded_arg1 + : lookup_as_function (folded_arg1, MINUS); + + if (y != 0 && GET_CODE (XEXP (y, 1)) == LABEL_REF + && XEXP (XEXP (y, 1), 0) == XEXP (const_arg0, 0)) + return XEXP (y, 0); + + /* Now try for a CONST of a MINUS like the above. */ + if ((y = (GET_CODE (folded_arg1) == CONST ? folded_arg1 + : lookup_as_function (folded_arg1, CONST))) != 0 + && GET_CODE (XEXP (y, 0)) == MINUS + && GET_CODE (XEXP (XEXP (y, 0), 1)) == LABEL_REF + && XEXP (XEXP (XEXP (y, 0),1), 0) == XEXP (const_arg0, 0)) + return XEXP (XEXP (y, 0), 0); } *************** *** 5760,5763 **** --- 5807,5817 ---- op1_elt = lookup (op1, op1_hash, mode); + /* If both operands are already equivalent or if they are not in the + table but are identical, do nothing. */ + if ((op0_elt != 0 && op1_elt != 0 + && op0_elt->first_same_value == op1_elt->first_same_value) + || op0 == op1 || rtx_equal_p (op0, op1)) + return; + /* If we aren't setting two things equal all we can do is save this comparison. Similarly if this is floating-point. In the latter *************** *** 5946,5950 **** for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1)) if (GET_CODE (XEXP (tem, 0)) == CLOBBER) ! invalidate (SET_DEST (XEXP (tem, 0))); } --- 6000,6004 ---- for (tem = CALL_INSN_FUNCTION_USAGE (insn); tem; tem = XEXP (tem, 1)) if (GET_CODE (XEXP (tem, 0)) == CLOBBER) ! invalidate (SET_DEST (XEXP (tem, 0)), VOIDmode); } *************** *** 5977,5981 **** apply_change_group (); fold_rtx (SET_SRC (x), insn); ! invalidate (SET_DEST (x)); } else --- 6031,6035 ---- apply_change_group (); fold_rtx (SET_SRC (x), insn); ! invalidate (SET_DEST (x), VOIDmode); } else *************** *** 6008,6015 **** if (GET_CODE (clobbered) == REG || GET_CODE (clobbered) == SUBREG) ! invalidate (clobbered); else if (GET_CODE (clobbered) == STRICT_LOW_PART || GET_CODE (clobbered) == ZERO_EXTRACT) ! invalidate (XEXP (clobbered, 0)); } } --- 6062,6069 ---- if (GET_CODE (clobbered) == REG || GET_CODE (clobbered) == SUBREG) ! invalidate (clobbered, VOIDmode); else if (GET_CODE (clobbered) == STRICT_LOW_PART || GET_CODE (clobbered) == ZERO_EXTRACT) ! invalidate (XEXP (clobbered, 0), GET_MODE (clobbered)); } } *************** *** 6027,6031 **** apply_change_group (); fold_rtx (SET_SRC (y), insn); ! invalidate (SET_DEST (y)); } else if (SET_DEST (y) == pc_rtx --- 6081,6085 ---- apply_change_group (); fold_rtx (SET_SRC (y), insn); ! invalidate (SET_DEST (y), VOIDmode); } else if (SET_DEST (y) == pc_rtx *************** *** 6664,6668 **** else if (constant_pool_entries_cost && CONSTANT_P (trial) ! && (src_folded == 0 || GET_CODE (src_folded) != MEM) && GET_MODE_CLASS (mode) != MODE_CC) { --- 6718,6726 ---- else if (constant_pool_entries_cost && CONSTANT_P (trial) ! && ! (GET_CODE (trial) == CONST ! && GET_CODE (XEXP (trial, 0)) == TRUNCATE) ! && (src_folded == 0 ! || (GET_CODE (src_folded) != MEM ! && ! src_folded_force_flag)) && GET_MODE_CLASS (mode) != MODE_CC) { *************** *** 6917,6924 **** if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG || GET_CODE (dest) == MEM) ! invalidate (dest); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0)); sets[i].rtl = 0; } --- 6975,6982 ---- if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG || GET_CODE (dest) == MEM) ! invalidate (dest, VOIDmode); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0), GET_MODE (dest)); sets[i].rtl = 0; } *************** *** 6966,6970 **** } if (insert_regs (src_eqv, classp, 0)) ! src_eqv_hash = HASH (src_eqv, eqvmode); elt = insert (src_eqv, classp, src_eqv_hash, eqvmode); elt->in_memory = src_eqv_in_memory; --- 7024,7031 ---- } if (insert_regs (src_eqv, classp, 0)) ! { ! rehash_using_reg (src_eqv); ! src_eqv_hash = HASH (src_eqv, eqvmode); ! } elt = insert (src_eqv, classp, src_eqv_hash, eqvmode); elt->in_memory = src_eqv_in_memory; *************** *** 7013,7017 **** match if not still valid. */ if (insert_regs (src, classp, 0)) ! sets[i].src_hash = HASH (src, mode); elt = insert (src, classp, sets[i].src_hash, mode); elt->in_memory = sets[i].src_in_memory; --- 7074,7081 ---- match if not still valid. */ if (insert_regs (src, classp, 0)) ! { ! rehash_using_reg (src); ! sets[i].src_hash = HASH (src, mode); ! } elt = insert (src, classp, sets[i].src_hash, mode); elt->in_memory = sets[i].src_in_memory; *************** *** 7055,7059 **** if (sets[i].rtl) { ! register rtx dest = sets[i].inner_dest; /* Needed for registers to remove the register from its --- 7119,7125 ---- if (sets[i].rtl) { ! /* We can't use the inner dest, because the mode associated with ! a ZERO_EXTRACT is significant. */ ! register rtx dest = SET_DEST (sets[i].rtl); /* Needed for registers to remove the register from its *************** *** 7062,7070 **** we have just done an invalidate_memory that covers even those. */ if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG ! || (! writes_memory.all && ! cse_rtx_addr_varies_p (dest))) ! invalidate (dest); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0)); } --- 7128,7137 ---- we have just done an invalidate_memory that covers even those. */ if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG ! || (GET_CODE (dest) == MEM && ! writes_memory.all ! && ! cse_rtx_addr_varies_p (dest))) ! invalidate (dest, VOIDmode); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0), GET_MODE (dest)); } *************** *** 7123,7127 **** /* If we didn't put a REG_EQUAL value or a source into the hash table, there is no point is recording DEST. */ ! || sets[i].src_elt == 0) continue; --- 7190,7204 ---- /* If we didn't put a REG_EQUAL value or a source into the hash table, there is no point is recording DEST. */ ! || sets[i].src_elt == 0 ! /* If DEST is a paradoxical SUBREG and SRC is a ZERO_EXTEND ! or SIGN_EXTEND, don't record DEST since it can cause ! some tracking to be wrong. ! ! ??? Think about this more later. */ ! || (GET_CODE (dest) == SUBREG ! && (GET_MODE_SIZE (GET_MODE (dest)) ! > GET_MODE_SIZE (GET_MODE (SUBREG_REG (dest)))) ! && (GET_CODE (sets[i].src) == SIGN_EXTEND ! || GET_CODE (sets[i].src) == ZERO_EXTEND))) continue; *************** *** 7135,7141 **** /* Registers must also be inserted into chains for quantities. */ if (insert_regs (dest, sets[i].src_elt, 1)) ! /* If `insert_regs' changes something, the hash code must be ! recalculated. */ ! sets[i].dest_hash = HASH (dest, GET_MODE (dest)); elt = insert (dest, sets[i].src_elt, --- 7212,7221 ---- /* Registers must also be inserted into chains for quantities. */ if (insert_regs (dest, sets[i].src_elt, 1)) ! { ! /* If `insert_regs' changes something, the hash code must be ! recalculated. */ ! rehash_using_reg (dest); ! sets[i].dest_hash = HASH (dest, GET_MODE (dest)); ! } elt = insert (dest, sets[i].src_elt, *************** *** 7201,7205 **** { if (insert_regs (new_src, classp, 0)) ! src_hash = HASH (new_src, new_mode); src_elt = insert (new_src, classp, src_hash, new_mode); src_elt->in_memory = elt->in_memory; --- 7281,7288 ---- { if (insert_regs (new_src, classp, 0)) ! { ! rehash_using_reg (new_src); ! src_hash = HASH (new_src, new_mode); ! } src_elt = insert (new_src, classp, src_hash, new_mode); src_elt->in_memory = elt->in_memory; *************** *** 7378,7382 **** /* This should be *very* rare. */ if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM)) ! invalidate (stack_pointer_rtx); } --- 7461,7465 ---- /* This should be *very* rare. */ if (TEST_HARD_REG_BIT (hard_regs_in_table, STACK_POINTER_REGNUM)) ! invalidate (stack_pointer_rtx, VOIDmode); } *************** *** 7388,7395 **** if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG || (GET_CODE (ref) == MEM && ! w->all)) ! invalidate (ref); else if (GET_CODE (ref) == STRICT_LOW_PART || GET_CODE (ref) == ZERO_EXTRACT) ! invalidate (XEXP (ref, 0)); } } --- 7471,7478 ---- if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG || (GET_CODE (ref) == MEM && ! w->all)) ! invalidate (ref, VOIDmode); else if (GET_CODE (ref) == STRICT_LOW_PART || GET_CODE (ref) == ZERO_EXTRACT) ! invalidate (XEXP (ref, 0), GET_MODE (ref)); } } *************** *** 7407,7414 **** if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG || (GET_CODE (ref) == MEM && !w->all)) ! invalidate (ref); else if (GET_CODE (ref) == STRICT_LOW_PART || GET_CODE (ref) == ZERO_EXTRACT) ! invalidate (XEXP (ref, 0)); } } --- 7490,7497 ---- if (GET_CODE (ref) == REG || GET_CODE (ref) == SUBREG || (GET_CODE (ref) == MEM && !w->all)) ! invalidate (ref, VOIDmode); else if (GET_CODE (ref) == STRICT_LOW_PART || GET_CODE (ref) == ZERO_EXTRACT) ! invalidate (XEXP (ref, 0), GET_MODE (ref)); } } *************** *** 7538,7546 **** p = p->next_same_value) if (GET_CODE (p->exp) == MEM || GET_CODE (p->exp) == REG ! || GET_CODE (p->exp) == SUBREG) ! invalidate (p->exp); else if (GET_CODE (p->exp) == STRICT_LOW_PART || GET_CODE (p->exp) == ZERO_EXTRACT) ! invalidate (XEXP (p->exp, 0)); /* Process insns starting after LOOP_START until we hit a CALL_INSN or --- 7621,7630 ---- p = p->next_same_value) if (GET_CODE (p->exp) == MEM || GET_CODE (p->exp) == REG ! || (GET_CODE (p->exp) == SUBREG ! && GET_CODE (SUBREG_REG (p->exp)) == REG)) ! invalidate (p->exp, VOIDmode); else if (GET_CODE (p->exp) == STRICT_LOW_PART || GET_CODE (p->exp) == ZERO_EXTRACT) ! invalidate (XEXP (p->exp, 0), GET_MODE (p->exp)); /* Process insns starting after LOOP_START until we hit a CALL_INSN or *************** *** 7601,7608 **** if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG || (! skipped_writes_memory.all && ! cse_rtx_addr_varies_p (dest))) ! invalidate (dest); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0)); } --- 7685,7692 ---- if (GET_CODE (dest) == REG || GET_CODE (dest) == SUBREG || (! skipped_writes_memory.all && ! cse_rtx_addr_varies_p (dest))) ! invalidate (dest, VOIDmode); else if (GET_CODE (dest) == STRICT_LOW_PART || GET_CODE (dest) == ZERO_EXTRACT) ! invalidate (XEXP (dest, 0), GET_MODE (dest)); } *************** *** 7756,7763 **** || (GET_CODE (SET_DEST (x)) == MEM && ! writes_memory.all && ! cse_rtx_addr_varies_p (SET_DEST (x)))) ! invalidate (SET_DEST (x)); else if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT) ! invalidate (XEXP (SET_DEST (x), 0)); } --- 7840,7847 ---- || (GET_CODE (SET_DEST (x)) == MEM && ! writes_memory.all && ! cse_rtx_addr_varies_p (SET_DEST (x)))) ! invalidate (SET_DEST (x), VOIDmode); else if (GET_CODE (SET_DEST (x)) == STRICT_LOW_PART || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT) ! invalidate (XEXP (SET_DEST (x), 0), GET_MODE (SET_DEST (x))); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/dbxout.c gcc-2.6.1/dbxout.c *** gcc-2.6.0/dbxout.c Tue Jul 12 08:11:12 1994 --- gcc-2.6.1/dbxout.c Fri Sep 9 17:02:25 1994 *************** *** 1844,1848 **** letter = decl_function_context (decl) ? 'V' : 'S'; ! if (!DECL_INITIAL (decl)) current_sym_code = N_LCSYM; else if (DECL_IN_TEXT_SECTION (decl)) --- 1844,1854 ---- letter = decl_function_context (decl) ? 'V' : 'S'; ! /* This should be the same condition as in assemble_variable, but ! we don't have access to dont_output_data here. So, instead, ! we rely on the fact that error_mark_node initializers always ! end up in bss for C++ and never end up in bss for C. */ ! if (DECL_INITIAL (decl) == 0 ! || (!strcmp (lang_identify (), "cplusplus") ! && DECL_INITIAL (decl) == error_mark_node)) current_sym_code = N_LCSYM; else if (DECL_IN_TEXT_SECTION (decl)) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/dwarfout.c gcc-2.6.1/dwarfout.c *** gcc-2.6.0/dwarfout.c Wed Mar 23 16:32:33 1994 --- gcc-2.6.1/dwarfout.c Thu Jul 28 19:55:34 1994 *************** *** 4436,4508 **** else { ! register tree arg_decls = DECL_ARGUMENTS (decl); ! ! { ! register tree last_arg; ! ! last_arg = (arg_decls && TREE_CODE (arg_decls) != ERROR_MARK) ! ? tree_last (arg_decls) ! : NULL; ! ! /* Generate DIEs to represent all known formal parameters, but ! don't do it if this looks like a varargs function. A given ! function is considered to be a varargs function if (and only ! if) its last named argument is named `__builtin_va_alist'. */ ! ! if (! last_arg ! || ! DECL_NAME (last_arg) ! || strcmp (IDENTIFIER_POINTER (DECL_NAME (last_arg)), ! "__builtin_va_alist")) ! { ! register tree parm; ! /* WARNING! Kludge zone ahead! Here we have a special ! hack for svr4 SDB compatibility. Instead of passing the ! current FUNCTION_DECL node as the second parameter (i.e. ! the `containing_scope' parameter) to `output_decl' (as ! we ought to) we instead pass a pointer to our own private ! fake_containing_scope node. That node is a RECORD_TYPE ! node which NO OTHER TYPE may ever actually be a member of. ! ! This pointer will ultimately get passed into `output_type' ! as its `containing_scope' parameter. `Output_type' will ! then perform its part in the hack... i.e. it will pend ! the type of the formal parameter onto the pending_types ! list. Later on, when we are done generating the whole ! sequence of formal parameter DIEs for this function ! definition, we will un-pend all previously pended types ! of formal parameters for this function definition. ! ! This whole kludge prevents any type DIEs from being ! mixed in with the formal parameter DIEs. That's good ! because svr4 SDB believes that the list of formal ! parameter DIEs for a function ends wherever the first ! non-formal-parameter DIE appears. Thus, we have to ! keep the formal parameter DIEs segregated. They must ! all appear (consecutively) at the start of the list of ! children for the DIE representing the function definition. ! Then (and only then) may we output any additional DIEs ! needed to represent the types of these formal parameters. ! */ ! ! for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) ! if (TREE_CODE (parm) == PARM_DECL) ! output_decl (parm, fake_containing_scope); ! ! /* Now that we have finished generating all of the DIEs to ! represent the formal parameters themselves, force out ! any DIEs needed to represent their types. We do this ! simply by un-pending all previously pended types which ! can legitimately go into the chain of children DIEs for ! the current FUNCTION_DECL. */ ! output_pending_types_for_scope (decl); } - } ! /* Now try to decide if we should put an ellipsis at the end. */ { - register int has_ellipsis = TRUE; /* default assumption */ register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); --- 4436,4510 ---- else { ! /* Generate DIEs to represent all known formal parameters */ ! register tree arg_decls = DECL_ARGUMENTS (decl); ! register tree parm; ! /* WARNING! Kludge zone ahead! Here we have a special ! hack for svr4 SDB compatibility. Instead of passing the ! current FUNCTION_DECL node as the second parameter (i.e. ! the `containing_scope' parameter) to `output_decl' (as ! we ought to) we instead pass a pointer to our own private ! fake_containing_scope node. That node is a RECORD_TYPE ! node which NO OTHER TYPE may ever actually be a member of. ! ! This pointer will ultimately get passed into `output_type' ! as its `containing_scope' parameter. `Output_type' will ! then perform its part in the hack... i.e. it will pend ! the type of the formal parameter onto the pending_types ! list. Later on, when we are done generating the whole ! sequence of formal parameter DIEs for this function ! definition, we will un-pend all previously pended types ! of formal parameters for this function definition. ! ! This whole kludge prevents any type DIEs from being ! mixed in with the formal parameter DIEs. That's good ! because svr4 SDB believes that the list of formal ! parameter DIEs for a function ends wherever the first ! non-formal-parameter DIE appears. Thus, we have to ! keep the formal parameter DIEs segregated. They must ! all appear (consecutively) at the start of the list of ! children for the DIE representing the function definition. ! Then (and only then) may we output any additional DIEs ! needed to represent the types of these formal parameters. ! */ ! ! /* ! When generating DIEs, generate the unspecified_parameters ! DIE instead if we come across the arg "__builtin_va_alist" ! */ ! ! for (parm = arg_decls; parm; parm = TREE_CHAIN (parm)) ! if (TREE_CODE (parm) == PARM_DECL) ! { ! if (DECL_NAME(parm) && ! !strcmp(IDENTIFIER_POINTER(DECL_NAME(parm)), ! "__builtin_va_alist") ) ! output_die (output_unspecified_parameters_die, decl); ! else ! output_decl (parm, fake_containing_scope); } ! /* ! Now that we have finished generating all of the DIEs to ! represent the formal parameters themselves, force out ! any DIEs needed to represent their types. We do this ! simply by un-pending all previously pended types which ! can legitimately go into the chain of children DIEs for ! the current FUNCTION_DECL. ! */ ! ! output_pending_types_for_scope (decl); ! ! /* ! Decide whether we need a unspecified_parameters DIE at the end. ! There are 2 more cases to do this for: ! 1) the ansi ... declaration - this is detectable when the end ! of the arg list is not a void_type_node ! 2) an unprototyped function declaration (not a definition). This ! just means that we have no info about the parameters at all. ! */ { register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl)); *************** *** 4509,4551 **** if (fn_arg_types) { ! /* This function declaration/definition was prototyped. */ ! ! /* If the list of formal argument types ends with a ! void_type_node, then the formals list did *not* end ! with an ellipsis. */ ! ! if (TREE_VALUE (tree_last (fn_arg_types)) == void_type_node) ! has_ellipsis = FALSE; ! } ! else ! { ! /* This function declaration/definition was not prototyped. */ ! ! /* Note that all non-prototyped function *declarations* are ! assumed to represent varargs functions (until proven ! otherwise). */ ! ! if (DECL_INITIAL (decl)) /* if this is a func definition */ ! { ! if (!arg_decls) ! has_ellipsis = FALSE; /* no args == (void) */ ! else ! { ! /* For a non-prototyped function definition which ! declares one or more formal parameters, if the name ! of the first formal parameter is *not* ! __builtin_va_alist then we must assume that this ! is *not* a varargs function. */ ! ! if (DECL_NAME (arg_decls) ! && strcmp (IDENTIFIER_POINTER (DECL_NAME (arg_decls)), ! "__builtin_va_alist")) ! has_ellipsis = FALSE; ! } ! } ! } ! ! if (has_ellipsis) ! output_die (output_unspecified_parameters_die, decl); } } --- 4511,4524 ---- if (fn_arg_types) { ! /* this is the prototyped case, check for ... */ ! if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node) ! output_die (output_unspecified_parameters_die, decl); ! } ! else ! { ! /* this is unprotoyped, check for undefined (just declaration) */ ! if (!DECL_INITIAL (decl)) ! output_die (output_unspecified_parameters_die, decl); ! } } } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/emit-rtl.c gcc-2.6.1/emit-rtl.c *** gcc-2.6.0/emit-rtl.c Tue Jun 14 18:00:32 1994 --- gcc-2.6.1/emit-rtl.c Sat Oct 29 21:15:29 1994 *************** *** 1177,1181 **** if (GET_MODE_CLASS (mode) != MODE_INT || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE) ! || BITS_PER_WORD > HOST_BITS_PER_INT) return 0; --- 1177,1181 ---- if (GET_MODE_CLASS (mode) != MODE_INT || (GET_CODE (op) != CONST_INT && GET_CODE (op) != CONST_DOUBLE) ! || BITS_PER_WORD > HOST_BITS_PER_WIDE_INT) return 0; *************** *** 2131,2137 **** } ! /* Add INSN into the doubly-linked list after insn AFTER. This should be the ! only function called to insert an insn once delay slots have been filled ! since only it knows how to update a SEQUENCE. */ void --- 2131,2138 ---- } ! /* Add INSN into the doubly-linked list after insn AFTER. This and ! the next should be the only functions called to insert an insn once ! delay slots have been filled since only they know how to update a ! SEQUENCE. */ void *************** *** 2141,2144 **** --- 2142,2148 ---- rtx next = NEXT_INSN (after); + if (optimize && INSN_DELETED_P (after)) + abort (); + NEXT_INSN (insn) = next; PREV_INSN (insn) = after; *************** *** 2158,2162 **** for (; stack; stack = stack->next) if (after == stack->last) ! stack->last = insn; } --- 2162,2172 ---- for (; stack; stack = stack->next) if (after == stack->last) ! { ! stack->last = insn; ! break; ! } ! ! if (stack == 0) ! abort (); } *************** *** 2169,2172 **** --- 2179,2230 ---- } + /* Add INSN into the doubly-linked list before insn BEFORE. This and + the previous should be the only functions called to insert an insn once + delay slots have been filled since only they know how to update a + SEQUENCE. */ + + void + add_insn_before (insn, before) + rtx insn, before; + { + rtx prev = PREV_INSN (before); + + if (optimize && INSN_DELETED_P (before)) + abort (); + + PREV_INSN (insn) = prev; + NEXT_INSN (insn) = before; + + if (prev) + { + NEXT_INSN (prev) = insn; + if (GET_CODE (prev) == INSN && GET_CODE (PATTERN (prev)) == SEQUENCE) + { + rtx sequence = PATTERN (prev); + NEXT_INSN (XVECEXP (sequence, 0, XVECLEN (sequence, 0) - 1)) = insn; + } + } + else if (first_insn == before) + first_insn = insn; + else + { + struct sequence_stack *stack = sequence_stack; + /* Scan all pending sequences too. */ + for (; stack; stack = stack->next) + if (before == stack->first) + { + stack->first = insn; + break; + } + + if (stack == 0) + abort (); + } + + PREV_INSN (before) = insn; + if (GET_CODE (before) == INSN && GET_CODE (PATTERN (before)) == SEQUENCE) + PREV_INSN (XVECEXP (PATTERN (before), 0, 0)) = insn; + } + /* Delete all insns made since FROM. FROM becomes the new last instruction. */ *************** *** 2280,2284 **** { insn = XVECEXP (pattern, 0, i); ! add_insn_after (insn, PREV_INSN (before)); } if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE) --- 2338,2342 ---- { insn = XVECEXP (pattern, 0, i); ! add_insn_before (insn, before); } if (XVECLEN (pattern, 0) < SEQUENCE_RESULT_SIZE) *************** *** 2288,2292 **** { insn = make_insn_raw (pattern); ! add_insn_after (insn, PREV_INSN (before)); } --- 2346,2350 ---- { insn = make_insn_raw (pattern); ! add_insn_before (insn, before); } *************** *** 2308,2312 **** { insn = make_jump_insn_raw (pattern); ! add_insn_after (insn, PREV_INSN (before)); } --- 2366,2370 ---- { insn = make_jump_insn_raw (pattern); ! add_insn_before (insn, before); } *************** *** 2328,2332 **** { insn = make_call_insn_raw (pattern); ! add_insn_after (insn, PREV_INSN (before)); PUT_CODE (insn, CALL_INSN); } --- 2386,2390 ---- { insn = make_call_insn_raw (pattern); ! add_insn_before (insn, before); PUT_CODE (insn, CALL_INSN); } *************** *** 2346,2350 **** INSN_UID (insn) = cur_insn_uid++; ! add_insn_after (insn, PREV_INSN (before)); return insn; } --- 2404,2408 ---- INSN_UID (insn) = cur_insn_uid++; ! add_insn_before (insn, before); return insn; } *************** *** 2362,2366 **** NOTE_LINE_NUMBER (note) = subtype; ! add_insn_after (note, PREV_INSN (before)); return note; } --- 2420,2424 ---- NOTE_LINE_NUMBER (note) = subtype; ! add_insn_before (note, before); return note; } *************** *** 2578,2582 **** { rtx next = NEXT_INSN (insn); ! add_insn_after (insn, PREV_INSN (before)); last = insn; insn = next; --- 2636,2640 ---- { rtx next = NEXT_INSN (insn); ! add_insn_before (insn, before); last = insn; insn = next; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/expmed.c gcc-2.6.1/expmed.c *** gcc-2.6.0/expmed.c Wed Jul 13 16:54:53 1994 --- gcc-2.6.1/expmed.c Thu Sep 22 18:55:22 1994 *************** *** 300,304 **** in the order least significant first. This is because the most significant word is the one which may ! be less than full. */ int nwords = (bitsize + (BITS_PER_WORD - 1)) / BITS_PER_WORD; --- 300,307 ---- in the order least significant first. This is because the most significant word is the one which may ! be less than full. ! However, only do that if the value is not BLKmode. */ ! ! int backwards = WORDS_BIG_ENDIAN && fieldmode != BLKmode; int nwords = (bitsize + (BITS_PER_WORD - 1)) / BITS_PER_WORD; *************** *** 316,321 **** /* If I is 0, use the low-order word in both field and target; if I is 1, use the next to lowest word; and so on. */ ! int wordnum = (WORDS_BIG_ENDIAN ? nwords - i - 1 : i); ! int bit_offset = (WORDS_BIG_ENDIAN ? MAX (bitsize - (i + 1) * BITS_PER_WORD, 0) : i * BITS_PER_WORD); --- 319,324 ---- /* If I is 0, use the low-order word in both field and target; if I is 1, use the next to lowest word; and so on. */ ! int wordnum = (backwards ? nwords - i - 1 : i); ! int bit_offset = (backwards ? MAX (bitsize - (i + 1) * BITS_PER_WORD, 0) : i * BITS_PER_WORD); *************** *** 370,374 **** /* Ensure insv's size is wide enough for this field. */ && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_insv][3]) ! >= bitsize)) { int xbitpos = bitpos; --- 373,380 ---- /* Ensure insv's size is wide enough for this field. */ && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_insv][3]) ! >= bitsize) ! && ! ((GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG) ! && (bitsize + bitpos ! > GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_insv][3])))) { int xbitpos = bitpos; *************** *** 742,758 **** & (((HOST_WIDE_INT) 1 << thissize) - 1)); else ! { ! /* The args are chosen so that the last part ! includes the lsb. */ ! int bit_offset = 0; ! /* If the value isn't in memory, then it must be right aligned ! if a register, so skip past the padding on the left. If it ! is in memory, then there is no padding on the left. */ ! if (GET_CODE (value) != MEM) ! bit_offset = BITS_PER_WORD - bitsize; ! part = extract_fixed_bit_field (word_mode, value, 0, thissize, ! bit_offset + bitsdone, ! NULL_RTX, 1, align); ! } #else /* Fetch successively more significant portions. */ --- 748,758 ---- & (((HOST_WIDE_INT) 1 << thissize) - 1)); else ! /* The args are chosen so that the last part includes the lsb. ! Give extract_bit_field the value it needs (with endianness ! compensation) to fetch the piece we want. */ ! part = extract_fixed_bit_field (word_mode, value, 0, thissize, ! GET_MODE_BITSIZE (GET_MODE (value)) ! - bitsize + bitsdone, ! NULL_RTX, 1, align); #else /* Fetch successively more significant portions. */ *************** *** 973,977 **** if (HAVE_extzv && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extzv][0]) ! >= bitsize)) { int xbitpos = bitpos, xoffset = offset; --- 973,980 ---- if (HAVE_extzv && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extzv][0]) ! >= bitsize) ! && ! ((GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG) ! && (bitsize + bitpos ! > GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extzv][0])))) { int xbitpos = bitpos, xoffset = offset; *************** *** 1112,1116 **** if (HAVE_extv && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extv][0]) ! >= bitsize)) { int xbitpos = bitpos, xoffset = offset; --- 1115,1122 ---- if (HAVE_extv && (GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extv][0]) ! >= bitsize) ! && ! ((GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG) ! && (bitsize + bitpos ! > GET_MODE_BITSIZE (insn_operand_mode[(int) CODE_FOR_extv][0])))) { int xbitpos = bitpos, xoffset = offset; *************** *** 2054,2057 **** --- 2060,2070 ---- rtx const_op1 = op1; + /* synth_mult does an `unsigned int' multiply. As long as the mode is + less than or equal in size to `unsigned int' this doesn't matter. + If the mode is larger than `unsigned int', then synth_mult works only + if the constant value exactly fits in an `unsigned int' without any + truncation. This means that multiplying by negative values does + not work; results are off by 2^32 on a 32 bit machine. */ + /* If we are multiplying in DImode, it may still be a win to try to work with shifts and adds. */ *************** *** 2058,2067 **** if (GET_CODE (op1) == CONST_DOUBLE && GET_MODE_CLASS (GET_MODE (op1)) == MODE_INT ! && HOST_BITS_PER_INT <= BITS_PER_WORD) ! { ! if ((CONST_DOUBLE_HIGH (op1) == 0 && CONST_DOUBLE_LOW (op1) >= 0) ! || (CONST_DOUBLE_HIGH (op1) == -1 && CONST_DOUBLE_LOW (op1) < 0)) ! const_op1 = GEN_INT (CONST_DOUBLE_LOW (op1)); ! } /* We used to test optimize here, on the grounds that it's better to --- 2071,2081 ---- if (GET_CODE (op1) == CONST_DOUBLE && GET_MODE_CLASS (GET_MODE (op1)) == MODE_INT ! && HOST_BITS_PER_INT >= BITS_PER_WORD ! && CONST_DOUBLE_HIGH (op1) == 0) ! const_op1 = GEN_INT (CONST_DOUBLE_LOW (op1)); ! else if (HOST_BITS_PER_INT < GET_MODE_BITSIZE (mode) ! && GET_CODE (op1) == CONST_INT ! && INTVAL (op1) < 0) ! const_op1 = 0; /* We used to test optimize here, on the grounds that it's better to *************** *** 2070,2074 **** that it seems better to use synth_mult always. */ ! if (GET_CODE (const_op1) == CONST_INT) { struct algorithm alg; --- 2084,2088 ---- that it seems better to use synth_mult always. */ ! if (const_op1 && GET_CODE (const_op1) == CONST_INT) { struct algorithm alg; *************** *** 2088,2098 **** synth_mult (&alg, val, mult_cost); ! synth_mult (&alg2, - val, ! (alg.cost < mult_cost ? alg.cost : mult_cost) - negate_cost); ! if (alg2.cost + negate_cost < alg.cost) ! alg = alg2, variant = negate_variant; /* This proves very useful for division-by-constant. */ ! synth_mult (&alg2, val - 1, (alg.cost < mult_cost ? alg.cost : mult_cost) - add_cost); if (alg2.cost + add_cost < alg.cost) alg = alg2, variant = add_variant; --- 2102,2119 ---- synth_mult (&alg, val, mult_cost); ! ! /* This works only if the inverted value actually fits in an ! `unsigned int' */ ! if (HOST_BITS_PER_INT >= GET_MODE_BITSIZE (mode)) ! { ! synth_mult (&alg2, - val, ! (alg.cost < mult_cost ? alg.cost : mult_cost) - negate_cost); ! if (alg2.cost + negate_cost < alg.cost) ! alg = alg2, variant = negate_variant; ! } /* This proves very useful for division-by-constant. */ ! synth_mult (&alg2, val - 1, ! (alg.cost < mult_cost ? alg.cost : mult_cost) - add_cost); if (alg2.cost + add_cost < alg.cost) alg = alg2, variant = add_variant; *************** *** 2132,2136 **** int preserve = preserve_subexpressions_p (); rtx shift_subtarget = preserve ? 0 : accum; ! rtx add_target = opno == alg.ops - 1 && target != 0 ? target : 0; rtx accum_target = preserve ? 0 : accum; --- 2153,2159 ---- int preserve = preserve_subexpressions_p (); rtx shift_subtarget = preserve ? 0 : accum; ! rtx add_target ! = (opno == alg.ops - 1 && target != 0 && variant != add_variant ! ? target : 0); rtx accum_target = preserve ? 0 : accum; *************** *** 2569,2573 **** rtx last; int size; ! rtx insn; optab optab1, optab2; int op1_is_constant, op1_is_pow2; --- 2592,2596 ---- rtx last; int size; ! rtx insn, set; optab optab1, optab2; int op1_is_constant, op1_is_pow2; *************** *** 2814,2821 **** insn = get_last_insn (); ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (UDIV, compute_mode, op0, op1), ! REG_NOTES (insn)); } else /* TRUNC_DIV, signed */ --- 2837,2847 ---- insn = get_last_insn (); ! if (insn != last ! && (set = single_set (insn)) != 0 ! && SET_DEST (set) == quotient) ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (UDIV, compute_mode, op0, op1), ! REG_NOTES (insn)); } else /* TRUNC_DIV, signed */ *************** *** 2879,2887 **** { insn = get_last_insn (); ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (DIV, compute_mode, op0, ! GEN_INT (abs_d)), ! REG_NOTES (insn)); quotient = expand_unop (compute_mode, neg_optab, --- 2905,2916 ---- { insn = get_last_insn (); ! if (insn != last ! && (set = single_set (insn)) != 0 ! && SET_DEST (set) == quotient) ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (DIV, compute_mode, op0, ! GEN_INT (abs_d)), ! REG_NOTES (insn)); quotient = expand_unop (compute_mode, neg_optab, *************** *** 2936,2947 **** } ! if (quotient != 0) ! { ! insn = get_last_insn (); ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (DIV, compute_mode, op0, op1), ! REG_NOTES (insn)); ! } } break; --- 2965,2976 ---- } ! insn = get_last_insn (); ! if (insn != last ! && (set = single_set (insn)) != 0 ! && SET_DEST (set) == quotient) ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_EQUAL, ! gen_rtx (DIV, compute_mode, op0, op1), ! REG_NOTES (insn)); } break; *************** *** 3219,3222 **** --- 3248,3289 ---- else /* signed */ { + if (op1_is_constant && EXACT_POWER_OF_2_OR_ZERO_P (INTVAL (op1)) + && INTVAL (op1) >= 0) + { + /* This is extremely similar to the code for the unsigned case + above. For 2.7 we should merge these variants, but for + 2.6.1 I don't want to touch the code for unsigned since that + get used in C. The signed case will only be used by other + languages (Ada). */ + + rtx t1, t2, t3; + unsigned HOST_WIDE_INT d = INTVAL (op1); + t1 = expand_shift (RSHIFT_EXPR, compute_mode, op0, + build_int_2 (floor_log2 (d), 0), + tquotient, 0); + t2 = expand_binop (compute_mode, and_optab, op0, + GEN_INT (d - 1), + NULL_RTX, 1, OPTAB_LIB_WIDEN); + t3 = gen_reg_rtx (compute_mode); + t3 = emit_store_flag (t3, NE, t2, const0_rtx, + compute_mode, 1, 1); + if (t3 == 0) + { + rtx lab; + lab = gen_label_rtx (); + emit_cmp_insn (t2, const0_rtx, EQ, NULL_RTX, + compute_mode, 0, 0); + emit_jump_insn (gen_beq (lab)); + expand_inc (t1, const1_rtx); + emit_label (lab); + quotient = t1; + } + else + quotient = force_operand (gen_rtx (PLUS, compute_mode, + t1, t3), + tquotient); + break; + } + /* Try using an instruction that produces both the quotient and remainder, using truncation. We can easily compensate the diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/expr.c gcc-2.6.1/expr.c *** gcc-2.6.0/expr.c Wed Jul 13 16:31:01 1994 --- gcc-2.6.1/expr.c Mon Oct 31 08:10:30 1994 *************** *** 1026,1029 **** --- 1026,1064 ---- } + if (to_mode == PDImode) + { + if (from_mode != DImode) + from = convert_to_mode (DImode, from, unsignedp); + + #ifdef HAVE_truncdipdi2 + if (HAVE_truncdipdi2) + { + emit_unop_insn (CODE_FOR_truncdipdi2, to, from, UNKNOWN); + return; + } + #endif /* HAVE_truncdipdi2 */ + abort (); + } + + if (from_mode == PDImode) + { + if (to_mode != DImode) + { + from = convert_to_mode (DImode, from, unsignedp); + from_mode = DImode; + } + else + { + #ifdef HAVE_extendpdidi2 + if (HAVE_extendpdidi2) + { + emit_unop_insn (CODE_FOR_extendpdidi2, to, from, UNKNOWN); + return; + } + #endif /* HAVE_extendpdidi2 */ + abort (); + } + } + /* Now follow all the conversions between integers no more than a word long. */ *************** *** 1165,1168 **** --- 1200,1255 ---- } + if (from_mode == TImode && to_mode == DImode) + { + #ifdef HAVE_trunctidi2 + if (HAVE_trunctidi2) + { + emit_unop_insn (CODE_FOR_trunctidi2, to, from, UNKNOWN); + return; + } + #endif + convert_move (to, force_reg (from_mode, from), unsignedp); + return; + } + + if (from_mode == TImode && to_mode == SImode) + { + #ifdef HAVE_trunctisi2 + if (HAVE_trunctisi2) + { + emit_unop_insn (CODE_FOR_trunctisi2, to, from, UNKNOWN); + return; + } + #endif + convert_move (to, force_reg (from_mode, from), unsignedp); + return; + } + + if (from_mode == TImode && to_mode == HImode) + { + #ifdef HAVE_trunctihi2 + if (HAVE_trunctihi2) + { + emit_unop_insn (CODE_FOR_trunctihi2, to, from, UNKNOWN); + return; + } + #endif + convert_move (to, force_reg (from_mode, from), unsignedp); + return; + } + + if (from_mode == TImode && to_mode == QImode) + { + #ifdef HAVE_trunctiqi2 + if (HAVE_trunctiqi2) + { + emit_unop_insn (CODE_FOR_trunctiqi2, to, from, UNKNOWN); + return; + } + #endif + convert_move (to, force_reg (from_mode, from), unsignedp); + return; + } + /* Handle truncation of volatile memrefs, and so on; the things that couldn't be truncated directly, *************** *** 1604,1607 **** --- 1691,1697 ---- rtx pat, last; + if (nregs == 0) + return; + if (CONSTANT_P (x) && ! LEGITIMATE_CONSTANT_P (x)) x = validize_mem (force_const_mem (mode, x)); *************** *** 1824,1829 **** rtx insns; - start_sequence (); - /* If this is a stack, push the highpart first, so it will be in the argument order. --- 1914,1917 ---- *************** *** 1859,1873 **** } - insns = get_insns (); - end_sequence (); - - /* If X is a CONCAT, we got insns like RD = RS, ID = IS, - each with a separate pseudo as destination. - It's not correct for flow to treat them as a unit. */ - if (GET_CODE (x) != CONCAT) - emit_no_conflict_block (insns, x, y, NULL_RTX, NULL_RTX); - else - emit_insns (insns); - return get_last_insn (); } --- 1947,1950 ---- *************** *** 1881,1886 **** rtx insns; - start_sequence (); - for (i = 0; i < (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD; --- 1958,1961 ---- *************** *** 1907,1914 **** } - insns = get_insns (); - end_sequence (); - emit_no_conflict_block (insns, x, y, NULL_RTX, NULL_RTX); - return last_insn; } --- 1982,1985 ---- *************** *** 2725,2728 **** --- 2796,2800 ---- So copy just the string's actual length, and clear the rest. */ rtx size; + rtx addr; /* Get the size of the data type of the string, *************** *** 2753,2760 **** if (GET_CODE (copy_size_rtx) == CONST_INT) { ! temp = plus_constant (XEXP (target, 0), TREE_STRING_LENGTH (exp)); ! size = plus_constant (size, ! - TREE_STRING_LENGTH (exp)); } else --- 2825,2831 ---- if (GET_CODE (copy_size_rtx) == CONST_INT) { ! addr = plus_constant (XEXP (target, 0), TREE_STRING_LENGTH (exp)); ! size = plus_constant (size, - TREE_STRING_LENGTH (exp)); } else *************** *** 2762,2767 **** enum machine_mode size_mode = Pmode; ! temp = force_reg (Pmode, XEXP (target, 0)); ! temp = expand_binop (size_mode, add_optab, temp, copy_size_rtx, NULL_RTX, 0, OPTAB_LIB_WIDEN); --- 2833,2838 ---- enum machine_mode size_mode = Pmode; ! addr = force_reg (Pmode, XEXP (target, 0)); ! addr = expand_binop (size_mode, add_optab, addr, copy_size_rtx, NULL_RTX, 0, OPTAB_LIB_WIDEN); *************** *** 2780,2790 **** { #ifdef TARGET_MEM_FUNCTIONS ! emit_library_call (memset_libfunc, 0, VOIDmode, 3, ! temp, Pmode, const0_rtx, Pmode, size, Pmode); #else emit_library_call (bzero_libfunc, 0, VOIDmode, 2, ! temp, Pmode, size, Pmode); #endif } if (label) emit_label (label); --- 2851,2862 ---- { #ifdef TARGET_MEM_FUNCTIONS ! emit_library_call (memset_libfunc, 0, VOIDmode, 3, addr, ! Pmode, const0_rtx, Pmode, size, Pmode); #else emit_library_call (bzero_libfunc, 0, VOIDmode, 2, ! addr, Pmode, size, Pmode); #endif } + if (label) emit_label (label); *************** *** 3508,3512 **** int i, nops; ! if (x == 0) return 1; --- 3580,3590 ---- int i, nops; ! if (x == 0 ! /* If EXP has varying size, we MUST use a target since we currently ! have no way of allocating temporaries of variable size. So we ! assume here that something at a higher level has prevented a ! clash. This is somewhat bogus, but the best we can do. */ ! || (TREE_TYPE (exp) != 0 && TYPE_SIZE (TREE_TYPE (exp)) != 0 ! && TREE_CODE (TYPE_SIZE (TREE_TYPE (exp))) != INTEGER_CST)) return 1; *************** *** 4341,4345 **** /* Fold an expression like: "foo"[2]. ! This is not done in fold so it won't happen inside &. */ if (TREE_CODE (array) == STRING_CST --- 4419,4425 ---- /* Fold an expression like: "foo"[2]. ! This is not done in fold so it won't happen inside &. ! Don't fold if this is for wide characters since it's too ! difficult to do correctly and this is a very rare case. */ if (TREE_CODE (array) == STRING_CST *************** *** 4347,4351 **** && !TREE_INT_CST_HIGH (index) && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (array) ! && GET_MODE_CLASS (mode) == MODE_INT) return GEN_INT (TREE_STRING_POINTER (array)[i]); --- 4427,4432 ---- && !TREE_INT_CST_HIGH (index) && (i = TREE_INT_CST_LOW (index)) < TREE_STRING_LENGTH (array) ! && GET_MODE_CLASS (mode) == MODE_INT ! && GET_MODE_SIZE (mode) == 1) return GEN_INT (TREE_STRING_POINTER (array)[i]); *************** *** 4405,4411 **** case BIT_FIELD_REF: /* If the operand is a CONSTRUCTOR, we can just extract the ! appropriate field if it is present. */ if (code != ARRAY_REF ! && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR) { tree elt; --- 4486,4495 ---- case BIT_FIELD_REF: /* If the operand is a CONSTRUCTOR, we can just extract the ! appropriate field if it is present. Don't do this if we have ! already written the data since we want to refer to that copy ! and varasm.c assumes that's what we'll do. */ if (code != ARRAY_REF ! && TREE_CODE (TREE_OPERAND (exp, 0)) == CONSTRUCTOR ! && TREE_CST_RTL (TREE_OPERAND (exp, 0)) == 0) { tree elt; *************** *** 5451,5455 **** else if (original_target && safe_from_p (original_target, TREE_OPERAND (exp, 0)) ! && GET_MODE (original_target) == mode) temp = original_target; else if (mode == BLKmode) --- 5535,5541 ---- else if (original_target && safe_from_p (original_target, TREE_OPERAND (exp, 0)) ! && GET_MODE (original_target) == mode ! && ! (GET_CODE (original_target) == MEM ! && MEM_VOLATILE_P (original_target))) temp = original_target; else if (mode == BLKmode) *************** *** 5499,5504 **** || TREE_CODE (binary_op) == MINUS_EXPR || TREE_CODE (binary_op) == BIT_IOR_EXPR ! || TREE_CODE (binary_op) == BIT_XOR_EXPR ! || TREE_CODE (binary_op) == BIT_AND_EXPR) && integer_onep (TREE_OPERAND (binary_op, 1)) && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<') --- 5585,5589 ---- || TREE_CODE (binary_op) == MINUS_EXPR || TREE_CODE (binary_op) == BIT_IOR_EXPR ! || TREE_CODE (binary_op) == BIT_XOR_EXPR) && integer_onep (TREE_OPERAND (binary_op, 1)) && TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == '<') *************** *** 5508,5513 **** : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab ! : TREE_CODE (binary_op) == BIT_XOR_EXPR ? xor_optab ! : and_optab); /* If we had X ? A : A + 1, do this as A + (X == 0). --- 5593,5597 ---- : TREE_CODE (binary_op) == MINUS_EXPR ? sub_optab : TREE_CODE (binary_op) == BIT_IOR_EXPR ? ior_optab ! : xor_optab); /* If we had X ? A : A + 1, do this as A + (X == 0). *************** *** 5733,5737 **** if (! right_cleanups) right_cleanups = integer_zero_node; ! new_cleanups = build (COND_EXPR, void_type_node, cond, left_cleanups, right_cleanups); new_cleanups = fold (new_cleanups); --- 5817,5822 ---- if (! right_cleanups) right_cleanups = integer_zero_node; ! new_cleanups = build (COND_EXPR, void_type_node, ! truthvalue_conversion (cond), left_cleanups, right_cleanups); new_cleanups = fold (new_cleanups); *************** *** 5970,5974 **** op0); else if (GET_CODE (op0) == MEM) ! temp = XEXP (op0, 0); else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG --- 6055,6062 ---- op0); else if (GET_CODE (op0) == MEM) ! { ! mark_temp_addr_taken (op0); ! temp = XEXP (op0, 0); ! } else if (GET_CODE (op0) == REG || GET_CODE (op0) == SUBREG *************** *** 5983,5986 **** --- 6071,6075 ---- int_size_in_bytes (inner_type), 1); + mark_temp_addr_taken (memloc); emit_move_insn (memloc, op0); op0 = memloc; *************** *** 6056,6059 **** --- 6145,6149 ---- case CONJ_EXPR: { + enum machine_mode partmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp))); rtx imag_t; rtx insns; *************** *** 6067,6075 **** /* Store the realpart and the negated imagpart to target. */ ! emit_move_insn (gen_realpart (mode, target), gen_realpart (mode, op0)); ! imag_t = gen_imagpart (mode, target); ! temp = expand_unop (mode, neg_optab, ! gen_imagpart (mode, op0), imag_t, 0); if (temp != imag_t) emit_move_insn (imag_t, temp); --- 6157,6166 ---- /* Store the realpart and the negated imagpart to target. */ ! emit_move_insn (gen_realpart (partmode, target), ! gen_realpart (partmode, op0)); ! imag_t = gen_imagpart (partmode, target); ! temp = expand_unop (partmode, neg_optab, ! gen_imagpart (partmode, op0), imag_t, 0); if (temp != imag_t) emit_move_insn (imag_t, temp); *************** *** 6837,6840 **** --- 6928,6934 ---- case BUILT_IN_SIN: case BUILT_IN_COS: + /* Treat these like sqrt, but only if the user asks for them. */ + if (! flag_fast_math) + break; case BUILT_IN_FSQRT: /* If not optimizing, call the library function. */ *************** *** 7793,7797 **** if (size % align != 0) size = CEIL (size, align) * align; ! reg = gen_rtx (REG, mode, savep ? INCOMING_REGNO (regno) : regno); mem = change_address (result, mode, plus_constant (XEXP (result, 0), size)); --- 7887,7891 ---- if (size % align != 0) size = CEIL (size, align) * align; ! reg = gen_rtx (REG, mode, savep ? regno : INCOMING_REGNO (regno)); mem = change_address (result, mode, plus_constant (XEXP (result, 0), size)); *************** *** 8285,8289 **** if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL ! || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))) CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0); return; --- 8379,8385 ---- if (TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR || TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) != FUNCTION_DECL ! || ! DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) ! /* Do nothing if the call returns a variable-sized object. */ ! || TREE_CODE (TYPE_SIZE (TREE_TYPE(exp))) != INTEGER_CST) CALL_EXPR_RTL (exp) = expand_call (exp, NULL_RTX, 0); return; *************** *** 8372,8375 **** --- 8468,8472 ---- { (*interim_eh_hook) (TREE_VALUE (cleanups_this_call)); + last = cleanups_this_call; cleanups_this_call = TREE_CHAIN (cleanups_this_call); } *************** *** 8556,8570 **** case TRUTH_ANDIF_EXPR: ! if (if_false_label == 0) ! if_false_label = drop_through_label = gen_label_rtx (); ! do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX); ! do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); break; case TRUTH_ORIF_EXPR: ! if (if_true_label == 0) ! if_true_label = drop_through_label = gen_label_rtx (); ! do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label); ! do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); break; --- 8653,8767 ---- case TRUTH_ANDIF_EXPR: ! { ! rtx seq1, seq2; ! tree cleanups, old_cleanups; ! ! if (if_false_label == 0) ! if_false_label = drop_through_label = gen_label_rtx (); ! start_sequence (); ! do_jump (TREE_OPERAND (exp, 0), if_false_label, NULL_RTX); ! seq1 = get_insns (); ! end_sequence (); ! ! old_cleanups = cleanups_this_call; ! start_sequence (); ! do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); ! seq2 = get_insns (); ! end_sequence (); ! ! cleanups = defer_cleanups_to (old_cleanups); ! if (cleanups) ! { ! rtx flag = gen_reg_rtx (word_mode); ! tree new_cleanups; ! tree cond; ! ! /* Flag cleanups as not needed. */ ! emit_move_insn (flag, const0_rtx); ! emit_insns (seq1); ! ! /* Flag cleanups as needed. */ ! emit_move_insn (flag, const1_rtx); ! emit_insns (seq2); ! ! /* convert flag, which is an rtx, into a tree. */ ! cond = make_node (RTL_EXPR); ! TREE_TYPE (cond) = integer_type_node; ! RTL_EXPR_RTL (cond) = flag; ! RTL_EXPR_SEQUENCE (cond) = NULL_RTX; ! ! new_cleanups = build (COND_EXPR, void_type_node, ! truthvalue_conversion (cond), ! cleanups, integer_zero_node); ! new_cleanups = fold (new_cleanups); ! ! /* Now add in the conditionalized cleanups. */ ! cleanups_this_call ! = tree_cons (NULL_TREE, new_cleanups, cleanups_this_call); ! (*interim_eh_hook) (NULL_TREE); ! } ! else ! { ! emit_insns (seq1); ! emit_insns (seq2); ! } ! } break; case TRUTH_ORIF_EXPR: ! { ! rtx seq1, seq2; ! tree cleanups, old_cleanups; ! ! if (if_true_label == 0) ! if_true_label = drop_through_label = gen_label_rtx (); ! start_sequence (); ! do_jump (TREE_OPERAND (exp, 0), NULL_RTX, if_true_label); ! seq1 = get_insns (); ! end_sequence (); ! ! old_cleanups = cleanups_this_call; ! start_sequence (); ! do_jump (TREE_OPERAND (exp, 1), if_false_label, if_true_label); ! seq2 = get_insns (); ! end_sequence (); ! ! cleanups = defer_cleanups_to (old_cleanups); ! if (cleanups) ! { ! rtx flag = gen_reg_rtx (word_mode); ! tree new_cleanups; ! tree cond; ! ! /* Flag cleanups as not needed. */ ! emit_move_insn (flag, const0_rtx); ! emit_insns (seq1); ! ! /* Flag cleanups as needed. */ ! emit_move_insn (flag, const1_rtx); ! emit_insns (seq2); ! ! /* convert flag, which is an rtx, into a tree. */ ! cond = make_node (RTL_EXPR); ! TREE_TYPE (cond) = integer_type_node; ! RTL_EXPR_RTL (cond) = flag; ! RTL_EXPR_SEQUENCE (cond) = NULL_RTX; ! ! new_cleanups = build (COND_EXPR, void_type_node, ! truthvalue_conversion (cond), ! cleanups, integer_zero_node); ! new_cleanups = fold (new_cleanups); ! ! /* Now add in the conditionalized cleanups. */ ! cleanups_this_call ! = tree_cons (NULL_TREE, new_cleanups, cleanups_this_call); ! (*interim_eh_hook) (NULL_TREE); ! } ! else ! { ! emit_insns (seq1); ! emit_insns (seq2); ! } ! } break; *************** *** 8981,8987 **** rtx branch = 0; - if (prev != 0) - prev = PREV_INSN (prev); - /* Output the branch with the opposite condition. Then try to invert what is generated. If more than one insn is a branch, or if the --- 9178,9181 ---- *************** *** 8991,9008 **** if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0) ! emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)]) (if_false_label)); else abort (); ! /* Here we get the insn before what was just emitted. ! On some machines, emitting the branch can discard ! the previous compare insn and emit a replacement. */ if (prev == 0) - /* If there's only one preceding insn... */ insn = get_insns (); else insn = NEXT_INSN (prev); ! for (insn = NEXT_INSN (insn); insn; insn = NEXT_INSN (insn)) if (GET_CODE (insn) == JUMP_INSN) { --- 9185,9205 ---- if (bcc_gen_fctn[(int) GET_CODE (comparison)] != 0) ! emit_jump_insn ((*bcc_gen_fctn[(int) GET_CODE (comparison)])(if_false_label)); else abort (); ! /* Here we get the first insn that was just emitted. It used to be the ! case that, on some machines, emitting the branch would discard ! the previous compare insn and emit a replacement. This isn't ! done anymore, but abort if we see that PREV is deleted. */ ! if (prev == 0) insn = get_insns (); + else if (INSN_DELETED_P (prev)) + abort (); else insn = NEXT_INSN (prev); ! for (; insn; insn = NEXT_INSN (insn)) if (GET_CODE (insn) == JUMP_INSN) { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/expr.h gcc-2.6.1/expr.h *** gcc-2.6.0/expr.h Fri Jul 8 16:43:06 1994 --- gcc-2.6.1/expr.h Wed Oct 12 09:15:54 1994 *************** *** 373,376 **** --- 373,383 ---- extern rtx bzero_libfunc; + extern rtx eqhf2_libfunc; + extern rtx nehf2_libfunc; + extern rtx gthf2_libfunc; + extern rtx gehf2_libfunc; + extern rtx lthf2_libfunc; + extern rtx lehf2_libfunc; + extern rtx eqsf2_libfunc; extern rtx nesf2_libfunc; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/extend.texi gcc-2.6.1/extend.texi *** gcc-2.6.0/extend.texi Wed Jul 6 16:36:28 1994 --- gcc-2.6.1/extend.texi Mon Sep 19 13:36:14 1994 *************** *** 1,3 **** ! @c Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. --- 1,3 ---- ! @c Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. *************** *** 14,19 **** @code{__GNUC__}, which is always defined under GNU CC. ! These extensions are available in C and in the languages derived from ! it, C++ and Objective C. @xref{C++ Extensions,,Extensions to the C++ Language}, for extensions that apply @emph{only} to C++. --- 14,19 ---- @code{__GNUC__}, which is always defined under GNU CC. ! These extensions are available in C and Objective C. Most of them are ! also available in C++. @xref{C++ Extensions,,Extensions to the C++ Language}, for extensions that apply @emph{only} to C++. *************** *** 609,612 **** --- 609,616 ---- their addresses or store values into them. + Standard C++ allows compound expressions and conditional expressions as + lvalues, and permits casts to reference type, so use of this extension + is deprecated for C++ code. + For example, a compound expression can be assigned, provided the last expression in the sequence is an lvalue. These two expressions are *************** *** 993,999 **** @cindex non-constant initializers ! The elements of an aggregate initializer for an automatic variable are ! not required to be constant expressions in GNU C. Here is an example of ! an initializer with run-time varying elements: @example --- 997,1003 ---- @cindex non-constant initializers ! As in standard C++, the elements of an aggregate initializer for an ! automatic variable are not required to be constant expressions in GNU C. ! Here is an example of an initializer with run-time varying elements: @example *************** *** 1077,1081 **** In GNU C you can give the elements in any order, specifying the array ! indices or structure field names they apply to. To specify an array index, write @samp{[@var{index}]} or --- 1081,1086 ---- In GNU C you can give the elements in any order, specifying the array ! indices or structure field names they apply to. This extension is not ! implemented in GNU C++. To specify an array index, write @samp{[@var{index}]} or *************** *** 1349,1352 **** --- 1354,1360 ---- @end smallexample + This approach does not work in GNU C++ from 2.6.0 on, since the language + specifies that the @samp{const} must be attached to the return value. + @cindex pointer arguments Note that a function that has pointer arguments and examines the data *************** *** 1495,1498 **** --- 1503,1509 ---- @end example + GNU C++ does not support old-style function definitions, so this + extension is irrelevant. + @node Dollar Signs @section Dollar Signs in Identifier Names *************** *** 1689,1692 **** --- 1700,1710 ---- If you need to map the entire contents of a module to a particular section, consider using the facilities of the linker instead. + + @item transparent_union + This attribute, attached to a function argument variable which is a + union, means to pass the argument in the same way that the first union + alternative would be passed. You can also use this attribute on a + @code{typedef} for a union data type; then it applies to all function + arguments with that type. @end table *************** *** 1731,1734 **** --- 1749,1755 ---- definition can make it unsuitable for inline substitution. + Note that in C and Objective C, unlike C++, the @code{inline} keyword + does not affect the linkage of the function. + @cindex automatic @code{inline} for C++ member fns @cindex @code{inline} automatic for C++ member fns *************** *** 1735,1741 **** @cindex member fns, automatically @code{inline} @cindex C++ member fns, automatically @code{inline} ! For C++ programs, GNU CC automatically inlines member functions even if ! they are not explicitly declared @code{inline}. ! (You can override this with @w{@samp{-fno-default-inline}}; @pxref{C++ Dialect Options,,Options Controlling C++ Dialect}.) --- 1756,1762 ---- @cindex member fns, automatically @code{inline} @cindex C++ member fns, automatically @code{inline} ! GNU CC automatically inlines member functions defined within the class ! body of C++ programs even if they are not explicitly declared ! @code{inline}. (You can override this with @samp{-fno-default-inline}; @pxref{C++ Dialect Options,,Options Controlling C++ Dialect}.) *************** *** 2280,2283 **** --- 2301,2306 ---- are handled. + This extension is not supported by GNU C++. + @node Function Names @section Function Names as Strings *************** *** 2342,2345 **** --- 2365,2370 ---- * C++ Interface:: You can use a single C++ header file for both declarations and definitions. + * Template Instantiation:: Methods for ensuring that exactly one copy of + each needed template instantiation is emitted. * C++ Signatures:: You can specify abstract types to get subtype polymorphism independent from inheritance. *************** *** 2554,2557 **** --- 2579,2583 ---- @table @code @item #pragma interface + @itemx #pragma interface "@var{subdir}/@var{objects}.h" @kindex #pragma interface Use this directive in @emph{header files} that define object classes, to save *************** *** 2567,2570 **** --- 2593,2601 ---- time. + The second form of this directive is useful for the case where you have + multiple headers with the same name in different directories. If you + use this form, you must specify the same string to @samp{#pragma + implementation}. + @item #pragma implementation @itemx #pragma implementation "@var{objects}.h" *************** *** 2580,2596 **** @cindex @code{#pragma implementation}, implied @cindex naming convention, implementation headers ! @samp{#pragma implementation} is @emph{implied} whenever the ! basename@footnote{A file's @dfn{basename} is the name stripped of all ! leading path information and of trailing suffixes, such as @samp{.h} or ! @samp{.C} or @samp{.cc}.} of your source file matches the basename of a ! header file it includes. There is no way to turn this off (other than ! using a different name for one of the two files). In the same vein, if ! you use @samp{#pragma implementation} with no argument, it applies to an ! include file with the same basename as your source file. For example, in ! @file{allclass.cc}, @samp{#pragma implementation} by itself is ! equivalent to @samp{#pragma implementation "allclass.h"}; but even if ! you do not say @samp{#pragma implementation} at all, @file{allclass.h} ! is treated as an implementation file whenever you include it from ! @file{allclass.cc}. If you use an explicit @samp{#pragma implementation}, it must appear in --- 2611,2626 ---- @cindex @code{#pragma implementation}, implied @cindex naming convention, implementation headers ! If you use @samp{#pragma implementation} with no argument, it applies to ! an include file with the same basename@footnote{A file's @dfn{basename} ! was the name stripped of all leading path information and of trailing ! suffixes, such as @samp{.h} or @samp{.C} or @samp{.cc}.} as your source ! file. For example, in @file{allclass.cc}, @samp{#pragma implementation} ! by itself is equivalent to @samp{#pragma implementation "allclass.h"}. ! ! In versions of GNU C++ prior to 2.6.0 @file{allclass.h} was treated as ! an implementation file whenever you would include it from ! @file{allclass.cc} even if you never specified @samp{#pragma ! implementation}. This was deemed to be more trouble than it was worth, ! however, and disabled. If you use an explicit @samp{#pragma implementation}, it must appear in *************** *** 2623,2627 **** code for the function itself; this defines a version of the function that can be found via pointers (or by callers compiled without ! inlining). @node C++ Signatures --- 2653,2774 ---- code for the function itself; this defines a version of the function that can be found via pointers (or by callers compiled without ! inlining). If all calls to the function can be inlined, you can avoid ! emitting the function by compiling with @samp{-fno-implement-inlines}. ! If any calls were not inlined, you will get linker errors. ! ! @node Template Instantiation ! @section Where's the Template? ! ! @cindex template instantiation ! ! C++ templates are the first language feature to require more ! intelligence from the environment than one usually finds on a UNIX ! system. Somehow the compiler and linker have to make sure that each ! template instance occurs exactly once in the executable if it is needed, ! and not at all otherwise. There are two basic approaches to this ! problem, which I will refer to as the Borland model and the Cfront model. ! ! @table @asis ! @item Borland model ! Borland C++ solved the template instantiation problem by adding the code ! equivalent of common blocks to their linker; template instances ! are emitted in each translation unit that uses them, and they are ! collapsed together at run time. The advantage of this model is that the ! linker only has to consider the object files themselves; there is no ! external complexity to worry about. This disadvantage is that ! compilation time is increased because the template code is being ! compiled repeatedly. Code written for this model tends to include ! definitions of all member templates in the header file, since they must ! be seen to be compiled. ! ! @item Cfront model ! The AT&T C++ translator, Cfront, solved the template instantiation ! problem by creating the notion of a template repository, an ! automatically maintained place where template instances are stored. As ! individual object files are built, notes are placed in the repository to ! record where templates and potential type arguments were seen so that ! the subsequent instantiation step knows where to find them. At link ! time, any needed instances are generated and linked in. The advantages ! of this model are more optimal compilation speed and the ability to use ! the system linker; to implement the Borland model a compiler vendor also ! needs to replace the linker. The disadvantages are vastly increased ! complexity, and thus potential for error; theoretically, this should be ! just as transparent, but in practice it has been very difficult to build ! multiple programs in one directory and one program in multiple ! directories using Cfront. Code written for this model tends to separate ! definitions of non-inline member templates into a separate file, which ! is magically found by the link preprocessor when a template needs to be ! instantiated. ! @end table ! ! Currently, g++ implements neither automatic model. The g++ team hopes ! to have a repository working for 2.7.0. In the mean time, you have ! three options for dealing with template instantiations: ! ! @enumerate ! @item ! Do nothing. Pretend g++ does implement automatic instantiation ! management. Code written for the Borland model will work fine, but ! each translation unit will contain instances of each of the templates it ! uses. In a large program, this can lead to an unacceptable amount of code ! duplication. ! ! @item ! Add @samp{#pragma interface} to all files containing template ! definitions. For each of these files, add @samp{#pragma implementation ! "@var{filename}"} to the top of some @samp{.C} file which ! @samp{#include}s it. Then compile everything with -fexternal-templates. ! The templates will then only be expanded in the translation unit which ! implements them (i.e. has a @samp{#pragma implementation} line for the ! file where they live); all other files will use external references. If ! you're lucky, everything should work properly. If you get undefined ! symbol errors, you need to make sure that each template instance which ! is used in the program is used in the file which implements that ! template. If you don't have any use for a particular instance in that ! file, you can just instantiate it explicitly, using the syntax from the ! latest C++ working paper: ! ! @example ! template class A; ! template ostream& operator << (ostream&, const A&); ! @end example ! ! This strategy will work with code written for either model. If you are ! using code written for the Cfront model, the file containing a class ! template and the file containing its member templates should be ! implemented in the same translation unit. ! ! A slight variation on this approach is to use the flag ! -falt-external-templates instead; this flag causes template instances to ! be emitted in the translation unit that implements the header where they ! are first instantiated, rather than the one which implements the file ! where the templates are defined. This header must be the same in all ! translation units, or things are likely to break. ! ! @xref{C++ Interface,,Declarations and Definitions in One Header}, for ! more discussion of these pragmas. ! ! @item ! Explicitly instantiate all the template instances you use, and compile ! with -fno-implicit-templates. This is probably your best bet; it may ! require more knowledge of exactly which templates you are using, but ! it's less mysterious than the previous approach, and it doesn't require ! any @samp{#pragma}s or other g++-specific code. You can scatter the ! instantiations throughout your program, you can create one big file to ! do all the instantiations, or you can create tiny files like ! ! @example ! #include "Foo.h" ! #include "Foo.cc" ! ! template class Foo; ! @end example ! ! for each instance you need, and create a template instantiation library ! from those. I'm partial to the last, but your mileage may vary. If you ! are using Cfront-model code, you can probably get away with not using ! -fno-implicit-templates when compiling files that don't @samp{#include} ! the member template definitions. ! @end enumerate @node C++ Signatures diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/final.c gcc-2.6.1/final.c *** gcc-2.6.0/final.c Tue Jul 12 21:31:11 1994 --- gcc-2.6.1/final.c Tue Sep 20 20:05:03 1994 *************** *** 825,831 **** int count = 1; ! for (template = decode_asm_operands (body, NULL_PTR, NULL_PTR, ! NULL_PTR, NULL_PTR); ! *template; template++) if (IS_ASM_LOGICAL_LINE_SEPARATOR(*template) || *template == '\n') count++; --- 825,835 ---- int count = 1; ! if (GET_CODE (body) == ASM_INPUT) ! template = XSTR (body, 0); ! else ! template = decode_asm_operands (body, NULL_PTR, NULL_PTR, ! NULL_PTR, NULL_PTR); ! ! for ( ; *template; template++) if (IS_ASM_LOGICAL_LINE_SEPARATOR(*template) || *template == '\n') count++; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fix-header.c gcc-2.6.1/fix-header.c *** gcc-2.6.0/fix-header.c Tue Jun 14 17:29:07 1994 --- gcc-2.6.1/fix-header.c Thu Aug 11 18:18:24 1994 *************** *** 177,181 **** int required_unseen_count; ! int write_lbrac () { --- 177,181 ---- int required_unseen_count; ! void write_lbrac () { *************** *** 375,378 **** --- 375,379 ---- } + void write_rbrac () { *************** *** 381,385 **** if (required_unseen_count) ! fprintf (outf, "#ifdef __cplusplus\n"); /* Now we print out prototypes for those functions that we haven't seen. */ --- 382,392 ---- if (required_unseen_count) ! { ! fprintf (outf, ! "#if defined(__cplusplus) || defined(__USE_FIXED_PROTOTYPES__)\n"); ! #ifdef NO_IMPLICIT_EXTERN_C ! fprintf (outf, "#ifdef __cplusplus\nextern \"C\" {\n#endif\n"); ! #endif ! } /* Now we print out prototypes for those functions that we haven't seen. */ *************** *** 409,414 **** } if (required_unseen_count) ! fprintf (outf, ! "#endif /* defined(__cplusplus) */\n"); switch (special_file_handling) --- 416,426 ---- } if (required_unseen_count) ! { ! #ifdef NO_IMPLICIT_EXTERN_C ! fprintf (outf, "#ifdef __cplusplus\n}\n#endif\n"); ! #endif ! fprintf (outf, ! "#endif /* defined(__cplusplus) || defined(__USE_FIXED_PROTOTYPES__*/\n"); ! } switch (special_file_handling) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fixinc.ptx gcc-2.6.1/fixinc.ptx *** gcc-2.6.0/fixinc.ptx --- gcc-2.6.1/fixinc.ptx Sat Sep 10 06:45:05 1994 *************** *** 0 **** --- 1,196 ---- + #! /bin/sh + # Install modified versions of certain ANSI-incompatible + # native Sequent DYNIX/ptx System V Release 3.2 system include files. + # Copyright (C) 1994 Free Software Foundation, Inc. + # Contributed by Bill Burton + # Portions adapted from fixinc.svr4 and fixincludes. + # + # 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. + # + # This script munges the native include files provided with DYNIX/ptx + # so as to remove things which are violations of the ANSI C standard. + # This is done by first running fixinc.svr4 which does most of the + # work. A few includes have fixes made to them afterwards by this + # script. Once munged, the resulting new system include files are + # placed in a directory that GNU C will search *before* searching the + # /usr/include directory. This script should work properly for most + # DYNIX/ptx systems. For other types of systems, you should use the + # `fixincludes' script instead. + # + # See README-fixinc for more information. + + # Directory containing the original header files. + INPUT=${2-${INPUT-/usr/include}} + + # Fail if no arg to specify a directory for the output. + if [ x$1 = x ] + then echo fixincludes: no output directory specified + exit 1 + fi + + # Directory in which to store the results. + LIB=${1?"fixincludes: output directory not specified"} + + # Make sure it exists. + if [ ! -d $LIB ]; then + mkdir $LIB || exit 1 + fi + + ORIG_DIR=`pwd` + + # Make LIB absolute if it is relative. + # Don't do this if not necessary, since may screw up automounters. + case $LIB in + /*) + ;; + *) + LIB=$ORIG_DIR/$LIB + ;; + esac + + echo 'Running fixinc.svr4' + # DYNIX/ptx has dirname so this is no problem + `dirname $0`/fixinc.svr4 $* + echo 'Finished fixinc.svr4' + + echo 'Building fixincludes in ' ${LIB} + + # Copied from fixincludes. + # Don't use or define the name va_list in stdio.h. + # This is for ANSI and also to interoperate properly with gcc's varargs.h. + file=stdio.h + if [ -r $file ] && [ ! -r ${LIB}/$file ]; then + cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" + chmod +w ${LIB}/$file 2>/dev/null + chmod a+r ${LIB}/$file 2>/dev/null + fi + + if [ -r ${LIB}/$file ]; then + echo Fixing $file, use of va_list + # Arrange for stdio.h to use stdarg.h to define __gnuc_va_list + (echo "#define __need___va_list" + echo "#include ") > ${LIB}/${file}.sed + # Use __gnuc_va_list in arg types in place of va_list. + # On 386BSD use __gnuc_va_list instead of _VA_LIST_. We're hoping the + # trailing parentheses and semicolon save all other systems from this. + # Define __va_list__ (something harmless and unused) instead of va_list. + # Don't claim to have defined va_list. + sed -e 's@ va_list @ __gnuc_va_list @' \ + -e 's@ va_list)@ __gnuc_va_list)@' \ + -e 's@ _VA_LIST_));@ __gnuc_va_list));@' \ + -e 's@ va_list@ __va_list__@' \ + -e 's@\*va_list@*__va_list__@' \ + -e 's@ __va_list)@ __gnuc_va_list)@' \ + -e 's@_NEED___VA_LIST@_NEED___Va_LIST@' \ + -e 's@VA_LIST@DUMMY_VA_LIST@' \ + -e 's@_NEED___Va_LIST@_NEED___VA_LIST@' \ + ${LIB}/$file >> ${LIB}/${file}.sed + + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + if cmp $file ${LIB}/$file >/dev/null 2>&1; then + rm -f ${LIB}/$file + fi + fi + + # In pwd.h, PTX 1.x needs stdio.h included since FILE * was added in a + # prototype later on in the file. + file=pwd.h + base=`basename $file` + if [ -r ${LIB}/$file ]; then + file_to_fix=${LIB}/$file + else + if [ -r ${INPUT}/$file ]; then + file_to_fix=${INPUT}/$file + else + file_to_fix="" + fi + fi + if [ \! -z "$file_to_fix" ]; then + echo Checking $file_to_fix + if grep stdio $file_to_fix > /dev/null; then + true + else + sed -e '/#include \/a\ + \ + #if defined(__STDC__) || defined(__cplusplus)\ + #include \ + #endif /* __STDC__ */' \ + $file_to_fix > ${LIB}/${file}.sed + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + echo Fixed $file_to_fix + fi + fi + + # Copied from fixincludes. + # math.h puts the declaration of matherr before the definition + # of struct exception, so the prototype (added by fixproto) causes havoc. + file=math.h + if [ -r $file ] && [ ! -r ${LIB}/$file ]; then + cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" + chmod +w ${LIB}/$file 2>/dev/null + chmod a+r ${LIB}/$file 2>/dev/null + fi + + if [ -r ${LIB}/$file ]; then + echo Fixing $file, matherr declaration + sed -e '/^struct exception/,$b' \ + -e '/matherr/i\ + struct exception; + '\ + ${LIB}/$file > ${LIB}/${file}.sed + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + if cmp $file ${LIB}/$file >/dev/null 2>&1; then + rm -f ${LIB}/$file + fi + fi + + # In netinet/in.h, the network byte swapping asm functions supported by the + # native cc compiler on PTX 1.x and 2.x is not supported in gcc. Instead, + # include written out by the fixinc.svr4 script which has + # these same routines written in an asm format supported by gcc. + file=netinet/in.h + base=`basename $file` + if [ -r ${LIB}/$file ]; then + file_to_fix=${LIB}/$file + else + if [ -r ${INPUT}/$file ]; then + file_to_fix=${INPUT}/$file + else + file_to_fix="" + fi + fi + if [ \! -z "$file_to_fix" ]; then + echo Checking $file_to_fix + if grep __GNUC__ $file_to_fix > /dev/null; then + true + else + sed -e '/#define NETSWAP/a\ + \ + #if defined (__GNUC__) || defined (__GNUG__)\ + #include \ + #else /* not __GNUC__ */\ + ' \ + -e '/#endif[ ]*\/\* NETSWAP \*\//i\ + #endif /* not __GNUC__ */' \ + $file_to_fix > ${LIB}/${file}.sed + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + echo Fixed $file_to_fix + fi + fi + + exit 0 + diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fixinc.svr4 gcc-2.6.1/fixinc.svr4 *** gcc-2.6.0/fixinc.svr4 Thu May 26 12:21:50 1994 --- gcc-2.6.1/fixinc.svr4 Thu Sep 22 13:14:18 1994 *************** *** 175,178 **** --- 175,180 ---- /#[a-z]*if.*[ (]__i386\([^_]\)/ s/__i386/__i386__/g /#[a-z]*if.*[ (]i386/ s/\([^_]\)i386/\1__i386__/g + /#[a-z]*if.*[ (!]__i860\([^_]\)/ s/__i860/__i860__/g + /#[a-z]*if.*[ (!]i860/ s/\([^_]\)i860/\1__i860__/g /#[a-z]*if.*[ (]sparc/ s/\([^_]\)sparc/\1__sparc__/g /#[a-z]*if.*[ (]mc68000/ s/\([^_]\)mc68000/\1__mc68000__/g *************** *** 199,202 **** --- 201,242 ---- done + # Install the proper definition of the three standard types in header files + # that they come from. + for file in sys/types.h stdlib.h sys/stdtypes.h stddef.h memory.h unistd.h; do + if [ -r $file ] && [ ! -r ${LIB}/$file ]; then + cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" + chmod +w ${LIB}/$file 2>/dev/null + chmod a+r ${LIB}/$file 2>/dev/null + fi + + if [ -r ${LIB}/$file ]; then + echo Fixing size_t, ptrdiff_t and wchar_t in $file + sed \ + -e '/typedef[ ][ ]*[a-z_][ a-z_]*[ ]size_t/i\ + #ifndef __SIZE_TYPE__\ + #define __SIZE_TYPE__ long unsigned int\ + #endif + ' \ + -e 's/typedef[ ][ ]*[a-z_][ a-z_]*[ ]size_t/typedef __SIZE_TYPE__ size_t/' \ + -e '/typedef[ ][ ]*[a-z_][ a-z_]*[ ]ptrdiff_t/i\ + #ifndef __PTRDIFF_TYPE__\ + #define __PTRDIFF_TYPE__ long int\ + #endif + ' \ + -e 's/typedef[ ][ ]*[a-z_][ a-z_]*[ ]ptrdiff_t/typedef __PTRDIFF_TYPE__ ptrdiff_t/' \ + -e '/typedef[ ][ ]*[a-z_][ a-z_]*[ ]wchar_t/i\ + #ifndef __WCHAR_TYPE__\ + #define __WCHAR_TYPE__ int\ + #endif + ' \ + -e 's/typedef[ ][ ]*[a-z_][ a-z_]*[ ]wchar_t/typedef __WCHAR_TYPE__ wchar_t/' \ + ${LIB}/$file > ${LIB}/${file}.sed + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + if cmp $file ${LIB}/$file >/dev/null 2>&1; then + rm ${LIB}/$file + fi + fi + done + # Fix first broken decl of getcwd present on some svr4 systems. *************** *** 1469,1483 **** #endif - #ifdef __GNUC__ - #define __STATIC static - #else - #define __STATIC - #endif - #ifdef __STDC__ ! __STATIC __inline__ unsigned long htonl (unsigned long); ! __STATIC __inline__ unsigned short htons (unsigned int); ! __STATIC __inline__ unsigned long ntohl (unsigned long); ! __STATIC __inline__ unsigned short ntohs (unsigned int); #endif /* defined (__STDC__) */ --- 1509,1517 ---- #endif #ifdef __STDC__ ! extern __inline__ unsigned long htonl (unsigned long); ! extern __inline__ unsigned short htons (unsigned int); ! extern __inline__ unsigned long ntohl (unsigned long); ! extern __inline__ unsigned short ntohs (unsigned int); #endif /* defined (__STDC__) */ *************** *** 1492,1496 **** /* We must use a new-style function definition, so that this will also be valid for C++. */ ! __STATIC __inline__ unsigned long htonl (unsigned long __arg) { --- 1526,1530 ---- /* We must use a new-style function definition, so that this will also be valid for C++. */ ! extern __inline__ unsigned long htonl (unsigned long __arg) { *************** *** 1505,1509 **** /* Convert a host short to a network short. */ ! __STATIC __inline__ unsigned short htons (unsigned int __arg) { --- 1539,1543 ---- /* Convert a host short to a network short. */ ! extern __inline__ unsigned short htons (unsigned int __arg) { *************** *** 1527,1531 **** /* Convert a host long to a network long. */ ! __STATIC __inline__ unsigned long htonl (unsigned long __arg) { --- 1561,1565 ---- /* Convert a host long to a network long. */ ! extern __inline__ unsigned long htonl (unsigned long __arg) { *************** *** 1541,1545 **** /* Convert a host short to a network short. */ ! __STATIC __inline__ unsigned short htons (unsigned int __arg) { --- 1575,1579 ---- /* Convert a host short to a network short. */ ! extern __inline__ unsigned short htons (unsigned int __arg) { *************** *** 1559,1563 **** /* Convert a host long to a network long. */ ! __STATIC __inline__ unsigned long htonl (unsigned long __arg) { --- 1593,1597 ---- /* Convert a host long to a network long. */ ! extern __inline__ unsigned long htonl (unsigned long __arg) { *************** *** 1567,1571 **** /* Convert a host short to a network short. */ ! __STATIC __inline__ unsigned short htons (unsigned int __arg) { --- 1601,1605 ---- /* Convert a host short to a network short. */ ! extern __inline__ unsigned short htons (unsigned int __arg) { *************** *** 1577,1581 **** /* Convert a network long to a host long. */ ! __STATIC __inline__ unsigned long ntohl (unsigned long __arg) { --- 1611,1615 ---- /* Convert a network long to a host long. */ ! extern __inline__ unsigned long ntohl (unsigned long __arg) { *************** *** 1585,1589 **** /* Convert a network short to a host short. */ ! __STATIC __inline__ unsigned short ntohs (unsigned int __arg) { --- 1619,1623 ---- /* Convert a network short to a host short. */ ! extern __inline__ unsigned short ntohs (unsigned int __arg) { *************** *** 1590,1596 **** return htons (__arg); } - - - #undef __STATIC __EOF__ --- 1624,1627 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fixincludes gcc-2.6.1/fixincludes *** gcc-2.6.0/fixincludes Thu Jun 30 16:06:57 1994 --- gcc-2.6.1/fixincludes Fri Oct 14 11:55:17 1994 *************** *** 143,148 **** # X gets the dir that the link actually leads to. x=`${PWDCMD}` # If a link points to ., make a similar link to . ! if [ $x = $INPUT ]; then echo $file '->' . ': Making link' rm -fr ${LIB}/$file > /dev/null 2>&1 --- 143,151 ---- # X gets the dir that the link actually leads to. x=`${PWDCMD}` + # Canonicalize ${INPUT} now to minimize the time an + # automounter has to change the result of ${PWDCMD}. + cinput=`cd ${INPUT}; ${PWDCMD}` # If a link points to ., make a similar link to . ! if [ $x = ${cinput} ]; then echo $file '->' . ': Making link' rm -fr ${LIB}/$file > /dev/null 2>&1 *************** *** 150,156 **** # If link leads back into ${INPUT}, # make a similar link here. ! elif expr $x : "${INPUT}/.*" > /dev/null; then # Y gets the actual target dir name, relative to ${INPUT}. ! y=`echo $x | sed -n "s&${INPUT}/&&p"` # DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}. dots=`echo "$file" | --- 153,159 ---- # If link leads back into ${INPUT}, # make a similar link here. ! elif expr $x : "${cinput}/.*" > /dev/null; then # Y gets the actual target dir name, relative to ${INPUT}. ! y=`echo $x | sed -n "s&${cinput}/&&p"` # DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}. dots=`echo "$file" | *************** *** 196,202 **** esac done # DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}. ! dots=`echo "$file" | ! sed -e 's@^./@@' -e 's@/./@/@g' -e 's@[^/][^/]*@..@g' -e 's@..$@@'` rm -fr ${LIB}/$file > /dev/null 2>&1 ln -s ${dots}root$x ${LIB}/$file > /dev/null 2>&1 --- 199,208 ---- esac done + # Get the path from ${LIB} to $file, accounting for symlinks. + parent=`echo "$file" | sed -e 's@/[^/]*$@@'` + libabs=`cd ${LIB}; ${PWDCMD}` + file2=`cd ${LIB}; cd $parent; ${PWDCMD} | sed -e "s@^${libabs}@@"` # DOTS is the relative path from ${LIB}/$file's dir back to ${LIB}. ! dots=`echo "$file2" | sed -e 's@/[^/]*@../@g'` rm -fr ${LIB}/$file > /dev/null 2>&1 ln -s ${dots}root$x ${LIB}/$file > /dev/null 2>&1 *************** *** 318,322 **** ' $2/$file > $2/$file. mv $2/$file. $2/$file ! if cmp $file $2/$file >/dev/null 2>&1; then rm $2/$file else --- 324,329 ---- ' $2/$file > $2/$file. mv $2/$file. $2/$file ! if cmp $file $2/$file >/dev/null 2>&1 \ ! || egrep 'This file is part of the GNU C Library' $2/$file >/dev/null 2>&1; then rm $2/$file else *************** *** 370,373 **** --- 377,386 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 389,392 **** --- 402,411 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 405,408 **** --- 424,433 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 419,422 **** --- 444,453 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 456,459 **** --- 487,496 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 476,479 **** --- 513,547 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done + fi + fi + + # Fix this ARM/RISCiX file where ___type is a Compiler hint that is specific to + # the Norcroft compiler. + file=X11/Intrinsic.h + if [ -r $file ] && [ ! -r ${LIB}/$file ]; then + cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" + chmod +w ${LIB}/$file 2>/dev/null + chmod a+r ${LIB}/$file 2>/dev/null + fi + + if [ -r ${LIB}/$file ]; then + echo Fixing $file + sed -e "s/___type p_type/p_type/" \ + ${LIB}/$file > ${LIB}/${file}.sed + rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file + if cmp $file ${LIB}/$file >/dev/null 2>&1; then + rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 501,504 **** --- 569,578 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 518,521 **** --- 592,601 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 537,540 **** --- 617,626 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 556,559 **** --- 642,651 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 575,578 **** --- 667,676 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 592,595 **** --- 690,699 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 615,618 **** --- 719,727 ---- rm ${LIB}/$file else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done # This file has an alternative name, mips/cpu.h. Fix that name, too. if cmp machine/cpu.h mips/cpu.h > /dev/null 2>&1; then *************** *** 641,644 **** --- 750,759 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 662,665 **** --- 777,786 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 680,683 **** --- 801,810 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 704,707 **** --- 831,840 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 722,725 **** --- 855,864 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 753,756 **** --- 892,901 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 772,775 **** --- 917,926 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 791,794 **** --- 942,951 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 810,813 **** --- 967,976 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 829,832 **** --- 992,1001 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 848,851 **** --- 1017,1026 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 868,871 **** --- 1043,1052 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 894,897 **** --- 1075,1084 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 917,920 **** --- 1104,1113 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 939,942 **** --- 1132,1141 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1011,1014 **** --- 1210,1219 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1028,1031 **** --- 1233,1242 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1052,1055 **** --- 1263,1272 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1072,1075 **** --- 1289,1298 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1106,1109 **** --- 1329,1338 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1135,1138 **** --- 1364,1373 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1156,1159 **** --- 1391,1400 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1177,1180 **** --- 1418,1427 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1192,1197 **** echo Fixing $file, use of va_list # Arrange for stdio.h to use stdarg.h to define __gnuc_va_list ! (echo "#define __need___va_list" ! echo "#include ") > ${LIB}/${file}.sed # Use __gnuc_va_list in arg types in place of va_list. # On 386BSD use __gnuc_va_list instead of _VA_LIST_. We're hoping the --- 1439,1448 ---- echo Fixing $file, use of va_list # Arrange for stdio.h to use stdarg.h to define __gnuc_va_list ! if egrep "__need___va_list" ${LIB}/$file >/dev/null 2>&1; then ! touch ${LIB}/${file}.sed ! else ! (echo "#define __need___va_list" ! echo "#include ") > ${LIB}/${file}.sed ! fi # Use __gnuc_va_list in arg types in place of va_list. # On 386BSD use __gnuc_va_list instead of _VA_LIST_. We're hoping the *************** *** 1205,1211 **** -e 's@\*va_list@*__va_list__@' \ -e 's@ __va_list)@ __gnuc_va_list)@' \ -e 's@_NEED___VA_LIST@_NEED___Va_LIST@' \ -e 's@VA_LIST@DUMMY_VA_LIST@' \ ! -e 's@_NEED___Va_LIST@_NEED___VA_LIST@' \ ${LIB}/$file >> ${LIB}/${file}.sed --- 1456,1463 ---- -e 's@\*va_list@*__va_list__@' \ -e 's@ __va_list)@ __gnuc_va_list)@' \ + -e 's@GNUC_VA_LIST@GNUC_Va_LIST@' \ -e 's@_NEED___VA_LIST@_NEED___Va_LIST@' \ -e 's@VA_LIST@DUMMY_VA_LIST@' \ ! -e 's@_Va_LIST@_VA_LIST@' \ ${LIB}/$file >> ${LIB}/${file}.sed *************** *** 1213,1216 **** --- 1465,1474 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1244,1247 **** --- 1502,1511 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1263,1266 **** --- 1527,1536 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1278,1281 **** --- 1548,1557 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1296,1299 **** --- 1572,1581 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1361,1364 **** --- 1643,1652 ---- echo Deleting ${LIB}/$file\; no fixes were needed. rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1404,1407 **** --- 1692,1701 ---- echo Deleting ${LIB}/$file\; no fixes were needed. rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1422,1425 **** --- 1716,1725 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1442,1445 **** --- 1742,1751 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1455,1463 **** if [ -r ${LIB}/$file ]; then echo Fixing $file ! sed -e '/#define[ ][ ]*void[ ]int/d' \ ${LIB}/$file > ${LIB}/${file}.sed rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file ! if cmp $file ${LIB}/$file >/dev/null 2>&1; then ! rm -f ${LIB}/$file fi fi --- 1761,1775 ---- if [ -r ${LIB}/$file ]; then echo Fixing $file ! sed -e '/#[ ]*define[ ][ ]*void[ ]int/d' \ ${LIB}/$file > ${LIB}/${file}.sed rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file ! if cmp $file ${LIB}/$file >/dev/null 2>&1; then ! rm -f ${LIB}/$file ! else ! # Find any include directives that use "file". ! for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do ! dir=`echo $file | sed -e s'|/[^/]*$||'` ! required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" ! done fi fi *************** *** 1486,1489 **** --- 1798,1807 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1506,1509 **** --- 1824,1833 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1524,1527 **** --- 1848,1857 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1579,1582 **** --- 1909,1918 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1598,1601 **** --- 1934,1943 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1621,1624 **** --- 1963,1972 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1634,1638 **** if [ -r ${LIB}/$file ]; then ! if egrep '"C"' ${LIB}/$file >/dev/null 2>/dev/null; then true else --- 1982,1987 ---- if [ -r ${LIB}/$file ]; then ! if egrep '"C"' ${LIB}/$file >/dev/null 2>&1 \ ! || egrep '__BEGIN_DECLS' ${LIB}/$file >/dev/null 2>&1; then true else *************** *** 1648,1651 **** --- 1997,2006 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1680,1683 **** --- 2035,2044 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1698,1701 **** --- 2059,2068 ---- if cmp $file ${LIB}/$file >/dev/null 2>&1; then rm -f ${LIB}/$file + else + # Find any include directives that use "file". + for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do + dir=`echo $file | sed -e s'|/[^/]*$||'` + required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" + done fi fi *************** *** 1714,1754 **** # errors during multiple inclusion on m88k-tektronix-sysv3. for file in time.h sys/time.h ; do ! if [ -r $file ] && [ ! -r ${LIB}/$file ]; then ! cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" ! chmod +w ${LIB}/$file 2>/dev/null ! fi ! if [ -r ${LIB}/$file ]; then ! echo Fixing $file, to protect against multiple inclusion. ! cpp_wrapper=`echo $file | sed -e 's,\.,_,g' -e 's,/,_,g'` ! (echo "#ifndef __GCC_GOT_${cpp_wrapper}_" ! echo "#define __GCC_GOT_${cpp_wrapper}_" ! cat ${LIB}/${file} ! echo '#endif /* !_GCC_GOT_'${cpp_wrapper}_' */') > ${LIB}/${file}.new ! rm -f ${LIB}/$file; mv ${LIB}/${file}.new ${LIB}/$file fi done ! echo 'Removing unneeded directories:' ! cd $LIB ! files=`find . -type d -print | sort -r` ! for file in $files; do ! rmdir $LIB/$file > /dev/null 2>&1 ! done ! if $LINKS; then ! echo 'Making internal symbolic non-directory links' ! cd ${INPUT} ! files=`find . -type l -print` ! for file in $files; do ! dest=`ls -ld $file | sed -n 's/.*-> //p'` ! if expr "$dest" : '[^/].*' > /dev/null; then ! target=${LIB}/`echo file | sed "s|[^/]*\$|$dest|"` ! if [ -f $target ]; then ! ln -s $dest ${LIB}/$file >/dev/null 2>&1 ! fi ! fi ! done fi # Make sure that any include files referenced using double quotes # exist in the fixed directory. This comes last since otherwise --- 2081,2145 ---- # errors during multiple inclusion on m88k-tektronix-sysv3. for file in time.h sys/time.h ; do ! if egrep '#ifndef' $file >/dev/null 2>&1; then ! true ! else ! if [ -r $file ] && [ ! -r ${LIB}/$file ]; then ! cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" ! chmod +w ${LIB}/$file 2>/dev/null ! fi ! if [ -r ${LIB}/$file ]; then ! echo Fixing $file, to protect against multiple inclusion. ! cpp_wrapper=`echo $file | sed -e 's,\.,_,g' -e 's,/,_,g'` ! (echo "#ifndef __GCC_GOT_${cpp_wrapper}_" ! echo "#define __GCC_GOT_${cpp_wrapper}_" ! cat ${LIB}/${file} ! echo '#endif /* !_GCC_GOT_'${cpp_wrapper}_' */') > ${LIB}/${file}.new ! rm -f ${LIB}/$file; mv ${LIB}/${file}.new ${LIB}/$file ! fi fi done ! # Fix fcntl prototype in fcntl.h on LynxOS. ! file=fcntl.h ! if [ -r $file ] && [ ! -r ${LIB}/$file ]; then ! cp $file ${LIB}/$file >/dev/null 2>&1 || echo "Can't copy $file" ! chmod +w ${LIB}/$file 2>/dev/null ! chmod a+r ${LIB}/$file 2>/dev/null ! fi ! if [ -r ${LIB}/$file ]; then ! echo Fixing $file, fcntl declaration ! sed -e 's/\(fcntl.*(int, int, \)int)/\1...)/' \ ! ${LIB}/$file > ${LIB}/${file}.sed ! rm -f ${LIB}/$file; mv ${LIB}/${file}.sed ${LIB}/$file ! if cmp $file ${LIB}/$file >/dev/null 2>&1; then ! rm -f ${LIB}/$file ! else ! # Find any include directives that use "file". ! for include in `egrep '^[ ]*#[ ]*include[ ]*"[^/]' ${LIB}/$file | sed -e 's/^[ ]*#[ ]*include[ ]*"\([^"]*\)".*$/\1/'`; do ! dir=`echo $file | sed -e s'|/[^/]*$||'` ! required="$required ${INPUT} $dir/$include ${LIB}/$dir/$include" ! done ! fi fi + # This loop does not appear to do anything, because it uses file + # rather than $file when setting target. It also appears to be + # unnecessary, since the main loop processes symbolic links. + #if $LINKS; then + # echo 'Making internal symbolic non-directory links' + # cd ${INPUT} + # files=`find . -type l -print` + # for file in $files; do + # dest=`ls -ld $file | sed -n 's/.*-> //p'` + # if expr "$dest" : '[^/].*' > /dev/null; then + # target=${LIB}/`echo file | sed "s|[^/]*\$|$dest|"` + # if [ -f $target ]; then + # ln -s $dest ${LIB}/$file >/dev/null 2>&1 + # fi + # fi + # done + #fi + # Make sure that any include files referenced using double quotes # exist in the fixed directory. This comes last since otherwise *************** *** 1755,1762 **** # we might end up deleting some of these files "because they don't # need any change." ! while [ -n "$required" ]; do newreq= - set x $required - shift while [ $# != 0 ]; do # $1 is the directory to copy from, $2 is the unfixed file, --- 2146,2153 ---- # we might end up deleting some of these files "because they don't # need any change." ! set x $required ! shift ! while [ $# != 0 ]; do newreq= while [ $# != 0 ]; do # $1 is the directory to copy from, $2 is the unfixed file, *************** *** 1777,1781 **** shift; shift; shift done ! required=$newreq done --- 2168,2173 ---- shift; shift; shift done ! set x $newreq ! shift done *************** *** 1783,1786 **** --- 2175,2185 ---- cd $LIB find . -name DONE -exec rm -f '{}' ';' + + echo 'Removing unneeded directories:' + cd $LIB + files=`find . -type d -print | sort -r` + for file in $files; do + rmdir $LIB/$file > /dev/null 2>&1 + done exit 0 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fixproto gcc-2.6.1/fixproto *** gcc-2.6.0/fixproto Sat Jun 18 17:51:31 1994 --- gcc-2.6.1/fixproto Wed Aug 31 20:38:31 1994 *************** *** 58,61 **** --- 58,62 ---- original_dir=`pwd` CPP=${CPP-./cpp} + FIX_HEADER=${FIX_HEADER-$original_dir/fix-header} DEFINES="-D__STDC__=0 -D__cplusplus ${FIXPROTO_DEFINES}" *************** *** 321,325 **** if ${CPP} ${DEFINES} $include_path fixtmp.c >fixtmp.i 2>/dev/null then ! $original_dir/fix-header $rel_source_file $abs_source_file $abs_target_file "$required_list" fixtmp.i 2>/dev/null then ! $FIX_HEADER $rel_source_file $abs_source_file $abs_target_file "$required_list" = FIRST_PSEUDO_REGISTER) ! { ! /* Count an extra reference to the reg. When a reg is ! incremented, spilling it is worse, so we want to make ! that less likely. */ ! reg_n_refs[regno] += loop_depth; ! /* Count the increment as a setting of the register, ! even though it isn't a SET in rtl. */ ! reg_n_sets[regno]++; ! } } } --- 2194,2229 ---- } ! /* If we haven't returned, it means we were able to make the ! auto-inc, so update the status. First, record that this insn ! has an implicit side effect. */ ! ! REG_NOTES (insn) ! = gen_rtx (EXPR_LIST, REG_INC, addr, REG_NOTES (insn)); ! ! /* Modify the old increment-insn to simply copy ! the already-incremented value of our register. */ ! if (! validate_change (incr, &SET_SRC (set), addr, 0)) ! abort (); ! ! /* If that makes it a no-op (copying the register into itself) delete ! it so it won't appear to be a "use" and a "set" of this ! register. */ ! if (SET_DEST (set) == addr) ! { ! PUT_CODE (incr, NOTE); ! NOTE_LINE_NUMBER (incr) = NOTE_INSN_DELETED; ! NOTE_SOURCE_FILE (incr) = 0; ! } ! if (regno >= FIRST_PSEUDO_REGISTER) ! { ! /* Count an extra reference to the reg. When a reg is ! incremented, spilling it is worse, so we want to make ! that less likely. */ ! reg_n_refs[regno] += loop_depth; ! /* Count the increment as a setting of the register, ! even though it isn't a SET in rtl. */ ! reg_n_sets[regno]++; } } *************** *** 2258,2261 **** --- 2293,2310 ---- break; + case SUBREG: + if (GET_CODE (SUBREG_REG (x)) == REG + && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER + && (GET_MODE_SIZE (GET_MODE (x)) + != GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))) + && (INTEGRAL_MODE_P (GET_MODE (x)) + || INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (x))))) + reg_changes_size[REGNO (SUBREG_REG (x))] = 1; + + /* While we're here, optimize this case. */ + x = SUBREG_REG (x); + + /* ... fall through ... */ + case REG: /* See a register other than being set *************** *** 2369,2372 **** --- 2418,2431 ---- ) { + /* Check for the case where the register dying partially + overlaps the register set by this insn. */ + if (regno < FIRST_PSEUDO_REGISTER + && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1) + { + int n = HARD_REGNO_NREGS (regno, GET_MODE (x)); + while (--n >= 0) + some_needed |= dead_or_set_regno_p (insn, regno + n); + } + /* If none of the words in X is needed, make a REG_DEAD note. Otherwise, we must make partial REG_DEAD notes. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/fold-const.c gcc-2.6.1/fold-const.c *** gcc-2.6.0/fold-const.c Wed Jul 13 14:43:50 1994 --- gcc-2.6.1/fold-const.c Wed Oct 5 19:07:23 1994 *************** *** 2837,2840 **** --- 2837,2841 ---- l_const = const_binop (LSHIFT_EXPR, convert (type, l_const), size_int (xll_bitpos), 0); + l_const = const_binop (BIT_AND_EXPR, l_const, ll_mask, 0); } if (r_const) *************** *** 2843,2846 **** --- 2844,2848 ---- r_const = const_binop (LSHIFT_EXPR, convert (type, r_const), size_int (xrl_bitpos), 0); + r_const = const_binop (BIT_AND_EXPR, r_const, rl_mask, 0); } *************** *** 3421,3424 **** --- 3423,3435 ---- #endif /* 0 */ + case COMPONENT_REF: + if (TREE_CODE (arg0) == CONSTRUCTOR) + { + tree m = purpose_member (arg1, CONSTRUCTOR_ELTS (arg0)); + if (m) + t = TREE_VALUE (m); + } + return t; + case RANGE_EXPR: TREE_CONSTANT (t) = wins; *************** *** 3734,3739 **** is volatile. */ ! if (operand_equal_p (arg0, arg1, ! FLOAT_TYPE_P (type) && ! flag_fast_math)) return convert (type, integer_zero_node); --- 3745,3750 ---- is volatile. */ ! if ((! FLOAT_TYPE_P (type) || flag_fast_math) ! && operand_equal_p (arg0, arg1, 0)) return convert (type, integer_zero_node); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/function.c gcc-2.6.1/function.c *** gcc-2.6.0/function.c Wed Jul 13 07:03:22 1994 --- gcc-2.6.1/function.c Mon Oct 31 07:22:11 1994 *************** *** 153,159 **** int current_function_pretend_args_size; ! /* # of bytes of outgoing arguments required to be pushed by the prologue. ! If this is non-zero, it means that ACCUMULATE_OUTGOING_ARGS was defined ! and no stack adjusts will be done on function calls. */ int current_function_outgoing_args_size; --- 153,158 ---- int current_function_pretend_args_size; ! /* # of bytes of outgoing arguments. If ACCUMULATE_OUTGOING_ARGS is ! defined, the needed space is pushed by the prologue. */ int current_function_outgoing_args_size; *************** *** 357,360 **** --- 356,361 ---- /* Non-zero if this temporary is currently in use. */ char in_use; + /* Non-zero if this temporary has its address taken. */ + char addr_taken; /* Nesting level at which this slot is being used. */ int level; *************** *** 462,466 **** void ! push_function_context () { struct function *p = (struct function *) xmalloc (sizeof (struct function)); --- 463,468 ---- void ! push_function_context_to (toplevel) ! int toplevel; { struct function *p = (struct function *) xmalloc (sizeof (struct function)); *************** *** 513,517 **** p->epilogue_delay_list = current_function_epilogue_delay_list; ! save_tree_status (p); save_storage_status (p); save_emit_status (p); --- 515,519 ---- p->epilogue_delay_list = current_function_epilogue_delay_list; ! save_tree_status (p, toplevel); save_storage_status (p); save_emit_status (p); *************** *** 525,528 **** --- 527,536 ---- } + void + push_function_context () + { + push_function_context_to (0); + } + /* Restore the last saved context, at the end of a nested function. This function is called from language-specific code. */ *************** *** 529,533 **** void ! pop_function_context () { struct function *p = outer_function_chain; --- 537,542 ---- void ! pop_function_context_from (toplevel) ! int toplevel; { struct function *p = outer_function_chain; *************** *** 546,550 **** current_function_has_nonlocal_label = p->has_nonlocal_label; current_function_has_nonlocal_goto = p->has_nonlocal_goto; ! current_function_contains_functions = 1; current_function_args_size = p->args_size; current_function_pretend_args_size = p->pretend_args_size; --- 555,560 ---- current_function_has_nonlocal_label = p->has_nonlocal_label; current_function_has_nonlocal_goto = p->has_nonlocal_goto; ! if (! toplevel) ! current_function_contains_functions = 1; current_function_args_size = p->args_size; current_function_pretend_args_size = p->pretend_args_size; *************** *** 578,583 **** temp_slot_level = p->temp_slot_level; current_function_epilogue_delay_list = p->epilogue_delay_list; ! restore_tree_status (p); restore_storage_status (p); restore_expr_status (p); --- 588,594 ---- temp_slot_level = p->temp_slot_level; current_function_epilogue_delay_list = p->epilogue_delay_list; + reg_renumber = 0; ! restore_tree_status (p, toplevel); restore_storage_status (p); restore_expr_status (p); *************** *** 603,606 **** --- 614,622 ---- virtuals_instantiated = 0; } + + void pop_function_context () + { + pop_function_context_from (0); + } /* Allocate fixed slots in the stack frame of the current function. */ *************** *** 785,788 **** --- 801,809 ---- struct temp_slot *p, *best_p = 0; + /* If SIZE is -1 it means that somebody tried to allocate a temporary + of a variable size. */ + if (size == -1) + abort (); + /* First try to find an available, already-allocated temporary that is the exact size we require. */ *************** *** 813,817 **** { p = (struct temp_slot *) oballoc (sizeof (struct temp_slot)); ! p->in_use = 0; p->size = best_p->size - rounded_size; p->slot = gen_rtx (MEM, BLKmode, --- 834,838 ---- { p = (struct temp_slot *) oballoc (sizeof (struct temp_slot)); ! p->in_use = p->addr_taken = 0; p->size = best_p->size - rounded_size; p->slot = gen_rtx (MEM, BLKmode, *************** *** 846,850 **** --- 867,873 ---- p->in_use = 1; + p->addr_taken = 0; p->rtl_expr = sequence_rtl_expr; + if (keep == 2) { *************** *** 970,973 **** --- 993,1018 ---- } + /* If X could be a reference to a temporary slot, mark the fact that its + adddress was taken. */ + + void + mark_temp_addr_taken (x) + rtx x; + { + struct temp_slot *p; + + if (x == 0) + return; + + /* If X is not in memory or is at a constant address, it cannot be in + a temporary slot. */ + if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) + return; + + p = find_temp_slot_from_address (XEXP (x, 0)); + if (p != 0) + p->addr_taken = 1; + } + /* If X could be a reference to a temporary slot, mark that slot as belonging to the to one level higher. If X matched one of our slots, just mark that *************** *** 982,989 **** rtx x; { ! struct temp_slot *p; if (x == 0) ! return; /* If X is a register that is being used as a pointer, see if we have --- 1027,1042 ---- rtx x; { ! struct temp_slot *p = 0; + /* If there is no result, we still might have some objects whose address + were taken, so we need to make sure they stay around. */ if (x == 0) ! { ! for (p = temp_slots; p; p = p->next) ! if (p->in_use && p->level == temp_slot_level && p->addr_taken) ! p->level--; ! ! return; ! } /* If X is a register that is being used as a pointer, see if we have *************** *** 991,1010 **** the code below, we really should preserve all non-kept slots if we can't find a match, but that seems to be much too costly. */ ! if (GET_CODE (x) == REG && REGNO_POINTER_FLAG (REGNO (x)) ! && (p = find_temp_slot_from_address (x)) != 0) ! { ! p->level--; return; } - - /* If X is not in memory or is at a constant address, it cannot be in - a temporary slot. */ - if (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0))) - return; /* First see if we can find a match. */ ! p = find_temp_slot_from_address (XEXP (x, 0)); if (p != 0) { p->level--; return; --- 1044,1076 ---- the code below, we really should preserve all non-kept slots if we can't find a match, but that seems to be much too costly. */ ! if (GET_CODE (x) == REG && REGNO_POINTER_FLAG (REGNO (x))) ! p = find_temp_slot_from_address (x); ! ! /* If X is not in memory or is at a constant address, it cannot be in ! a temporary slot, but it can contain something whose address was ! taken. */ ! if (p == 0 && (GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))) ! { ! for (p = temp_slots; p; p = p->next) ! if (p->in_use && p->level == temp_slot_level && p->addr_taken) ! p->level--; ! return; } /* First see if we can find a match. */ ! if (p == 0) ! p = find_temp_slot_from_address (XEXP (x, 0)); ! if (p != 0) { + /* Move everything at our level whose address was taken to our new + level in case we used its address. */ + struct temp_slot *q; + + for (q = temp_slots; q; q = q->next) + if (q != p && q->addr_taken && q->level == p->level) + q->level--; + p->level--; return; *************** *** 2192,2195 **** --- 2258,2263 ---- register int offset = INTVAL (XEXP (bitfield, 2)); + rtx insns; + /* Adjust OFFSET to count bits from low-address byte. */ #if BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN *************** *** 2210,2215 **** } ! memref = change_address (memref, mode, plus_constant (XEXP (memref, 0), offset)); /* Store this memory reference where --- 2278,2287 ---- } ! start_sequence (); ! memref = change_address (memref, mode, plus_constant (XEXP (memref, 0), offset)); + insns = get_insns (); + end_sequence (); + emit_insns_before (insns, insn); /* Store this memory reference where *************** *** 3151,3154 **** --- 3223,3233 ---- } + /* If the parm is to be passed as a transparent union, use the + type of the first field for the tests below. We have already + verified that the modes are the same. */ + if (DECL_TRANSPARENT_UNION (parm) + || TYPE_TRANSPARENT_UNION (passed_type)) + passed_type = TREE_TYPE (TYPE_FIELDS (passed_type)); + /* See if this arg was passed by invisible reference. It is if it is an object whose size depends on the contents of the *************** *** 3427,3430 **** --- 3506,3512 ---- abort (); + if (TREE_READONLY (parm)) + RTX_UNCHANGING_P (stack_parm) = 1; + move_block_from_reg (REGNO (entry_parm), validize_mem (stack_parm), *************** *** 4252,4256 **** for (link = trampoline_list; link; link = TREE_CHAIN (link)) if (TREE_PURPOSE (link) == function) ! return XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0); for (fp = outer_function_chain; fp; fp = fp->next) for (link = fp->trampoline_list; link; link = TREE_CHAIN (link)) --- 4334,4340 ---- for (link = trampoline_list; link; link = TREE_CHAIN (link)) if (TREE_PURPOSE (link) == function) ! return ! round_trampoline_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0)); ! for (fp = outer_function_chain; fp; fp = fp->next) for (link = fp->trampoline_list; link; link = TREE_CHAIN (link)) *************** *** 4694,4697 **** --- 4778,4786 ---- /* Expand a call to __main at the beginning of a possible main function. */ + #if defined(INIT_SECTION_ASM_OP) && !defined(INVOKE__main) + #undef HAS_INIT_SECTION + #define HAS_INIT_SECTION + #endif + void expand_main_function () *************** *** 4701,4708 **** /* The zero below avoids a possible parse error */ 0; ! #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main) emit_library_call (gen_rtx (SYMBOL_REF, Pmode, NAME__MAIN), 0, VOIDmode, 0); ! #endif /* not INIT_SECTION_ASM_OP or INVOKE__main */ } } --- 4790,4797 ---- /* The zero below avoids a possible parse error */ 0; ! #if !defined (HAS_INIT_SECTION) emit_library_call (gen_rtx (SYMBOL_REF, Pmode, NAME__MAIN), 0, VOIDmode, 0); ! #endif /* not HAS_INIT_SECTION */ } } *************** *** 4859,4863 **** { /* Returning something that won't go in a register. */ ! register rtx value_address; #ifdef PCC_STATIC_STRUCT_RETURN --- 4948,4952 ---- { /* Returning something that won't go in a register. */ ! register rtx value_address = 0; #ifdef PCC_STATIC_STRUCT_RETURN *************** *** 4966,4974 **** /* Fetch static chain values for containing functions. */ tem = decl_function_context (current_function_decl); ! /* If not doing stupid register allocation, then start off with the static ! chain pointer in a pseudo register. Otherwise, we use the stack ! address that was generated above. */ if (tem && ! obey_regdecls) ! last_ptr = copy_to_reg (static_chain_incoming_rtx); context_display = 0; while (tem) --- 5055,5075 ---- /* Fetch static chain values for containing functions. */ tem = decl_function_context (current_function_decl); ! /* If not doing stupid register allocation copy the static chain ! pointer into a psuedo. If we have small register classes, copy the ! value from memory if static_chain_incoming_rtx is a REG. If we do ! stupid register allocation, we use the stack address generated above. */ if (tem && ! obey_regdecls) ! { ! #ifdef SMALL_REGISTER_CLASSES ! /* If the static chain originally came in a register, put it back ! there, then move it out in the next insn. The reason for ! this peculiar code is to satisfy function integration. */ ! if (GET_CODE (static_chain_incoming_rtx) == REG) ! emit_move_insn (static_chain_incoming_rtx, last_ptr); ! #endif ! ! last_ptr = copy_to_reg (static_chain_incoming_rtx); ! } ! context_display = 0; while (tem) *************** *** 5037,5041 **** if (NON_SAVING_SETJMP && current_function_calls_setjmp) { ! setjmp_protect (DECL_INITIAL (current_function_decl)); setjmp_protect_args (); } --- 5138,5144 ---- if (NON_SAVING_SETJMP && current_function_calls_setjmp) { ! if (DECL_INITIAL (current_function_decl) != error_mark_node) ! setjmp_protect (DECL_INITIAL (current_function_decl)); ! setjmp_protect_args (); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/future.options gcc-2.6.1/future.options *** gcc-2.6.0/future.options --- gcc-2.6.1/future.options Mon Oct 17 14:43:18 1994 *************** *** 0 **** --- 1,29 ---- + From: friedman@gnu.ai.mit.edu (Noah Friedman) + To: roland@gnu.ai.mit.edu (Roland McGrath), + rms@gnu.ai.mit.edu (Richard Stallman), + jimb@gnu.ai.mit.edu (Jim Blandy), + mib@gnu.ai.mit.edu (Michael Bushnell) + Cc: cgw@sol.acs.unt.edu (chris williams), + clc@gnu.ai.mit.edu (Christian Longshore Claiborn) + Subject: Some gcc options we'd like to see. + Date: Mon, 28 Jun 93 00:45:09 EST + Reply-To: friedman@gnu.ai.mit.edu + + -Waggravate-return + -Wcast-spell + -Wcaste-align + -Win + -Wmissing-protons + -Wredundant-repetitions + -antsy + -fbungee-jump + -fexpensive-operations + -fextra-strength + -fjesus-saves + -fkeep-programmers-inline + -fno-peeping-toms + -fruit-roll-ups + -fshort-enough + -mno-dialogue + -pedophile + -vomit-frame-pointer diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/gbl-ctors.h gcc-2.6.1/gbl-ctors.h *** gcc-2.6.0/gbl-ctors.h Wed Mar 23 16:32:36 1994 --- gcc-2.6.1/gbl-ctors.h Fri Aug 5 12:20:13 1994 *************** *** 64,70 **** out-of-sync with one another. */ ! /* The first word may or may not contain the number of pointers in the table. In all cases, the table is null-terminated. ! We ignore the first word and scan up to the null. */ /* Some systems use a different strategy for finding the ctors. --- 64,72 ---- out-of-sync with one another. */ ! /* Some systems place the number of pointers ! in the first word of the table. ! On other systems, that word is -1. In all cases, the table is null-terminated. ! If the length is not recorded, count up to the null. */ /* Some systems use a different strategy for finding the ctors. *************** *** 73,80 **** #define DO_GLOBAL_CTORS_BODY \ do { \ ! func_ptr *p; \ ! for (p = __CTOR_LIST__ + 1; *p; ) \ ! (*p++) (); \ ! } while (0) #endif --- 75,85 ---- #define DO_GLOBAL_CTORS_BODY \ do { \ ! unsigned long nptrs = (unsigned long) __CTOR_LIST__[0]; \ ! unsigned i; \ ! if (nptrs == -1) \ ! for (nptrs = 0; __CTOR_LIST__[nptrs + 1] != 0; nptrs++); \ ! for (i = nptrs; i >= 1; i--) \ ! __CTOR_LIST__[i] (); \ ! } while (0) #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/gcc.c gcc-2.6.1/gcc.c *** gcc-2.6.0/gcc.c Mon Jul 11 15:08:58 1994 --- gcc-2.6.1/gcc.c Thu Oct 27 18:49:58 1994 *************** *** 35,39 **** --- 35,45 ---- #include #include + #include + + #ifndef WINNT #include /* May get R_OK, etc. on some systems. */ + #else + #include + #endif #include "config.h" *************** *** 55,58 **** --- 61,77 ---- #endif + #ifndef WIFSIGNALED + #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f) + #endif + #ifndef WTERMSIG + #define WTERMSIG(S) ((S) & 0x7f) + #endif + #ifndef WIFEXITED + #define WIFEXITED(S) (((S) & 0xff) == 0) + #endif + #ifndef WEXITSTATUS + #define WEXITSTATUS(S) (((S) & 0xff00) >> 8) + #endif + /* Add prototype support. */ #ifndef PROTO *************** *** 82,85 **** --- 101,109 ---- #endif + /* Define O_RDONLY if the system hasn't defined it for us. */ + #ifndef O_RDONLY + #define O_RDONLY 0 + #endif + #ifndef GENERIC_PTR #if defined (USE_PROTOTYPES) ? USE_PROTOTYPES : defined (__STDC__) *************** *** 126,129 **** --- 150,159 ---- #endif + #ifndef DIR_SEPARATOR + #define DIR_SEPARATOR '/' + #endif + + static char dir_separator_str[] = {DIR_SEPARATOR, 0}; + #define obstack_chunk_alloc xmalloc #define obstack_chunk_free free *************** *** 132,136 **** extern char *getenv (); ! extern int errno, sys_nerr; #if defined(bsd4_4) || defined(__NetBSD__) extern const char *const sys_errlist[]; --- 162,170 ---- extern char *getenv (); ! #ifndef errno ! extern int errno; ! #endif ! ! extern int sys_nerr; #if defined(bsd4_4) || defined(__NetBSD__) extern const char *const sys_errlist[]; *************** *** 230,234 **** static char *handle_braces PROTO((char *)); static char *save_string PROTO((char *, int)); ! static char *concat PROTO((char *, char *, char *)); static int do_spec PROTO((char *)); static int do_spec_1 PROTO((char *, int, char *)); --- 264,272 ---- static char *handle_braces PROTO((char *)); static char *save_string PROTO((char *, int)); ! static char *concat PROTO((char *, char *)); ! static char *concat3 PROTO((char *, char *, char *)); ! static char *concat4 PROTO((char *, char *, char *, char *)); ! static char *concat6 PROTO((char *, char *, char *, char *, char *, \ ! char *)); static int do_spec PROTO((char *)); static int do_spec_1 PROTO((char *, int, char *)); *************** *** 311,314 **** --- 349,353 ---- %X Output the accumulated linker options specified by compilations. %Y Output the accumulated assembler options specified by compilations. + %Z Output the accumulated preprocessor options specified by compilations. %v1 Substitute the major version number of GCC. (For version 2.5.n, this is 2.) *************** *** 320,324 **** used here. This can be used to run a post-processor after the assembler has done it's job. ! %D Dump out a -L option for each directory in startfile_prefix. If multilib_dir is set, extra entries are generated with it affixed. %l process LINK_SPEC as a spec. --- 359,363 ---- used here. This can be used to run a post-processor after the assembler has done it's job. ! %D Dump out a -L option for each directory in startfile_prefixes. If multilib_dir is set, extra entries are generated with it affixed. %l process LINK_SPEC as a spec. *************** *** 426,430 **** #ifndef STARTFILE_SPEC #define STARTFILE_SPEC \ ! "%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}" #endif --- 465,469 ---- #ifndef STARTFILE_SPEC #define STARTFILE_SPEC \ ! "%{!shared:%{pg:gcrt0.o%s}%{!pg:%{p:mcrt0.o%s}%{!p:crt0.o%s}}}" #endif *************** *** 536,540 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \ --- 575,579 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1 %{!pipe:%g.i} %1 \ *************** *** 557,561 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %W{o*}}\ %{!E:%e-E required when input is from standard input}"}, --- 596,600 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %W{o*}}\ %{!E:%e-E required when input is from standard input}"}, *************** *** 570,574 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \ --- 609,613 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.i}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1obj %{!pipe:%g.i} %1 \ *************** *** 594,598 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %W{o*}"}, {".cc", "@c++"}, --- 633,637 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %W{o*}"}, {".cc", "@c++"}, *************** *** 599,602 **** --- 638,642 ---- {".cxx", "@c++"}, {".cpp", "@c++"}, + {".c++", "@c++"}, {".C", "@c++"}, {"@c++", *************** *** 608,612 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional} %{trigraphs}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\ --- 648,652 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional} %{trigraphs}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.ii}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:cc1plus %{!pipe:%g.ii} %1 %2\ *************** *** 655,659 **** %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*}\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\ --- 695,699 ---- %c %{O*:%{!O0:-D__OPTIMIZE__}} %{traditional} %{ftraditional:-traditional}\ %{traditional-cpp:-traditional}\ ! %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C %{D*} %{U*} %{i*} %Z\ %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n", "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\ *************** *** 718,722 **** /* A vector of options to give to the linker. ! These options are accumulated by -Xlinker and -Wl, and substituted into the linker command with %X. */ static int n_linker_options; --- 758,762 ---- /* A vector of options to give to the linker. ! These options are accumulated by %x, and substituted into the linker command with %X. */ static int n_linker_options; *************** *** 725,731 **** /* A vector of options to give to the assembler. These options are accumulated by -Wa, ! and substituted into the assembler command with %X. */ static int n_assembler_options; static char **assembler_options; /* Define how to map long options into short ones. */ --- 765,777 ---- /* A vector of options to give to the assembler. These options are accumulated by -Wa, ! and substituted into the assembler command with %Y. */ static int n_assembler_options; static char **assembler_options; + + /* A vector of options to give to the preprocessor. + These options are accumulated by -Wp, + and substituted into the preprocessor command with %Z. */ + static int n_preprocessor_options; + static char **preprocessor_options; /* Define how to map long options into short ones. */ *************** *** 742,746 **** o => argument optional. j => join argument to equivalent, making one word. ! * => allow other text after NAME as an argument. */ char *arg_info; }; --- 788,792 ---- o => argument optional. j => join argument to equivalent, making one word. ! * => require other text after NAME as an argument. */ char *arg_info; }; *************** *** 751,824 **** struct option_map option_map[] = { ! {"--profile-blocks", "-a", 0}, ! {"--target", "-b", "a"}, {"--compile", "-c", 0}, {"--dump", "-d", "a"}, {"--entry", "-e", 0}, ! {"--debug", "-g", "oj"}, ! {"--include", "-include", "a"}, {"--imacros", "-imacros", "a"}, ! {"--include-prefix", "-iprefix", "a"}, {"--include-directory-after", "-idirafter", "a"}, {"--include-with-prefix", "-iwithprefix", "a"}, {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, {"--include-with-prefix-after", "-iwithprefix", "a"}, ! {"--machine-", "-m", "*j"}, {"--machine", "-m", "aj"}, {"--no-standard-includes", "-nostdinc", 0}, {"--no-standard-libraries", "-nostdlib", 0}, - {"--no-precompiled-includes", "-noprecomp", 0}, - {"--output", "-o", "a"}, - {"--profile", "-p", 0}, - {"--quiet", "-q", 0}, - {"--silent", "-q", 0}, - {"--force-link", "-u", "a"}, - {"--verbose", "-v", 0}, - {"--version", "-dumpversion", 0}, {"--no-warnings", "-w", 0}, - {"--language", "-x", "a"}, - - {"--assert", "-A", "a"}, - {"--prefix", "-B", "a"}, - {"--comments", "-C", 0}, - {"--define-macro", "-D", "a"}, - {"--preprocess", "-E", 0}, - {"--trace-includes", "-H", 0}, - {"--include-directory", "-I", "a"}, - {"--include-barrier", "-I-", 0}, - {"--library-directory", "-L", "a"}, - {"--dependencies", "-M", 0}, - {"--user-dependencies", "-MM", 0}, - {"--write-dependencies", "-MD", 0}, - {"--write-user-dependencies", "-MMD", 0}, - {"--print-missing-file-dependencies", "-MG", 0}, {"--optimize", "-O", "oj"}, ! {"--no-line-commands", "-P", 0}, ! {"--assemble", "-S", 0}, ! {"--undefine-macro", "-U", "a"}, ! {"--use-version", "-V", "a"}, ! {"--for-assembler", "-Wa", "a"}, ! {"--extra-warnings", "-W", 0}, ! {"--all-warnings", "-Wall", 0}, ! {"--warn-", "-W", "*j"}, ! {"--for-linker", "-Xlinker", "a"}, ! ! {"--ansi", "-ansi", 0}, ! {"--traditional", "-traditional", 0}, ! {"--traditional-cpp", "-traditional-cpp", 0}, ! {"--trigraphs", "-trigraphs", 0}, ! {"--pipe", "-pipe", 0}, ! {"--dumpbase", "-dumpbase", "a"}, {"--pedantic", "-pedantic", 0}, {"--pedantic-errors", "-pedantic-errors", 0}, ! {"--save-temps", "-save-temps", 0}, ! {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, {"--print-file-name", "-print-file-name=", "aj"}, ! {"--print-prog-name", "-print-prog-name=", "aj"}, {"--print-multi-lib", "-print-multi-lib", 0}, {"--print-multi-directory", "-print-multi-directory", 0}, ! {"--static", "-static", 0}, {"--shared", "-shared", 0}, {"--symbolic", "-symbolic", 0}, {"--", "-f", "*j"} }; --- 797,868 ---- struct option_map option_map[] = { ! {"--all-warnings", "-Wall", 0}, ! {"--ansi", "-ansi", 0}, ! {"--assemble", "-S", 0}, ! {"--assert", "-A", "a"}, ! {"--comments", "-C", 0}, {"--compile", "-c", 0}, + {"--debug", "-g", "oj"}, + {"--define-macro", "-D", "a"}, + {"--dependencies", "-M", 0}, {"--dump", "-d", "a"}, + {"--dumpbase", "-dumpbase", "a"}, {"--entry", "-e", 0}, ! {"--extra-warnings", "-W", 0}, ! {"--for-assembler", "-Wa", "a"}, ! {"--for-linker", "-Xlinker", "a"}, ! {"--force-link", "-u", "a"}, {"--imacros", "-imacros", "a"}, ! {"--include", "-include", "a"}, ! {"--include-barrier", "-I-", 0}, ! {"--include-directory", "-I", "a"}, {"--include-directory-after", "-idirafter", "a"}, + {"--include-prefix", "-iprefix", "a"}, {"--include-with-prefix", "-iwithprefix", "a"}, {"--include-with-prefix-before", "-iwithprefixbefore", "a"}, {"--include-with-prefix-after", "-iwithprefix", "a"}, ! {"--language", "-x", "a"}, ! {"--library-directory", "-L", "a"}, {"--machine", "-m", "aj"}, + {"--machine-", "-m", "*j"}, + {"--no-line-commands", "-P", 0}, + {"--no-precompiled-includes", "-noprecomp", 0}, {"--no-standard-includes", "-nostdinc", 0}, {"--no-standard-libraries", "-nostdlib", 0}, {"--no-warnings", "-w", 0}, {"--optimize", "-O", "oj"}, ! {"--output", "-o", "a"}, {"--pedantic", "-pedantic", 0}, {"--pedantic-errors", "-pedantic-errors", 0}, ! {"--pipe", "-pipe", 0}, ! {"--prefix", "-B", "a"}, ! {"--preprocess", "-E", 0}, {"--print-file-name", "-print-file-name=", "aj"}, ! {"--print-libgcc-file-name", "-print-libgcc-file-name", 0}, ! {"--print-missing-file-dependencies", "-MG", 0}, {"--print-multi-lib", "-print-multi-lib", 0}, {"--print-multi-directory", "-print-multi-directory", 0}, ! {"--print-prog-name", "-print-prog-name=", "aj"}, ! {"--profile", "-p", 0}, ! {"--profile-blocks", "-a", 0}, ! {"--quiet", "-q", 0}, ! {"--save-temps", "-save-temps", 0}, {"--shared", "-shared", 0}, + {"--silent", "-q", 0}, + {"--static", "-static", 0}, {"--symbolic", "-symbolic", 0}, + {"--target", "-b", "a"}, + {"--trace-includes", "-H", 0}, + {"--traditional", "-traditional", 0}, + {"--traditional-cpp", "-traditional-cpp", 0}, + {"--trigraphs", "-trigraphs", 0}, + {"--undefine-macro", "-U", "a"}, + {"--use-version", "-V", "a"}, + {"--user-dependencies", "-MM", 0}, + {"--verbose", "-v", 0}, + {"--version", "-dumpversion", 0}, + {"--warn-", "-W", "*j"}, + {"--write-dependencies", "-MD", 0}, + {"--write-user-dependencies", "-MMD", 0}, {"--", "-f", "*j"} }; *************** *** 833,837 **** char ***argvp; { ! int i, j; int argc = *argcp; char **argv = *argvp; --- 877,881 ---- char ***argvp; { ! int i, j, k; int argc = *argcp; char **argv = *argvp; *************** *** 851,855 **** { int optlen = strlen (option_map[j].name); ! int complen = strlen (argv[i]); char *arginfo = option_map[j].arg_info; --- 895,900 ---- { int optlen = strlen (option_map[j].name); ! int arglen = strlen (argv[i]); ! int complen = arglen > optlen ? optlen : arglen; char *arginfo = option_map[j].arg_info; *************** *** 856,867 **** if (arginfo == 0) arginfo = ""; ! if (complen > optlen) ! complen = optlen; if (!strncmp (argv[i], option_map[j].name, complen)) { - int extra = strlen (argv[i]) > optlen; char *arg = 0; ! if (extra) { /* If the option has an argument, accept that. */ --- 901,926 ---- if (arginfo == 0) arginfo = ""; ! if (!strncmp (argv[i], option_map[j].name, complen)) { char *arg = 0; ! if (arglen < optlen) ! { ! for (k = j + 1; ! k < sizeof (option_map) / sizeof (option_map[0]); ! k++) ! if (strlen (option_map[k].name) >= arglen ! && !strncmp (argv[i], option_map[k].name, arglen)) ! { ! error ("Ambiguous abbreviation %s", argv[i]); ! break; ! } ! ! if (k != sizeof (option_map) / sizeof (option_map[0])) ! break; ! } ! ! if (arglen > optlen) { /* If the option has an argument, accept that. */ *************** *** 868,875 **** if (argv[i][optlen] == '=') arg = argv[i] + optlen + 1; ! /* If this mapping allows extra text at end of name, accept that as "argument". */ else if (index (arginfo, '*') != 0) arg = argv[i] + optlen; /* Otherwise, extra text at end means mismatch. Try other mappings. */ --- 927,936 ---- if (argv[i][optlen] == '=') arg = argv[i] + optlen + 1; ! ! /* If this mapping requires extra text at end of name, accept that as "argument". */ else if (index (arginfo, '*') != 0) arg = argv[i] + optlen; + /* Otherwise, extra text at end means mismatch. Try other mappings. */ *************** *** 877,885 **** continue; } else if (index (arginfo, '*') != 0) ! error ("Incomplete `%s' option", option_map[j].name); /* Handle arguments. */ ! if (index (arginfo, 'o') != 0) { if (arg == 0) --- 938,950 ---- continue; } + else if (index (arginfo, '*') != 0) ! { ! error ("Incomplete `%s' option", option_map[j].name); ! break; ! } /* Handle arguments. */ ! if (index (arginfo, 'a') != 0) { if (arg == 0) *************** *** 886,891 **** { if (i + 1 == argc) ! error ("Missing argument to `%s' option", ! option_map[j].name); arg = argv[++i]; } --- 951,960 ---- { if (i + 1 == argc) ! { ! error ("Missing argument to `%s' option", ! option_map[j].name); ! break; ! } ! arg = argv[++i]; } *************** *** 893,897 **** else if (index (arginfo, '*') != 0) ; ! else if (index (arginfo, 'a') == 0) { if (arg != 0) --- 962,966 ---- else if (index (arginfo, '*') != 0) ; ! else if (index (arginfo, 'o') == 0) { if (arg != 0) *************** *** 903,908 **** /* Store the translation as one argv elt or as two. */ if (arg != 0 && index (arginfo, 'j') != 0) ! newv[newindex++] = concat (option_map[j].equivalent, ! arg, ""); else if (arg != 0) { --- 972,976 ---- /* Store the translation as one argv elt or as two. */ if (arg != 0 && index (arginfo, 'j') != 0) ! newv[newindex++] = concat (option_map[j].equivalent, arg); else if (arg != 0) { *************** *** 918,921 **** --- 986,990 ---- i++; } + /* Handle old-fashioned options--just copy them through, with their arguments. */ *************** *** 983,987 **** /* Open and stat the file. */ ! desc = open (filename, 0, 0); if (desc < 0) pfatal_with_name (filename); --- 1052,1056 ---- /* Open and stat the file. */ ! desc = open (filename, O_RDONLY, 0); if (desc < 0) pfatal_with_name (filename); *************** *** 1143,1147 **** old_spec = sl->spec; if (name && spec[0] == '+' && isspace (spec[1])) ! sl->spec = concat (old_spec, spec + 1, ""); else sl->spec = save_string (spec, strlen (spec)); --- 1212,1216 ---- old_spec = sl->spec; if (name && spec[0] == '+' && isspace (spec[1])) ! sl->spec = concat (old_spec, spec + 1); else sl->spec = save_string (spec, strlen (spec)); *************** *** 1238,1250 **** /* List of prefixes to try when looking for executables. */ ! static struct path_prefix exec_prefix = { 0, 0, "exec" }; /* List of prefixes to try when looking for startup (crt0) files. */ ! static struct path_prefix startfile_prefix = { 0, 0, "startfile" }; /* List of prefixes to try when looking for include files. */ ! static struct path_prefix include_prefix = { 0, 0, "include" }; /* Suffix to attach to directories searched for commands. --- 1307,1319 ---- /* List of prefixes to try when looking for executables. */ ! static struct path_prefix exec_prefixes = { 0, 0, "exec" }; /* List of prefixes to try when looking for startup (crt0) files. */ ! static struct path_prefix startfile_prefixes = { 0, 0, "startfile" }; /* List of prefixes to try when looking for include files. */ ! static struct path_prefix include_prefixes = { 0, 0, "include" }; /* Suffix to attach to directories searched for commands. *************** *** 1496,1511 **** #endif ! base = choose_temp_base_try ("/usr/tmp", base); ! base = choose_temp_base_try ("/tmp", base); ! /* If all else fails, use the current directory! */ ! if (base == (char *)0) ! base = "./"; len = strlen (base); ! temp_filename = xmalloc (len + sizeof("/ccXXXXXX") + 1); strcpy (temp_filename, base); ! if (len > 0 && temp_filename[len-1] != '/') ! temp_filename[len++] = '/'; strcpy (temp_filename + len, "ccXXXXXX"); --- 1565,1583 ---- #endif ! base = choose_temp_base_try (concat4 (dir_separator_str, "usr", ! dir_separator_str, "tmp"), ! base); ! base = choose_temp_base_try (concat (dir_separator_str, "tmp"), base); ! /* If all else fails, use the current directory! */ ! if (base == (char *)0) base = concat(".", dir_separator_str); len = strlen (base); ! temp_filename = xmalloc (len + strlen (concat (dir_separator_str, ! "ccXXXXXX")) + 1); strcpy (temp_filename, base); ! if (len > 0 && temp_filename[len-1] != '/' ! && temp_filename[len-1] != DIR_SEPARATOR) ! temp_filename[len++] = DIR_SEPARATOR; strcpy (temp_filename + len, "ccXXXXXX"); *************** *** 1651,1655 **** /* Determine the filename to execute (special case for absolute paths). */ ! if (*name == '/') { if (access (name, mode)) --- 1723,1727 ---- /* Determine the filename to execute (special case for absolute paths). */ ! if (*name == '/' || *name == DIR_SEPARATOR) { if (access (name, mode)) *************** *** 1871,1881 **** (i.e. its output should be piped to the next one.) */ - #ifndef OS2 #ifdef __MSDOS__ ! /* Declare these to avoid compilation error. They won't be called. */ ! int execv(const char *a, const char **b){} ! int execvp(const char *a, const char **b){} ! static int pexecute (search_flag, program, argv, not_last) --- 1943,1949 ---- (i.e. its output should be piped to the next one.) */ #ifdef __MSDOS__ ! #include static int pexecute (search_flag, program, argv, not_last) *************** *** 1885,1888 **** --- 1953,1959 ---- int not_last; { + #ifdef __GO32__ + int i = (search_flag ? spawnv : spawnvp) (1, program, argv); + #else char *scmd, *rf; FILE *argfile; *************** *** 1913,1916 **** --- 1984,1988 ---- remove (rf); + #endif if (i == -1) *************** *** 1919,1927 **** return MIN_FATAL_STATUS << 8; } - return i << 8; } ! #else /* not __MSDOS__ */ static int --- 1991,2000 ---- return MIN_FATAL_STATUS << 8; } return i << 8; } ! #endif ! ! #if !defined(__MSDOS__) && !defined(OS2) && !defined(WINNT) static int *************** *** 2013,2019 **** } ! #endif /* not __MSDOS__ */ ! #else /* not OS2 */ static int pexecute (search_flag, program, argv, not_last) --- 2086,2138 ---- } ! #endif /* not __MSDOS__ and not OS2 */ ! ! #if defined(OS2) || defined(WINNT) ! ! #ifdef WINNT ! ! char ** ! fix_argv (argvec) ! char **argvec ! { ! int i; ! ! for (i = 1; argvec[i] != 0; i++) ! { ! int len, j; ! char *temp, *newtemp; ! ! temp = argvec[i]; ! len = strlen (temp); ! for (j = 0; j < len; j++) ! { ! if (temp[j] == '"') ! { ! newtemp = xmalloc (len + 2); ! strncpy (newtemp, temp, j); ! newtemp [j] = '\\'; ! strncpy (&newtemp [j+1], &temp [j], len-j); ! newtemp [len+1] = 0; ! free (temp); ! temp = newtemp; ! len++; ! j++; ! } ! } ! ! argvec[i] = temp; ! } ! ! return argvec; ! } ! ! #define FIX_ARGV(a) fix_argv(a) ! ! #else ! ! #define FIX_ARGV(a) a + #endif /* OS2 or WINNT */ + static int pexecute (search_flag, program, argv, not_last) *************** *** 2023,2029 **** int not_last; { ! return (search_flag ? spawnv : spawnvp) (1, program, argv); } ! #endif /* not OS2 */ /* Execute the command specified by the arguments on the current line of spec. --- 2142,2149 ---- int not_last; { ! return (search_flag ? spawnv : spawnvp) (1, program, FIX_ARGV (argv)); } ! #endif /* OS2 or WINNT */ ! /* Execute the command specified by the arguments on the current line of spec. *************** *** 2063,2067 **** commands[0].prog = argbuf[0]; /* first command. */ commands[0].argv = &argbuf[0]; ! string = find_a_file (&exec_prefix, commands[0].prog, X_OK); if (string) commands[0].argv[0] = string; --- 2183,2187 ---- commands[0].prog = argbuf[0]; /* first command. */ commands[0].argv = &argbuf[0]; ! string = find_a_file (&exec_prefixes, commands[0].prog, X_OK); if (string) commands[0].argv[0] = string; *************** *** 2076,2080 **** commands[n_commands].prog = argbuf[i + 1]; commands[n_commands].argv = &argbuf[i + 1]; ! string = find_a_file (&exec_prefix, commands[n_commands].prog, X_OK); if (string) commands[n_commands].argv[0] = string; --- 2196,2200 ---- commands[n_commands].prog = argbuf[i + 1]; commands[n_commands].argv = &argbuf[i + 1]; ! string = find_a_file (&exec_prefixes, commands[n_commands].prog, X_OK); if (string) commands[n_commands].argv[0] = string; *************** *** 2146,2151 **** --- 2266,2275 ---- status = pid = commands[i].pid; #else + #ifdef WINNT + pid = cwait (&status, commands[i].pid, WAIT_CHILD); + #else pid = wait (&status); #endif + #endif if (pid < 0) abort (); *************** *** 2158,2168 **** prog = commands[j].prog; ! if ((status & 0x7F) != 0) { fatal ("Internal compiler error: program %s got fatal signal %d", ! prog, (status & 0x7F)); signal_count++; } ! if (((status & 0xFF00) >> 8) >= MIN_FATAL_STATUS) ret_code = -1; } --- 2282,2294 ---- prog = commands[j].prog; ! if (WIFSIGNALED (status)) { fatal ("Internal compiler error: program %s got fatal signal %d", ! prog, WTERMSIG (status)); signal_count++; + ret_code = -1; } ! else if (WIFEXITED (status) ! && WEXITSTATUS (status) >= MIN_FATAL_STATUS) ret_code = -1; } *************** *** 2245,2250 **** if (gcc_exec_prefix) { ! add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, gcc_exec_prefix, 0, 0, NULL_PTR); } --- 2371,2376 ---- if (gcc_exec_prefix) { ! add_prefix (&exec_prefixes, gcc_exec_prefix, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, gcc_exec_prefix, 0, 0, NULL_PTR); } *************** *** 2265,2274 **** strncpy (nstore, startp, endp-startp); if (endp == startp) ! { ! strcpy (nstore, "./"); ! } ! else if (endp[-1] != '/') { ! nstore[endp-startp] = '/'; nstore[endp-startp+1] = 0; } --- 2391,2398 ---- strncpy (nstore, startp, endp-startp); if (endp == startp) ! strcpy (nstore, concat (".", dir_separator_str)); ! else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) { ! nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; } *************** *** 2275,2279 **** else nstore[endp-startp] = 0; ! add_prefix (&exec_prefix, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; --- 2399,2403 ---- else nstore[endp-startp] = 0; ! add_prefix (&exec_prefixes, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; *************** *** 2298,2307 **** strncpy (nstore, startp, endp-startp); if (endp == startp) { ! strcpy (nstore, "./"); ! } ! else if (endp[-1] != '/') ! { ! nstore[endp-startp] = '/'; nstore[endp-startp+1] = 0; } --- 2422,2429 ---- strncpy (nstore, startp, endp-startp); if (endp == startp) + strcpy (nstore, concat (".", dir_separator_str)); + else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) { ! nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; } *************** *** 2308,2312 **** else nstore[endp-startp] = 0; ! add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; --- 2430,2434 ---- else nstore[endp-startp] = 0; ! add_prefix (&startfile_prefixes, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; *************** *** 2332,2341 **** strncpy (nstore, startp, endp-startp); if (endp == startp) ! { ! strcpy (nstore, "./"); ! } ! else if (endp[-1] != '/') { ! nstore[endp-startp] = '/'; nstore[endp-startp+1] = 0; } --- 2454,2461 ---- strncpy (nstore, startp, endp-startp); if (endp == startp) ! strcpy (nstore, concat (".", dir_separator_str)); ! else if (endp[-1] != '/' && endp[-1] != DIR_SEPARATOR) { ! nstore[endp-startp] = DIR_SEPARATOR; nstore[endp-startp+1] = 0; } *************** *** 2342,2346 **** else nstore[endp-startp] = 0; ! add_prefix (&startfile_prefix, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; --- 2462,2466 ---- else nstore[endp-startp] = 0; ! add_prefix (&startfile_prefixes, nstore, 0, 0, NULL_PTR); if (*endp == 0) break; *************** *** 2385,2388 **** --- 2505,2513 ---- exit (0); } + else if (! strcmp (argv[i], "-dumpmachine")) + { + printf ("%s\n", spec_machine); + exit (0); + } else if (! strcmp (argv[i], "-print-libgcc-file-name")) print_file_name = "libgcc.a"; *************** *** 2395,2446 **** else if (! strcmp (argv[i], "-print-multi-directory")) print_multi_directory = 1; - else if (! strcmp (argv[i], "-Xlinker")) - { - /* Pass the argument of this option to the linker when we link. */ - - if (i + 1 == argc) - fatal ("argument to `-Xlinker' is missing"); - - n_linker_options++; - if (!linker_options) - linker_options - = (char **) xmalloc (n_linker_options * sizeof (char **)); - else - linker_options - = (char **) xrealloc (linker_options, - n_linker_options * sizeof (char **)); - - linker_options[n_linker_options - 1] = argv[++i]; - } - else if (! strncmp (argv[i], "-Wl,", 4)) - { - int prev, j; - /* Pass the rest of this option to the linker when we link. */ - - n_linker_options++; - if (!linker_options) - linker_options - = (char **) xmalloc (n_linker_options * sizeof (char **)); - else - linker_options - = (char **) xrealloc (linker_options, - n_linker_options * sizeof (char **)); - - /* Split the argument at commas. */ - prev = 4; - for (j = 4; argv[i][j]; j++) - if (argv[i][j] == ',') - { - linker_options[n_linker_options - 1] - = save_string (argv[i] + prev, j - prev); - n_linker_options++; - linker_options - = (char **) xrealloc (linker_options, - n_linker_options * sizeof (char **)); - prev = j + 1; - } - /* Record the part after the last comma. */ - linker_options[n_linker_options - 1] = argv[i] + prev; - } else if (! strncmp (argv[i], "-Wa,", 4)) { --- 2520,2523 ---- *************** *** 2473,2480 **** assembler_options[n_assembler_options - 1] = argv[i] + prev; } else if (argv[i][0] == '+' && argv[i][1] == 'e') /* The +e options to the C++ front-end. */ n_switches++; ! else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l') { register char *p = &argv[i][1]; --- 2550,2604 ---- assembler_options[n_assembler_options - 1] = argv[i] + prev; } + else if (! strncmp (argv[i], "-Wp,", 4)) + { + int prev, j; + /* Pass the rest of this option to the preprocessor. */ + + n_preprocessor_options++; + if (!preprocessor_options) + preprocessor_options + = (char **) xmalloc (n_preprocessor_options * sizeof (char **)); + else + preprocessor_options + = (char **) xrealloc (preprocessor_options, + n_preprocessor_options * sizeof (char **)); + + /* Split the argument at commas. */ + prev = 4; + for (j = 4; argv[i][j]; j++) + if (argv[i][j] == ',') + { + preprocessor_options[n_preprocessor_options - 1] + = save_string (argv[i] + prev, j - prev); + n_preprocessor_options++; + preprocessor_options + = (char **) xrealloc (preprocessor_options, + n_preprocessor_options * sizeof (char **)); + prev = j + 1; + } + /* Record the part after the last comma. */ + preprocessor_options[n_preprocessor_options - 1] = argv[i] + prev; + } else if (argv[i][0] == '+' && argv[i][1] == 'e') /* The +e options to the C++ front-end. */ n_switches++; ! else if (strncmp (argv[i], "-Wl,", 4) == 0) ! { ! int j; ! /* Split the argument at commas. */ ! for (j = 3; argv[i][j]; j++) ! n_infiles += (argv[i][j] == ','); ! } ! else if (strcmp (argv[i], "-Xlinker") == 0) ! { ! if (i + 1 == argc) ! fatal ("argument to `-Xlinker' is missing"); ! ! n_infiles++; ! i++; ! } ! else if (strncmp (argv[i], "-l", 2) == 0) ! n_infiles++; ! else if (argv[i][0] == '-' && argv[i][1] != 0) { register char *p = &argv[i][1]; *************** *** 2502,2520 **** else value = p + 1; ! add_prefix (&exec_prefix, value, 1, 0, temp); ! add_prefix (&startfile_prefix, value, 1, 0, temp); ! add_prefix (&include_prefix, concat (value, "include", ""), 1, 0, 0); /* As a kludge, if the arg is "[foo/]stageN/", just add ! "[foo/]stageN/../include" to the include prefix. */ { int len = strlen (value); ! if ((len == 7 || (len > 7 && value[len - 8] == '/')) && strncmp (value + len - 7, "stage", 5) == 0 && isdigit (value[len - 2]) ! && value[len - 1] == '/') ! add_prefix (&include_prefix, ! concat (value, "../include", ""), 1, 0, 0); } } --- 2626,2657 ---- else value = p + 1; ! add_prefix (&exec_prefixes, value, 1, 0, temp); ! add_prefix (&startfile_prefixes, value, 1, 0, temp); ! add_prefix (&include_prefixes, concat (value, "include"), 1, 0, 0); /* As a kludge, if the arg is "[foo/]stageN/", just add ! "[foo/]include" to the include prefix. */ { int len = strlen (value); ! if ((len == 7 ! || (len > 7 ! && (value[len - 8] == '/' ! || value[len - 8] == DIR_SEPARATOR))) && strncmp (value + len - 7, "stage", 5) == 0 && isdigit (value[len - 2]) ! && (value[len - 1] == '/' ! || value[len - 1] == DIR_SEPARATOR)) ! { ! if (len == 7) ! add_prefix (&include_prefixes, "include", 1, 0, 0); ! else ! { ! char *string = xmalloc (len + 1); ! strncpy (string, value, len-7); ! strcat (string, "include"); ! add_prefix (&include_prefixes, string, 1, 0, 0); ! } ! } } } *************** *** 2566,2578 **** /* Use 2 as fourth arg meaning try just the machine as a suffix, as well as trying the machine and the version. */ ! add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR); ! add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR); ! add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR); ! add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR); ! tooldir_prefix = concat (tooldir_base_prefix, spec_machine, "/"); ! /* If tooldir is relative, base it on exec_prefix. A relative tooldir lets us move the installed tree as a unit. --- 2703,2718 ---- /* Use 2 as fourth arg meaning try just the machine as a suffix, as well as trying the machine and the version. */ ! #ifndef OS2 ! add_prefix (&exec_prefixes, standard_exec_prefix, 0, 2, NULL_PTR); ! add_prefix (&exec_prefixes, standard_exec_prefix_1, 0, 2, NULL_PTR); ! #endif ! add_prefix (&startfile_prefixes, standard_exec_prefix, 0, 1, NULL_PTR); ! add_prefix (&startfile_prefixes, standard_exec_prefix_1, 0, 1, NULL_PTR); ! tooldir_prefix = concat3 (tooldir_base_prefix, spec_machine, ! dir_separator_str); ! /* If tooldir is relative, base it on exec_prefixes. A relative tooldir lets us move the installed tree as a unit. *************** *** 2581,2585 **** and the standard place. */ ! if (*tooldir_prefix != '/') { if (gcc_exec_prefix) --- 2721,2725 ---- and the standard place. */ ! if (*tooldir_prefix != '/' && *tooldir_prefix != DIR_SEPARATOR) { if (gcc_exec_prefix) *************** *** 2586,2607 **** { char *gcc_exec_tooldir_prefix ! = concat (concat (gcc_exec_prefix, spec_machine, "/"), ! concat (spec_version, "/", tooldir_prefix), ! ""); ! add_prefix (&exec_prefix, concat (gcc_exec_tooldir_prefix, "bin", "/"), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, concat (gcc_exec_tooldir_prefix, "lib", "/"), 0, 0, NULL_PTR); } ! tooldir_prefix = concat (concat (standard_exec_prefix, spec_machine, "/"), ! concat (spec_version, "/", tooldir_prefix), ! ""); } ! add_prefix (&exec_prefix, concat (tooldir_prefix, "bin", "/"), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, concat (tooldir_prefix, "lib", "/"), 0, 0, NULL_PTR); --- 2726,2752 ---- { char *gcc_exec_tooldir_prefix ! = concat6 (gcc_exec_prefix, spec_machine, dir_separator_str, ! spec_version, dir_separator_str, tooldir_prefix); ! add_prefix (&exec_prefixes, ! concat3 (gcc_exec_tooldir_prefix, "bin", ! dir_separator_str), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, ! concat3 (gcc_exec_tooldir_prefix, "lib", ! dir_separator_str), 0, 0, NULL_PTR); } ! tooldir_prefix = concat6 (standard_exec_prefix, spec_machine, ! dir_separator_str, spec_version, ! dir_separator_str, tooldir_prefix); } ! add_prefix (&exec_prefixes, ! concat3 (tooldir_prefix, "bin", dir_separator_str), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, ! concat3 (tooldir_prefix, "lib", dir_separator_str), 0, 0, NULL_PTR); *************** *** 2626,2634 **** { /* Just skip the switches that were handled by the preceding loop. */ ! if (!strcmp (argv[i], "-Xlinker")) ! i++; ! else if (! strncmp (argv[i], "-Wl,", 4)) ; ! else if (! strncmp (argv[i], "-Wa,", 4)) ; else if (! strcmp (argv[i], "-print-libgcc-file-name")) --- 2771,2777 ---- { /* Just skip the switches that were handled by the preceding loop. */ ! if (! strncmp (argv[i], "-Wa,", 4)) ; ! else if (! strncmp (argv[i], "-Wp,", 4)) ; else if (! strcmp (argv[i], "-print-libgcc-file-name")) *************** *** 2655,2659 **** n_switches++; } ! else if (argv[i][0] == '-' && argv[i][1] != 0 && argv[i][1] != 'l') { register char *p = &argv[i][1]; --- 2798,2829 ---- n_switches++; } ! else if (strncmp (argv[i], "-Wl,", 4) == 0) ! { ! int prev, j; ! /* Split the argument at commas. */ ! prev = 4; ! for (j = 4; argv[i][j]; j++) ! if (argv[i][j] == ',') ! { ! infiles[n_infiles].language = spec_lang; ! infiles[n_infiles++].name ! = save_string (argv[i] + prev, j - prev); ! prev = j + 1; ! } ! /* Record the part after the last comma. */ ! infiles[n_infiles].language = spec_lang; ! infiles[n_infiles++].name = argv[i] + prev; ! } ! else if (strcmp (argv[i], "-Xlinker") == 0) ! { ! infiles[n_infiles].language = spec_lang; ! infiles[n_infiles++].name = argv[++i]; ! } ! else if (strncmp (argv[i], "-l", 2) == 0) ! { ! infiles[n_infiles].language = spec_lang; ! infiles[n_infiles++].name = argv[i]; ! } ! else if (argv[i][0] == '-' && argv[i][1] != 0) { register char *p = &argv[i][1]; *************** *** 2728,2734 **** else { ! if ((argv[i][0] != '-' || argv[i][1] != 'l') ! && strcmp (argv[i], "-") ! && access (argv[i], R_OK) < 0) { perror_with_name (argv[i]); --- 2898,2902 ---- else { ! if (strcmp (argv[i], "-") != 0 && access (argv[i], R_OK) < 0) { perror_with_name (argv[i]); *************** *** 2756,2762 **** strcpy (temp, gcc_exec_prefix); strcat (temp, spec_machine); ! strcat (temp, "/"); strcat (temp, spec_version); ! strcat (temp, "/"); gcc_exec_prefix = temp; } --- 2924,2930 ---- strcpy (temp, gcc_exec_prefix); strcat (temp, spec_machine); ! strcat (temp, dir_separator_str); strcat (temp, spec_version); ! strcat (temp, dir_separator_str); gcc_exec_prefix = temp; } *************** *** 2970,2974 **** case 'D': { ! struct prefix_list *pl = startfile_prefix.plist; int bufsize = 100; char *buffer = (char *) xmalloc (bufsize); --- 3138,3142 ---- case 'D': { ! struct prefix_list *pl = startfile_prefixes.plist; int bufsize = 100; char *buffer = (char *) xmalloc (bufsize); *************** *** 2983,2987 **** and it is better not to use them for searching at run time. In particular, stage1 loses */ ! if (pl->prefix[0] != '/') continue; #endif --- 3151,3155 ---- and it is better not to use them for searching at run time. In particular, stage1 loses */ ! if (pl->prefix[0] != '/' && pl->prefix[0] != DIR_SEPARATOR) continue; #endif *************** *** 3040,3044 **** strcpy (buffer, machine_suffix); idx = strlen (buffer); ! if (buffer[idx - 1] == '/') buffer[idx - 1] = 0; do_spec_1 (buffer, 1, NULL_PTR); --- 3208,3213 ---- strcpy (buffer, machine_suffix); idx = strlen (buffer); ! if (buffer[idx - 1] == '/' ! || buffer[idx - 1] == DIR_SEPARATOR) buffer[idx - 1] = 0; do_spec_1 (buffer, 1, NULL_PTR); *************** *** 3061,3065 **** strcpy (buffer, pl->prefix); idx = strlen (buffer); ! if (buffer[idx - 1] == '/') buffer[idx - 1] = 0; do_spec_1 (buffer, 1, NULL_PTR); --- 3230,3235 ---- strcpy (buffer, pl->prefix); idx = strlen (buffer); ! if (buffer[idx - 1] == '/' ! || buffer[idx - 1] == DIR_SEPARATOR) buffer[idx - 1] = 0; do_spec_1 (buffer, 1, NULL_PTR); *************** *** 3159,3163 **** case 'I': { ! struct prefix_list *pl = include_prefix.plist; if (gcc_exec_prefix) --- 3329,3333 ---- case 'I': { ! struct prefix_list *pl = include_prefixes.plist; if (gcc_exec_prefix) *************** *** 3248,3253 **** break; ! /* Dump out the options accumulated previously using %x, ! -Xlinker and -Wl,. */ case 'X': for (i = 0; i < n_linker_options; i++) --- 3418,3422 ---- break; ! /* Dump out the options accumulated previously using %x. */ case 'X': for (i = 0; i < n_linker_options; i++) *************** *** 3269,3272 **** --- 3438,3451 ---- break; + /* Dump out the options accumulated previously using -Wp,. */ + case 'Z': + for (i = 0; i < n_preprocessor_options; i++) + { + do_spec_1 (preprocessor_options[i], 1, NULL_PTR); + /* Make each accumulated option a separate argument. */ + do_spec_1 (" ", 0, NULL_PTR); + } + break; + /* Here are digits and numbers that just process a certain constant string as a spec. */ *************** *** 3929,3936 **** try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2); strcpy (try, multilib_dir); ! strcat (try, "/"); strcat (try, name); ! newname = find_a_file (&startfile_prefix, try, R_OK); /* If we don't find it in the multi library dir, then fall --- 4108,4115 ---- try = (char *) alloca (strlen (multilib_dir) + strlen (name) + 2); strcpy (try, multilib_dir); ! strcat (try, dir_separator_str); strcat (try, name); ! newname = find_a_file (&startfile_prefixes, try, R_OK); /* If we don't find it in the multi library dir, then fall *************** *** 3940,3944 **** } ! newname = find_a_file (&startfile_prefix, name, R_OK); return newname ? newname : name; } --- 4119,4123 ---- } ! newname = find_a_file (&startfile_prefixes, name, R_OK); return newname ? newname : name; } *************** *** 3972,3977 **** bcopy (path2, path + len1, len2); cp = path + len1 + len2; ! if (cp[-1] != '/') ! *cp++ = '/'; *cp++ = '.'; *cp = '\0'; --- 4151,4156 ---- bcopy (path2, path + len1, len2); cp = path + len1 + len2; ! if (cp[-1] != '/' && cp[-1] != DIR_SEPARATOR) ! *cp++ = DIR_SEPARATOR; *cp++ = '.'; *cp = '\0'; *************** *** 3979,3984 **** /* Exclude directories that the linker is known to search. */ if (linker ! && ((cp - path == 6 && strcmp (path, "/lib/.") == 0) ! || (cp - path == 10 && strcmp (path, "/usr/lib/.") == 0))) return 0; --- 4158,4168 ---- /* Exclude directories that the linker is known to search. */ if (linker ! && ((cp - path == 6 ! && strcmp (path, concat4 (dir_separator_str, "lib", ! dir_separator_str, ".")) == 0) ! || (cp - path == 10 ! && strcmp (path, concat6 (dir_separator_str, "usr", ! dir_separator_str, "lib", ! dir_separator_str, ".")) == 0))) return 0; *************** *** 4014,4018 **** p = argv[0] + strlen (argv[0]); ! while (p != argv[0] && p[-1] != '/') --p; programname = p; --- 4198,4202 ---- p = argv[0] + strlen (argv[0]); ! while (p != argv[0] && p[-1] != '/' && p[-1] != DIR_SEPARATOR) --p; programname = p; *************** *** 4063,4070 **** /* Read specs from a file if there is one. */ ! machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", "")); ! just_machine_suffix = concat (spec_machine, "/", ""); ! specs_file = find_a_file (&startfile_prefix, "specs", R_OK); /* Read the specs file unless it is a default one. */ if (specs_file != 0 && strcmp (specs_file, "specs")) --- 4247,4255 ---- /* Read specs from a file if there is one. */ ! machine_suffix = concat4 (spec_machine, dir_separator_str, ! spec_version, dir_separator_str); ! just_machine_suffix = concat (spec_machine, dir_separator_str); ! specs_file = find_a_file (&startfile_prefixes, "specs", R_OK); /* Read the specs file unless it is a default one. */ if (specs_file != 0 && strcmp (specs_file, "specs")) *************** *** 4078,4091 **** { #ifdef MD_EXEC_PREFIX ! add_prefix (&exec_prefix, md_exec_prefix, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, md_exec_prefix, 0, 0, NULL_PTR); #endif #ifdef MD_STARTFILE_PREFIX ! add_prefix (&startfile_prefix, md_startfile_prefix, 0, 0, NULL_PTR); #endif #ifdef MD_STARTFILE_PREFIX_1 ! add_prefix (&startfile_prefix, md_startfile_prefix_1, 0, 0, NULL_PTR); #endif --- 4263,4276 ---- { #ifdef MD_EXEC_PREFIX ! add_prefix (&exec_prefixes, md_exec_prefix, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, md_exec_prefix, 0, 0, NULL_PTR); #endif #ifdef MD_STARTFILE_PREFIX ! add_prefix (&startfile_prefixes, md_startfile_prefix, 0, 0, NULL_PTR); #endif #ifdef MD_STARTFILE_PREFIX_1 ! add_prefix (&startfile_prefixes, md_startfile_prefix_1, 0, 0, NULL_PTR); #endif *************** *** 4094,4099 **** as a unit. If GCC_EXEC_PREFIX is defined, base standard_startfile_prefix on that as well. */ ! if (*standard_startfile_prefix == '/') ! add_prefix (&startfile_prefix, standard_startfile_prefix, 0, 0, NULL_PTR); else --- 4279,4285 ---- as a unit. If GCC_EXEC_PREFIX is defined, base standard_startfile_prefix on that as well. */ ! if (*standard_startfile_prefix == '/' ! || *standard_startfile_prefix == DIR_SEPARATOR) ! add_prefix (&startfile_prefixes, standard_startfile_prefix, 0, 0, NULL_PTR); else *************** *** 4100,4121 **** { if (gcc_exec_prefix) ! add_prefix (&startfile_prefix, ! concat (gcc_exec_prefix, ! standard_startfile_prefix, ! ""), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, ! concat (standard_exec_prefix, ! machine_suffix, ! standard_startfile_prefix), 0, 0, NULL_PTR); } ! add_prefix (&startfile_prefix, standard_startfile_prefix_1, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefix, standard_startfile_prefix_2, 0, 0, NULL_PTR); #if 0 /* Can cause surprises, and one can use -B./ instead. */ ! add_prefix (&startfile_prefix, "./", 0, 1, NULL_PTR); #endif } --- 4286,4305 ---- { if (gcc_exec_prefix) ! add_prefix (&startfile_prefixes, ! concat (gcc_exec_prefix, standard_startfile_prefix), 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, ! concat3 (standard_exec_prefix, ! machine_suffix, ! standard_startfile_prefix), 0, 0, NULL_PTR); } ! add_prefix (&startfile_prefixes, standard_startfile_prefix_1, 0, 0, NULL_PTR); ! add_prefix (&startfile_prefixes, standard_startfile_prefix_2, 0, 0, NULL_PTR); #if 0 /* Can cause surprises, and one can use -B./ instead. */ ! add_prefix (&startfile_prefixes, "./", 0, 1, NULL_PTR); #endif } *************** *** 4146,4150 **** if (print_prog_name) { ! char *newname = find_a_file (&exec_prefix, print_prog_name, X_OK); printf ("%s\n", (newname ? newname : print_prog_name)); exit (0); --- 4330,4334 ---- if (print_prog_name) { ! char *newname = find_a_file (&exec_prefixes, print_prog_name, X_OK); printf ("%s\n", (newname ? newname : print_prog_name)); exit (0); *************** *** 4216,4220 **** input_basename = input_filename; for (p = input_filename; *p; p++) ! if (*p == '/') input_basename = p + 1; --- 4400,4404 ---- input_basename = input_filename; for (p = input_filename; *p; p++) ! if (*p == '/' || *p == DIR_SEPARATOR) input_basename = p + 1; *************** *** 4281,4286 **** /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */ ! putenv_from_prefixes (&exec_prefix, "COMPILER_PATH="); ! putenv_from_prefixes (&startfile_prefix, "LIBRARY_PATH="); /* Build COLLECT_GCC_OPTIONS to have all of the options specified to --- 4465,4470 ---- /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables for collect. */ ! putenv_from_prefixes (&exec_prefixes, "COMPILER_PATH="); ! putenv_from_prefixes (&startfile_prefixes, "LIBRARY_PATH="); /* Build COLLECT_GCC_OPTIONS to have all of the options specified to *************** *** 4317,4322 **** /* Warn if a -B option was specified but the prefix was never used. */ ! unused_prefix_warnings (&exec_prefix); ! unused_prefix_warnings (&startfile_prefix); /* If options said don't run linker, --- 4501,4506 ---- /* Warn if a -B option was specified but the prefix was never used. */ ! unused_prefix_warnings (&exec_prefixes); ! unused_prefix_warnings (&startfile_prefixes); /* If options said don't run linker, *************** *** 4375,4380 **** --- 4559,4572 ---- (strlen (cp->suffix) < length /* See if the suffix matches the end of NAME. */ + #ifdef OS2 + && (!strcmp (cp->suffix, + name + length - strlen (cp->suffix)) + || !strpbrk (cp->suffix, "ABCDEFGHIJKLMNOPQRSTUVWXYZ") + && !strcasecmp (cp->suffix, + name + length - strlen (cp->suffix))))) + #else && !strcmp (cp->suffix, name + length - strlen (cp->suffix)))) + #endif { if (cp->spec[0][0] == '@') *************** *** 4421,4437 **** } ! /* Return a newly-allocated string whose contents concatenate those of s1, s2, s3. */ static char * ! concat (s1, s2, s3) ! char *s1, *s2, *s3; { ! int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3); ! char *result = xmalloc (len1 + len2 + len3 + 1); strcpy (result, s1); strcpy (result + len1, s2); ! strcpy (result + len1 + len2, s3); ! *(result + len1 + len2 + len3) = 0; return result; --- 4613,4629 ---- } ! /* Return a newly-allocated string whose contents concatenate those of s1, s2 */ static char * ! concat (s1, s2) ! char *s1, *s2; { ! int len1 = strlen (s1); ! int len2 = strlen (s2); ! char *result = xmalloc (len1 + len2 + 1); strcpy (result, s1); strcpy (result + len1, s2); ! *(result + len1 + len2) = 0; return result; *************** *** 4439,4442 **** --- 4631,4655 ---- static char * + concat3 (s1, s2, s3) + char *s1, *s2, *s3; + { + return concat (concat (s1, s2), s3); + } + + static char * + concat4 (s1, s2, s3, s4) + char *s1, *s2, *s3, *s4; + { + return concat (concat (s1, s2), concat (s3, s4)); + } + + static char * + concat6 (s1, s2, s3, s4, s5, s6) + char *s1, *s2, *s3, *s4, *s5, *s6; + { + return concat3 (concat (s1, s2), concat (s3, s4), concat (s5, s6)); + } + + static char * save_string (s, len) char *s; *************** *** 4457,4461 **** if (errno < sys_nerr) ! s = concat ("%s: ", sys_errlist[errno], ""); else s = "cannot open %s"; --- 4670,4674 ---- if (errno < sys_nerr) ! s = concat ("%s: ", sys_errlist[errno]); else s = "cannot open %s"; *************** *** 4470,4474 **** if (errno < sys_nerr) ! s = concat ("%s: ", sys_errlist[errno], ""); else s = "cannot open %s"; --- 4683,4687 ---- if (errno < sys_nerr) ! s = concat ("%s: ", sys_errlist[errno]); else s = "cannot open %s"; *************** *** 4483,4488 **** if (errno < sys_nerr) ! s = concat ("installation problem, cannot exec %s: ", ! sys_errlist[errno], ""); else s = "installation problem, cannot exec %s"; --- 4696,4700 ---- if (errno < sys_nerr) ! s = concat ("installation problem, cannot exec %s: ", sys_errlist[errno]); else s = "installation problem, cannot exec %s"; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/gcc.texi gcc-2.6.1/gcc.texi *** gcc-2.6.0/gcc.texi Thu Jul 14 22:05:42 1994 --- gcc-2.6.1/gcc.texi Sun Oct 30 04:47:55 1994 *************** *** 96,100 **** Cambridge, MA 02139 USA ! Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of --- 96,100 ---- Cambridge, MA 02139 USA ! Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. Permission is granted to make and distribute verbatim copies of *************** *** 111,126 **** Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the ! sections entitled ``GNU General Public License'' and ``Protect Your ! Freedom---Fight `Look And Feel'@w{}'' are included exactly as in the ! original, and provided that the entire resulting derived work is ! distributed under the terms of a permission notice identical to this ! one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, ! except that the sections entitled ``GNU General Public License'' and ! ``Protect Your Freedom---Fight `Look And Feel'@w{}'', and this permission ! notice, may be included in translations approved by the Free Software ! Foundation instead of in the original English. @end ifinfo --- 111,127 ---- Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the ! sections entitled ``GNU General Public License,'' ``Funding for Free ! Software,'' and ``Protect Your Freedom---Fight `Look And Feel'@w{}'' are ! included exactly as in the original, and provided that the entire ! resulting derived work is distributed under the terms of a permission ! notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, ! except that the sections entitled ``GNU General Public License,'' ! ``Funding for Free Software,'' and ``Protect Your Freedom---Fight `Look ! And Feel'@w{}'', and this permission notice, may be included in ! translations approved by the Free Software Foundation instead of in the ! original English. @end ifinfo *************** *** 143,147 **** @center Richard M. Stallman @sp 3 ! @center Last updated 11 July 1994 @sp 1 @c The version number appears twice more in this file. --- 144,148 ---- @center Richard M. Stallman @sp 3 ! @center Last updated 19 September 1994 @sp 1 @c The version number appears twice more in this file. *************** *** 168,183 **** Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the ! sections entitled ``GNU General Public License'' and ``Protect Your ! Freedom---Fight `Look And Feel'@w{}'' are included exactly as in the ! original, and provided that the entire resulting derived work is ! distributed under the terms of a permission notice identical to this ! one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, ! except that the sections entitled ``GNU General Public License'' and ! ``Protect Your Freedom---Fight `Look And Feel'@w{}'', and this ! permission notice, may be included in translations approved by the Free ! Software Foundation instead of in the original English. @end titlepage @page --- 169,185 ---- Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the ! sections entitled ``GNU General Public License,'' ``Funding for Free ! Software,'' and ``Protect Your Freedom---Fight `Look And Feel'@w{}'' are ! included exactly as in the original, and provided that the entire ! resulting derived work is distributed under the terms of a permission ! notice identical to this one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions, ! except that the sections entitled ``GNU General Public License,'' ! ``Funding for Free Software,'' and ``Protect Your Freedom---Fight `Look ! And Feel'@w{}'', and this permission notice, may be included in ! translations approved by the Free Software Foundation instead of in the ! original English. @end titlepage @page *************** *** 213,216 **** --- 215,219 ---- how you can copy and share GNU CC. * Contributors:: People who have contributed to GNU CC. + * Funding:: How to help assure funding for free software. * Look and Feel:: Protect your freedom---fight ``look and feel''. @ifset USING *************** *** 238,242 **** @end menu ! @node Copying, Contributors, Top, Top @unnumbered GNU GENERAL PUBLIC LICENSE @center Version 2, June 1991 --- 241,245 ---- @end menu ! @node Copying @unnumbered GNU GENERAL PUBLIC LICENSE @center Version 2, June 1991 *************** *** 630,634 **** Public License instead of this License. ! @node Contributors, Look and Feel, Copying, Top @unnumbered Contributors to GNU CC @cindex contributors --- 633,637 ---- Public License instead of this License. ! @node Contributors @unnumbered Contributors to GNU CC @cindex contributors *************** *** 755,759 **** @item Mike Meissner at the Open Software Foundation finished the port to the ! MIPS cpu, including adding ECOFF debug support. @item --- 758,763 ---- @item Mike Meissner at the Open Software Foundation finished the port to the ! MIPS cpu, including adding ECOFF debug support, and worked on the ! Intel port for the Intel 80386 cpu. @item *************** *** 809,812 **** --- 813,865 ---- @end itemize + @node Funding + @chapter Funding Free Software + + If you want to have more free software a few years from now, it makes + sense for you to help encourage people to contribute funds for its + development. The most effective approach known is to encourage + commercial redistributors to donate. + + Users of free software systems can boost the pace of development by + encouraging for-a-fee distributors to donate part of their selling price + to free software developers---the Free Software Foundation, and others. + + The way to convince distributors to do this is to demand it and expect + it from them. So when you compare distributors, judge them partly by + how much they give to free software development. Show distributors + they must compete to be the one who gives the most. + + To make this approach work, you must insist on numbers that you can + compare, such as, ``We will donate ten dollars to the Frobnitz project + for each disk sold.'' Don't be satisfied with a vague promise, such as + ``A portion of the profits are donated,'' since it doesn't give a basis + for comparison. + + Even a precise fraction ``of the profits from this disk'' is not very + meaningful, since creative accounting and unrelated business decisions + can greatly alter what fraction of the sales price counts as profit. + If the price you pay is $50, ten percent of the profit is probably + less than a dollar; it might be a few cents, or nothing at all. + + Some redistributors do development work themselves. This is useful too; + but to keep everyone honest, you need to inquire how much they do, and + what kind. Some kinds of development make much more long-term + difference than others. For example, maintaining a separate version of + a program contributes very little; maintaining the standard version of a + program for the whole community contributes much. Easy new ports + contribute little, since someone else would surely do them; difficult + ports such as adding a new CPU to the GNU C compiler contribute more; + major new features or packages contribute the most. + + By establishing the idea that supporting further development is ``the + proper thing to do'' when distributing free software for a fee, we can + assure a steady flow of resources into making more free software. + + @display + Copyright (C) 1994 Free Software Foundation, Inc. + Verbatim copying and redistribution of this section is permitted + without royalty; alteration is not permitted. + @end display + @node Look and Feel @chapter Protect Your Freedom---Fight ``Look And Feel'' *************** *** 880,886 **** @item Open Computing magazine reported a Microsoft vice president as threatening ! to sue people who copy the interface of Windows. It should be no surprise ! that the largest software company plans to take advantage of a policy that ! generally favors the large against the small. @end itemize --- 933,937 ---- @item Open Computing magazine reported a Microsoft vice president as threatening ! to sue people who copy the interface of Windows. @end itemize *************** *** 907,911 **** The League's membership rolls include John McCarthy, inventor of Lisp, ! Marvin Minsky, founder of the Artificial Intelligence lab, Guy L. Steele, Jr., author of well-known books on Lisp and C, as well as Richard Stallman, the developer of GNU CC. Please join and add your --- 958,962 ---- The League's membership rolls include John McCarthy, inventor of Lisp, ! Marvin Minsky, founder of the MIT Artificial Intelligence lab, Guy L. Steele, Jr., author of well-known books on Lisp and C, as well as Richard Stallman, the developer of GNU CC. Please join and add your *************** *** 1085,1093 **** @item Loop unrolling doesn't work properly for certain C++ programs. This is ! because of difficulty in updating the debugging information within the ! loop being unrolled. We plan to revamp the representation of debugging ! information so that this will work properly, but we have not done this ! in version 2.6 because we don't want to delay it any further. @end itemize --- 1136,1151 ---- @item + There are several obscure case of mis-using struct, union, and + enum tags that are not detected as errors by the compiler. + + @item + When @samp{-pedantic-errors} is specified, GNU C will incorrectly give + an error message when a function name is specified in an expression + involving the comma operator. + + @item Loop unrolling doesn't work properly for certain C++ programs. This is ! a bug in the C++ front end. It sometimes emits incorrect debug info, and ! the loop unrolling code is unable to recover from this error. @end itemize *************** *** 1386,1390 **** @end quotation ! This patch is also known as PHCO_0800. @item --- 1444,1448 ---- @end quotation ! This patch is also known as PHCO_4484. @item *************** *** 2722,2736 **** @item ! Using the ``canonical'' form of the target configuration name as the ! directory for installation. ! ! This would be an improvement in some respects, but it would also cause ! problems. For one thing, users might expect to use in the @samp{-b} ! option the same name specified at installation; if installation used the ! canonical form, that would not work. What's more, the canonical name ! might be too long for certain file systems. ! We suggest you make a link to the installation directory under the ! canonical name, if you want to use that name in the @samp{-b} option. @end itemize --- 2780,2789 ---- @item ! Not allowing structures with volatile fields in registers. ! Strictly speaking, there is no prohibition in the ANSI C standard ! against allowing structures with volatile fields in registers, but ! it does not seem to make any sense and is probably not what you wanted ! to do. So the compiler will give an error message in this case. @end itemize *************** *** 2881,2902 **** @section Where to Report Bugs @cindex bug report mailing lists - @kindex bug-gcc@@prep.ai.mit.edu ! Send bug reports for GNU C to one of these addresses: ! ! @example ! bug-gcc@@prep.ai.mit.edu ! @{ucbvax|mit-eddie|uunet@}!prep.ai.mit.edu!bug-gcc ! @end example @kindex bug-g++@@prep.ai.mit.edu - Send bug reports for GNU C++ to one of these addresses: - - @example - bug-g++@@prep.ai.mit.edu - @{ucbvax|mit-eddie|uunet@}!prep.ai.mit.edu!bug-g++ - @end example - @kindex bug-libg++@@prep.ai.mit.edu If your bug involves the C++ class library libg++, send mail to @samp{bug-lib-g++@@prep.ai.mit.edu}. If you're not sure, you can send --- 2934,2943 ---- @section Where to Report Bugs @cindex bug report mailing lists @kindex bug-gcc@@prep.ai.mit.edu ! Send bug reports for GNU C to @samp{bug-gcc@@prep.ai.mit.edu}. @kindex bug-g++@@prep.ai.mit.edu @kindex bug-libg++@@prep.ai.mit.edu + Send bug reports for GNU C++ to @samp{bug-g++@@prep.ai.mit.edu}. If your bug involves the C++ class library libg++, send mail to @samp{bug-lib-g++@@prep.ai.mit.edu}. If you're not sure, you can send *************** *** 2903,2907 **** the bug report to both lists. ! @strong{Do not send bug reports to the mailing list @samp{help-gcc}, or to the newsgroup @samp{gnu.gcc.help}.} Most users of GNU CC do not want to receive bug reports. Those that do, have asked to be on --- 2944,2948 ---- the bug report to both lists. ! @strong{Do not send bug reports to @samp{help-gcc@@prep.ai.mit.edu} or to the newsgroup @samp{gnu.gcc.help}.} Most users of GNU CC do not want to receive bug reports. Those that do, have asked to be on *************** *** 2960,2963 **** --- 3001,3008 ---- in your response, as well as the information that was missing. + Please report each bug in a separate message. This makes it easier for + us to track which bugs have been fixed and to forward your bugs reports + to the appropriate maintainer. + To enable someone to investigate the bug, you should include all these things: *************** *** 4444,4447 **** --- 4489,4506 ---- @file{stab.h}. If @samp{USG} is defined, @samp{NO_STAB_H} is assumed. + + @findex PATH_SEPARATOR + @item PATH_SEPARATOR + Define this macro to be a C character constant representing the + character used to separate components in paths. The default value is. + the colon character + + @findex DIR_SEPARATOR + @item DIR_SEPARATOR + If your system uses some character other than slash to separate + directory names within a file specification, define this macro to be a C + character constant specifying that character. When GNU CC displays file + names, the character you specify will be used. GNU CC will test for + both slash and the character you specify when parsing filenames. @end table diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/genattr.c gcc-2.6.1/genattr.c *** gcc-2.6.0/genattr.c Fri Mar 25 14:09:18 1994 --- gcc-2.6.1/genattr.c Fri Sep 30 17:23:46 1994 *************** *** 32,36 **** extern void free PROTO((void *)); - extern int atoi PROTO((char *)); extern rtx read_rtx PROTO((FILE *)); --- 32,35 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/genattrtab.c gcc-2.6.1/genattrtab.c *** gcc-2.6.0/genattrtab.c Tue Jun 14 18:04:44 1994 --- gcc-2.6.1/genattrtab.c Thu Oct 13 10:44:20 1994 *************** *** 311,314 **** --- 311,315 ---- static int have_annul_true, have_annul_false; static int num_units; + static int num_insn_ents; /* Used as operand to `operate_exp': */ *************** *** 2546,2549 **** --- 2547,2552 ---- if (ie->insn_code == -1) av->has_asm_insn = 0; + + num_insn_ents--; } *************** *** 2560,2563 **** --- 2563,2568 ---- if (ie->insn_code == -1) av->has_asm_insn = 1; + + num_insn_ents++; } *************** *** 3294,3297 **** --- 3299,3303 ---- struct attr_value_list *next; }; struct attr_value_list **insn_code_values; + struct attr_value_list *ivbuf; struct attr_value_list *iv; *************** *** 3299,3302 **** --- 3305,3311 ---- for all values for all attributes. */ + if (num_insn_ents == 0) + return; + /* Make 2 extra elements, for "code" values -2 and -1. */ insn_code_values *************** *** 3309,3312 **** --- 3318,3327 ---- insn_code_values += 2; + /* Allocate the attr_value_list structures using xmalloc rather than + alloca, because using alloca can overflow the maximum permitted + stack limit on SPARC Lynx. */ + iv = ivbuf = ((struct attr_value_list *) + xmalloc (num_insn_ents * sizeof (struct attr_value_list))); + for (i = 0; i < MAX_ATTRS_INDEX; i++) for (attr = attrs[i]; attr; attr = attr->next) *************** *** 3314,3319 **** for (ie = av->first_insn; ie; ie = ie->next) { - iv = ((struct attr_value_list *) - alloca (sizeof (struct attr_value_list))); iv->attr = attr; iv->av = av; --- 3329,3332 ---- *************** *** 3321,3326 **** --- 3334,3344 ---- iv->next = insn_code_values[ie->insn_code]; insn_code_values[ie->insn_code] = iv; + iv++; } + /* Sanity check on num_insn_ents. */ + if (iv != ivbuf + num_insn_ents) + abort (); + /* Process one insn code at a time. */ for (i = -2; i < insn_code_number; i++) *************** *** 3372,3375 **** --- 3390,3395 ---- } } + + free (ivbuf); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/genextract.c gcc-2.6.1/genextract.c *** gcc-2.6.0/genextract.c Mon Sep 6 14:42:25 1993 --- gcc-2.6.1/genextract.c Thu Sep 1 22:13:37 1994 *************** *** 448,453 **** printf ("extern rtx *recog_dup_loc[];\n"); printf ("extern char recog_dup_num[];\n"); - printf ("extern\n#ifdef __GNUC__\n__volatile__\n#endif\n"); - printf ("void fatal_insn_not_found ();\n\n"); printf ("void\ninsn_extract (insn)\n"); --- 448,451 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/genoutput.c gcc-2.6.1/genoutput.c *** gcc-2.6.0/genoutput.c Sat Mar 19 08:35:31 1994 --- gcc-2.6.1/genoutput.c Tue Sep 27 18:27:28 1994 *************** *** 990,994 **** static int n_occurrences (c, s) ! char c; char *s; { --- 990,994 ---- static int n_occurrences (c, s) ! int c; char *s; { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/getopt.c gcc-2.6.1/getopt.c *** gcc-2.6.0/getopt.c Thu Jul 14 22:17:42 1994 --- gcc-2.6.1/getopt.c Tue Nov 1 21:35:37 1994 *************** *** 28,42 **** #ifdef HAVE_CONFIG_H - #if defined (emacs) || defined (CONFIG_BROKETS) - /* We use instead of "config.h" so that a compilation - using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h - (which it would do because it found this file in $srcdir). */ #include - #else - #include "config.h" - #endif #endif ! #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ --- 28,35 ---- #ifdef HAVE_CONFIG_H #include #endif ! #if !defined (__STDC__) || !__STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ *************** *** 196,200 **** /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. That was relevant to code that was here before. */ ! #ifndef __STDC__ /* gcc with -traditional declares the built-in strlen to return int, and has done so at least since version 2.4.5. -- rms. */ --- 189,193 ---- /* Note that Motorola Delta 68k R3V7 comes with GCC but not stddef.h. That was relevant to code that was here before. */ ! #if !defined (__STDC__) || !__STDC__ /* gcc with -traditional declares the built-in strlen to return int, and has done so at least since version 2.4.5. -- rms. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/getopt.h gcc-2.6.1/getopt.h *** gcc-2.6.0/getopt.h Thu Jul 14 22:17:42 1994 --- gcc-2.6.1/getopt.h Tue Nov 1 21:35:38 1994 *************** *** 1,4 **** /* Declarations for getopt. ! Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it --- 1,4 ---- /* Declarations for getopt. ! Copyright (C) 1989, 90, 91, 92, 93, 94 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it *************** *** 77,81 **** struct option { ! #if __STDC__ const char *name; #else --- 77,81 ---- struct option { ! #if defined (__STDC__) && __STDC__ const char *name; #else *************** *** 95,100 **** #define optional_argument 2 ! #if __STDC__ ! #if defined(__GNU_LIBRARY__) /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation --- 95,100 ---- #define optional_argument 2 ! #if defined (__STDC__) && __STDC__ ! #ifdef __GNU_LIBRARY__ /* Many other libraries have conflicting prototypes for getopt, with differences in the consts, in stdlib.h. To avoid compilation *************** *** 103,107 **** #else /* not __GNU_LIBRARY__ */ extern int getopt (); ! #endif /* not __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); --- 103,107 ---- #else /* not __GNU_LIBRARY__ */ extern int getopt (); ! #endif /* __GNU_LIBRARY__ */ extern int getopt_long (int argc, char *const *argv, const char *shortopts, const struct option *longopts, int *longind); *************** *** 121,125 **** extern int _getopt_internal (); ! #endif /* not __STDC__ */ #ifdef __cplusplus --- 121,125 ---- extern int _getopt_internal (); ! #endif /* __STDC__ */ #ifdef __cplusplus diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/getopt1.c gcc-2.6.1/getopt1.c *** gcc-2.6.0/getopt1.c Thu Jul 14 22:17:43 1994 --- gcc-2.6.1/getopt1.c Tue Nov 1 21:35:39 1994 *************** *** 1,4 **** /* getopt_long and getopt_long_only entry points for GNU getopt. ! Copyright (C) 1987, 88, 89, 90, 91, 92, 1993 Free Software Foundation, Inc. --- 1,4 ---- /* getopt_long and getopt_long_only entry points for GNU getopt. ! Copyright (C) 1987, 88, 89, 90, 91, 92, 1993, 1994 Free Software Foundation, Inc. *************** *** 18,34 **** #ifdef HAVE_CONFIG_H - #if defined (emacs) || defined (CONFIG_BROKETS) - /* We use instead of "config.h" so that a compilation - using -I. -I$srcdir will use ./config.h rather than $srcdir/config.h - (which it would do because it found this file in $srcdir). */ #include - #else - #include "config.h" #endif - #endif #include "getopt.h" ! #ifndef __STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ --- 18,27 ---- #ifdef HAVE_CONFIG_H #include #endif #include "getopt.h" ! #if !defined (__STDC__) || !__STDC__ /* This is a separate conditional since some stdc systems reject `defined (const)'. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/getpwd.c gcc-2.6.1/getpwd.c *** gcc-2.6.0/getpwd.c Tue Sep 21 17:35:41 1993 --- gcc-2.6.1/getpwd.c Fri Oct 14 10:29:12 1994 *************** *** 15,23 **** the few exceptions to the general rule here. */ ! #if !(defined (POSIX) || defined (USG) || defined (VMS)) #include extern char *getwd (); #define getcwd(buf,len) getwd(buf) #define GUESSPATHLEN (MAXPATHLEN + 1) #else /* (defined (USG) || defined (VMS)) */ extern char *getcwd (); --- 15,27 ---- the few exceptions to the general rule here. */ ! #if !(defined (POSIX) || defined (USG) || defined (VMS)) || defined (HAVE_GETWD) #include extern char *getwd (); #define getcwd(buf,len) getwd(buf) + #ifdef MAXPATHLEN #define GUESSPATHLEN (MAXPATHLEN + 1) + #else + #define GUESSPATHLEN 100 + #endif #else /* (defined (USG) || defined (VMS)) */ extern char *getcwd (); *************** *** 25,28 **** --- 29,35 ---- #define GUESSPATHLEN 100 #endif /* (defined (USG) || defined (VMS)) */ + #ifdef WINNT + #include + #endif char *getenv (); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ginclude/math-68881.h gcc-2.6.1/ginclude/math-68881.h *** gcc-2.6.0/ginclude/math-68881.h Sun Jan 23 07:10:59 1994 --- gcc-2.6.1/ginclude/math-68881.h Mon Sep 5 17:23:52 1994 *************** *** 62,66 **** #endif ! __inline static const double sin (double x) { --- 62,66 ---- #endif ! __inline extern double sin (double x) { *************** *** 73,77 **** } ! __inline static const double cos (double x) { --- 73,77 ---- } ! __inline extern double cos (double x) { *************** *** 84,88 **** } ! __inline static const double tan (double x) { --- 84,88 ---- } ! __inline extern double tan (double x) { *************** *** 95,99 **** } ! __inline static const double asin (double x) { --- 95,99 ---- } ! __inline extern double asin (double x) { *************** *** 106,110 **** } ! __inline static const double acos (double x) { --- 106,110 ---- } ! __inline extern double acos (double x) { *************** *** 117,121 **** } ! __inline static const double atan (double x) { --- 117,121 ---- } ! __inline extern double atan (double x) { *************** *** 128,132 **** } ! __inline static const double atan2 (double y, double x) { --- 128,132 ---- } ! __inline extern double atan2 (double y, double x) { *************** *** 185,189 **** } ! __inline static const double sinh (double x) { --- 185,189 ---- } ! __inline extern double sinh (double x) { *************** *** 196,200 **** } ! __inline static const double cosh (double x) { --- 196,200 ---- } ! __inline extern double cosh (double x) { *************** *** 207,211 **** } ! __inline static const double tanh (double x) { --- 207,211 ---- } ! __inline extern double tanh (double x) { *************** *** 218,222 **** } ! __inline static const double atanh (double x) { --- 218,222 ---- } ! __inline extern double atanh (double x) { *************** *** 229,233 **** } ! __inline static const double exp (double x) { --- 229,233 ---- } ! __inline extern double exp (double x) { *************** *** 240,244 **** } ! __inline static const double expm1 (double x) { --- 240,244 ---- } ! __inline extern double expm1 (double x) { *************** *** 251,255 **** } ! __inline static const double log (double x) { --- 251,255 ---- } ! __inline extern double log (double x) { *************** *** 262,266 **** } ! __inline static const double log1p (double x) { --- 262,266 ---- } ! __inline extern double log1p (double x) { *************** *** 273,277 **** } ! __inline static const double log10 (double x) { --- 273,277 ---- } ! __inline extern double log10 (double x) { *************** *** 284,288 **** } ! __inline static const double sqrt (double x) { --- 284,288 ---- } ! __inline extern double sqrt (double x) { *************** *** 295,300 **** } ! __inline static const double ! hypot (const double x, const double y) { return sqrt (x*x + y*y); --- 295,300 ---- } ! __inline extern double ! hypot (double x, double y) { return sqrt (x*x + y*y); *************** *** 301,306 **** } ! __inline static const double ! pow (const double x, const double y) { if (x > 0) --- 301,306 ---- } ! __inline extern double ! pow (double x, double y) { if (x > 0) *************** *** 350,354 **** } ! __inline static const double fabs (double x) { --- 350,354 ---- } ! __inline extern double fabs (double x) { *************** *** 361,365 **** } ! __inline static const double ceil (double x) { --- 361,365 ---- } ! __inline extern double ceil (double x) { *************** *** 383,387 **** } ! __inline static const double floor (double x) { --- 383,387 ---- } ! __inline extern double floor (double x) { *************** *** 406,410 **** } ! __inline static const double rint (double x) { --- 406,410 ---- } ! __inline extern double rint (double x) { *************** *** 428,432 **** } ! __inline static const double fmod (double x, double y) { --- 428,432 ---- } ! __inline extern double fmod (double x, double y) { *************** *** 440,444 **** } ! __inline static const double drem (double x, double y) { --- 440,444 ---- } ! __inline extern double drem (double x, double y) { *************** *** 452,456 **** } ! __inline static const double scalb (double x, int n) { --- 452,456 ---- } ! __inline extern double scalb (double x, int n) { *************** *** 464,468 **** } ! __inline static double logb (double x) { --- 464,468 ---- } ! __inline extern double logb (double x) { *************** *** 475,479 **** } ! __inline static const double ldexp (double x, int n) { --- 475,479 ---- } ! __inline extern double ldexp (double x, int n) { *************** *** 487,491 **** } ! __inline static double frexp (double x, int *exp) { --- 487,491 ---- } ! __inline extern double frexp (double x, int *exp) { *************** *** 512,516 **** } ! __inline static double modf (double x, double *ip) { --- 512,516 ---- } ! __inline extern double modf (double x, double *ip) { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ginclude/stddef.h gcc-2.6.1/ginclude/stddef.h *** gcc-2.6.0/ginclude/stddef.h Mon Apr 25 14:13:23 1994 --- gcc-2.6.1/ginclude/stddef.h Fri Oct 7 19:22:35 1994 *************** *** 36,42 **** --- 36,46 ---- #define _PTRDIFF_T #endif + /* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ + instead of _WCHAR_T_. */ #ifndef _WCHAR_T_ + #ifndef _BSD_WCHAR_T_ #define _WCHAR_T #endif + #endif /* Undef _FOO_T_ if we are supposed to define foo_t. */ #if defined (__need_ptrdiff_t) || defined (_STDDEF_H_) *************** *** 110,113 **** --- 114,118 ---- #ifndef __SIZE_T #ifndef _SIZE_T_ + #ifndef _SIZE_T_DEFINED_ #ifndef ___int_size_t_h #ifndef _GCC_SIZE_T *************** *** 120,123 **** --- 125,129 ---- #define __SIZE_T #define _SIZE_T_ + #define _SIZE_T_DEFINED_ #define ___int_size_t_h #define _GCC_SIZE_T *************** *** 134,137 **** --- 140,144 ---- #endif /* _GCC_SIZE_T */ #endif /* ___int_size_t_h */ + #endif /* _SIZE_T_DEFINED_ */ #endif /* _SIZE_T_ */ #endif /* __SIZE_T */ *************** *** 157,160 **** --- 164,168 ---- #ifndef __WCHAR_T #ifndef _WCHAR_T_ + #ifndef _WCHAR_T_DEFINED_ #ifndef _WCHAR_T_H #ifndef ___int_wchar_t_h *************** *** 166,169 **** --- 174,178 ---- #define __WCHAR_T #define _WCHAR_T_ + #define _WCHAR_T_DEFINED_ #define _WCHAR_T_H #define ___int_wchar_t_h *************** *** 170,173 **** --- 179,202 ---- #define __INT_WCHAR_T_H #define _GCC_WCHAR_T + + /* On BSD/386 1.1, at least, machine/ansi.h defines _BSD_WCHAR_T_ + instead of _WCHAR_T_, and _BSD_RUNE_T_ (which, unlike the other + symbols in the _FOO_T_ family, stays defined even after its + corresponding type is defined). If we define wchar_t, then we + must undef _WCHAR_T_; for BSD/386 1.1 (and perhaps others), if + we undef _WCHAR_T_, then we must also define rune_t, since + headers like runetype.h assume that if machine/ansi.h is included, + and _BSD_WCHAR_T_ is not defined, then rune_t is available. + machine/ansi.h says, "Note that _WCHAR_T_ and _RUNE_T_ must be of + the same type." */ + #ifdef _BSD_WCHAR_T_ + #undef _BSD_WCHAR_T_ + #ifdef _BSD_RUNE_T_ + #if !defined (_ANSI_SOURCE) && !defined (_POSIX_SOURCE) + typedef _BSD_RUNE_T_ rune_t; + #endif + #endif + #endif + #ifndef __WCHAR_TYPE__ #define __WCHAR_TYPE__ int *************** *** 183,186 **** --- 212,216 ---- #endif #endif + #endif #undef __need_wchar_t #endif /* _STDDEF_H or __need_wchar_t. */ *************** *** 189,192 **** --- 219,224 ---- are already defined. */ #ifdef _ANSI_H_ + /* The references to _GCC_PTRDIFF_T_, _GCC_SIZE_T_, and _GCC_WCHAR_T_ + are probably typos and should be removed before 2.7 is released. */ #ifdef _GCC_PTRDIFF_T_ #undef _PTRDIFF_T_ *************** *** 196,199 **** --- 228,241 ---- #endif #ifdef _GCC_WCHAR_T_ + #undef _WCHAR_T_ + #endif + /* The following ones are the real ones. */ + #ifdef _GCC_PTRDIFF_T + #undef _PTRDIFF_T_ + #endif + #ifdef _GCC_SIZE_T + #undef _SIZE_T_ + #endif + #ifdef _GCC_WCHAR_T #undef _WCHAR_T_ #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ginclude/va-i960.h gcc-2.6.1/ginclude/va-i960.h *** gcc-2.6.0/ginclude/va-i960.h Wed Mar 23 17:07:21 1994 --- gcc-2.6.1/ginclude/va-i960.h Thu Oct 20 16:09:44 1994 *************** *** 40,44 **** __extension__ \ ({ __asm__ ("st g14,%0" : "=m" (*(AP))); \ ! (AP)[1] = (unsigned) __builtin_next_arg (LASTARG) - *AP; }) #else --- 40,45 ---- __extension__ \ ({ __asm__ ("st g14,%0" : "=m" (*(AP))); \ ! (AP)[1] = (__builtin_args_info (0) + __builtin_args_info (1)) * 4; }) ! #else diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ginclude/va-mips.h gcc-2.6.1/ginclude/va-mips.h *** gcc-2.6.0/ginclude/va-mips.h Wed Mar 23 17:07:30 1994 --- gcc-2.6.1/ginclude/va-mips.h Mon Oct 17 19:28:32 1994 *************** *** 39,43 **** #ifdef _STDARG_H ! #define va_start(__AP, __LASTARG) (__AP = __builtin_next_arg (__LASTARG)) #else --- 39,44 ---- #ifdef _STDARG_H ! #define va_start(__AP, __LASTARG) \ ! (__AP = (__gnuc_va_list) __builtin_next_arg (__LASTARG)) #else *************** *** 59,67 **** /* We cast to void * and then to TYPE * because this avoids a warning about increasing the alignment requirement. */ #if __mips==3 #define va_arg(__AP, __type) \ ! ((__type *) (void *) (__AP = (char *) ((((int)__AP + 8 - 1) & -8) \ ! + __va_rounded_size (__type))))[-1] #else #ifdef __MIPSEB__ /* For big-endian machines. */ --- 60,81 ---- /* We cast to void * and then to TYPE * because this avoids a warning about increasing the alignment requirement. */ + /* The __mips==3 cases are reversed from the 32 bit cases, because the standard + 32 bit calling convention left-aligns all parameters smaller than a word, + whereas the __mips==3 calling convention does not (and hence they are + right aligned). */ #if __mips==3 + #ifdef __MIPSEB__ #define va_arg(__AP, __type) \ ! ((__type *) (void *) (__AP = (char *) ((((int)__AP + 8 - 1) & -8) \ ! + __va_rounded_size (__type))))[-1] #else + #define va_arg(__AP, __type) \ + ((__AP = (char *) ((((int)__AP + 8 - 1) & -8) \ + + __va_rounded_size (__type))), \ + *(__type *) (void *) (__AP - __va_rounded_size (__type))) + #endif + + #else /* not __mips==3 */ + #ifdef __MIPSEB__ /* For big-endian machines. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/ginclude/va-sparc.h gcc-2.6.1/ginclude/va-sparc.h *** gcc-2.6.0/ginclude/va-sparc.h Wed Jun 15 03:37:23 1994 --- gcc-2.6.1/ginclude/va-sparc.h Wed Aug 3 21:32:54 1994 *************** *** 46,50 **** AP.__va_next_fp_limit = (AP.__va_next_fp + \ (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ ! AP.__va_next_stack = (__va_greg *) __builtin_next_arg(); \ }) #else --- 46,50 ---- AP.__va_next_fp_limit = (AP.__va_next_fp + \ (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ ! AP.__va_next_stack = (__va_greg *) __builtin_next_arg (LASTARG); \ }) #else *************** *** 75,79 **** AP.__va_next_fp_limit = (AP.__va_next_fp + \ (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ ! AP.__va_next_stack = (__va_greg *) __builtin_next_arg(); \ }) #else --- 75,79 ---- AP.__va_next_fp_limit = (AP.__va_next_fp + \ (__builtin_args_info (1) < 16 ? (16 - __builtin_args_info (1) + 1) / 2 : 0)); \ ! AP.__va_next_stack = (__va_greg *) __builtin_next_arg (__builtin_va_alist); \ }) #else *************** *** 138,142 **** { \ __va_freg *__r; \ ! /* see PASS_IN_REG_P in sparc.h */ \ if (pvar.__va_next_fp < pvar.__va_next_fp_limit \ && ((__r = (__va_freg *) (((__va_greg) pvar.__va_next_fp + sizeof (TYPE) - 1) & ~(__va_greg) (sizeof (TYPE) - 1))) \ --- 138,142 ---- { \ __va_freg *__r; \ ! /* see PASS_IN_REG_P in gcc's sparc.h */ \ if (pvar.__va_next_fp < pvar.__va_next_fp_limit \ && ((__r = (__va_freg *) (((__va_greg) pvar.__va_next_fp + sizeof (TYPE) - 1) & ~(__va_greg) (sizeof (TYPE) - 1))) \ *************** *** 143,147 **** < pvar.__va_next_fp_limit)) \ { \ ! pvar.__va_next_fp = __r + sizeof (TYPE) / 8; \ } \ else \ --- 143,147 ---- < pvar.__va_next_fp_limit)) \ { \ ! pvar.__va_next_fp = __r + (sizeof (TYPE) + 7) / 8; \ } \ else \ *************** *** 148,152 **** { \ __r = (__va_freg *) pvar.__va_next_stack; \ ! pvar.__va_next_stack += sizeof (TYPE) / 8; \ } \ __result = __r; \ --- 148,152 ---- { \ __r = (__va_freg *) pvar.__va_next_stack; \ ! pvar.__va_next_stack += (sizeof (TYPE) + 7) / 8; \ } \ __result = __r; \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/global.c gcc-2.6.1/global.c *** gcc-2.6.0/global.c Wed Jun 29 16:00:18 1994 --- gcc-2.6.1/global.c Fri Sep 16 19:21:08 1994 *************** *** 447,450 **** --- 447,462 ---- local_reg_n_refs[i] = 0; + /* Likewise for regs used in a SCRATCH. */ + for (i = 0; i < scratch_list_length; i++) + if (scratch_list[i]) + { + int regno = REGNO (scratch_list[i]); + int lim = regno + HARD_REGNO_NREGS (regno, GET_MODE (scratch_list[i])); + int j; + + for (j = regno; j < lim; j++) + local_reg_n_refs[j] = 0; + } + /* Allocate the space for the conflict and preference tables and initialize them. */ *************** *** 924,927 **** --- 936,945 ---- IOR_HARD_REG_SET (used1, hard_reg_conflicts[allocno]); + #ifdef CLASS_CANNOT_CHANGE_SIZE + if (reg_changes_size[allocno_reg[allocno]]) + IOR_HARD_REG_SET (used1, + reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]); + #endif + /* Try each hard reg to see if it fits. Do this in two passes. In the first pass, skip registers that are preferred by some other pseudo *************** *** 1098,1122 **** && ! TEST_HARD_REG_BIT (used2, regno) && HARD_REGNO_MODE_OK (regno, mode) ! && (((double) local_reg_n_refs[regno] ! / local_reg_live_length[regno]) ! < ((double) allocno_n_refs[allocno] ! / allocno_live_length[allocno]))) { ! /* Hard reg REGNO was used less in total by local regs ! than it would be used by this one allocno! */ ! int k; ! for (k = 0; k < max_regno; k++) ! if (reg_renumber[k] >= 0) ! { ! int r = reg_renumber[k]; ! int endregno ! = r + HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (k)); ! if (regno >= r && regno < endregno) ! reg_renumber[k] = -1; ! } ! best_reg = regno; ! break; } } --- 1116,1155 ---- && ! TEST_HARD_REG_BIT (used2, regno) && HARD_REGNO_MODE_OK (regno, mode) ! #ifdef CLASS_CANNOT_CHANGE_SIZE ! && ! (reg_changes_size[allocno_reg[allocno]] ! && (TEST_HARD_REG_BIT ! (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], ! regno))) ! #endif ! ) { ! /* We explicitly evaluate the divide results into temporary ! variables so as to avoid excess precision problems that occur ! on a i386-unknown-sysv4.2 (unixware) host. */ ! ! double tmp1 = ((double) local_reg_n_refs[regno] ! / local_reg_live_length[regno]); ! double tmp2 = ((double) allocno_n_refs[allocno] ! / allocno_live_length[allocno]); ! if (tmp1 < tmp2) ! { ! /* Hard reg REGNO was used less in total by local regs ! than it would be used by this one allocno! */ ! int k; ! for (k = 0; k < max_regno; k++) ! if (reg_renumber[k] >= 0) ! { ! int r = reg_renumber[k]; ! int endregno ! = r + HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (k)); ! ! if (regno >= r && regno < endregno) ! reg_renumber[k] = -1; ! } ! best_reg = regno; ! break; ! } } } Only in gcc-2.6.0: gplus.gperf diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/install.sh gcc-2.6.1/install.sh *** gcc-2.6.0/install.sh Thu Jul 14 22:17:49 1994 --- gcc-2.6.1/install.sh Tue Nov 1 21:35:45 1994 *************** *** 4,8 **** # This comes from X11R5. # ! # $XConsortium: install.sh,v 1.2 89/12/18 14:47:22 jim Exp $ # # This script is compatible with the BSD install script, but was written --- 4,10 ---- # This comes from X11R5. # ! # Calling this script install-sh is preferred over install.sh, to prevent ! # `make' implicit rules from creating a file called install from it ! # when there is no Makefile. # # This script is compatible with the BSD install script, but was written diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/install.texi gcc-2.6.1/install.texi *** gcc-2.6.0/install.texi Thu Jul 14 12:51:44 1994 --- gcc-2.6.1/install.texi Wed Oct 26 14:42:06 1994 *************** *** 48,64 **** @item ! Specify the host and target machine configurations. You do this by ! running the file @file{configure} with appropriate arguments. ! The @file{configure} script searches subdirectories of the source ! directory for other compilers that are to be integrated into GNU CC. ! The GNU compiler for C++, called G++ is in a subdirectory named ! @file{cp}. @file{configure} inserts rules into @file{Makefile} to build ! all of those compilers. If you are building a compiler to produce code for the machine it runs ! on, specify the @dfn{configuration name} with the @samp{--target} ! option; the host will default to be the same as the target. (If ! you are building a cross-compiler, see @ref{Cross-Compiler}.) Here is an example: --- 48,71 ---- @item ! Specify the host, build and target machine configurations. You do this ! by running the file @file{configure}. ! The @dfn{build} machine is the system which you are usinfg, the ! @dfn{host} machine is the system where you want to run the resulting ! compiler (normally the build machine), and the @dfn{target} machine is ! the system for which you want the compiler to generate code. If you are building a compiler to produce code for the machine it runs ! on (a native compiler), you normally do not need to specify any operands ! to @file{configure}; it will try to guess the type of machine you are on ! and use that as the build, host and target machines. So you don't need ! to specify a configuration when building a native compiler unless ! @file{configure} cannot figure out what your configuration is or guesses ! wrong. ! ! In those cases, specify the build machine's @dfn{configuration name} ! with the @samp{--build} option; the host and target will default to be ! the same as the build machine. (If you are building a cross-compiler, ! see @ref{Cross-Compiler}.) Here is an example: *************** *** 65,77 **** @smallexample ! ./configure --target=sparc-sun-sunos4.1 @end smallexample - If you run @file{configure} without specifying configuration arguments, - @file{configure} tries to guess the type of host you are on, and uses - that configuration type for both host and target. So you don't need to - specify a configuration, for building a native compiler, unless - @file{configure} cannot figure out what your configuration is. - A configuration name may be canonical or it may be more or less abbreviated. --- 72,78 ---- @smallexample ! ./configure --build=sparc-sun-sunos4.1 @end smallexample A configuration name may be canonical or it may be more or less abbreviated. *************** *** 98,102 **** section before proceding any further with the installation of GNU CC. - There are four additional options you can specify independently to describe variant hardware and software configurations. These are --- 99,102 ---- *************** *** 129,135 **** has no effect. ! On the systems listed above (except for the HP-PA and for ISC on the ! 386), if you use GAS, you should also use the GNU linker (and specify ! @samp{--with-gnu-ld}). @item --with-gnu-ld --- 129,135 ---- has no effect. ! On the systems listed above (except for the HP-PA, for ISC on the ! 386, and for @samp{mips-sgi-irix5.*}), if you use GAS, you should also ! use the GNU linker (and specify @samp{--with-gnu-ld}). @item --with-gnu-ld *************** *** 163,166 **** --- 163,173 ---- supports C++ well; ordinary COFF debugging information does not. + @samp{--with-stabs} is also meaningful on 386 systems running SVR4. It + selects use of stabs debugging information embedded in ELF output. The + C++ compiler currently (2.6.0) does not support the DWARF debugging + information normally used on 386 SVR4 platforms; stabs provide a + workable alternative. This requires gas and gdb, as the normal SVR4 + tools can not generate or interpret stabs. + @item --nfp On certain systems, you must specify whether the machine has a floating *************** *** 171,174 **** --- 178,187 ---- @end table + The @file{configure} script searches subdirectories of the source + directory for other compilers that are to be integrated into GNU CC. + The GNU compiler for C++, called G++ is in a subdirectory named + @file{cp}. @file{configure} inserts rules into @file{Makefile} to build + all of those compilers. + Here we spell out what files will be set up by @code{configure}. Normally you need not be concerned with these files. *************** *** 237,250 **** with one exception: the directory @file{/usr/local/include} is searched for header files no matter where you install the compiler. To override ! this name, use thge @code{--local-prefix} option below. @item Specify @samp{--local-prefix=@var{dir}} if you want the compiler to ! search directory @file{@var{dir}/include} for header files ! @emph{instead} of @file{/usr/local/include}. (This is for systems that ! have different conventions for where to put site-specific things.) ! Unless you have a convention other than @file{/usr/local} for ! site-specific files, it is a bad idea to specify @samp{--local-prefix}. @cindex Bison parser generator --- 250,270 ---- with one exception: the directory @file{/usr/local/include} is searched for header files no matter where you install the compiler. To override ! this name, use the @code{--local-prefix} option below. @item Specify @samp{--local-prefix=@var{dir}} if you want the compiler to ! search directory @file{@var{dir}/include} for locally installed header ! files @emph{instead} of @file{/usr/local/include}. ! You should specify @samp{--local-prefix} @strong{only} if your site has ! a different convention (not @file{/usr/local}) for where to put ! site-specific files. ! ! @strong{Do not} specify @file{/usr} as the @samp{--local-prefix}! The ! directory you use for @samp{--local-prefix} @strong{must not} contain ! any of the system's standard header files. If it did contain them, ! certain programs would be miscompiled (including GNU Emacs, on certain ! targets), because this would override and nullify the header file ! corrections made by the @code{fixincludes} script. @cindex Bison parser generator *************** *** 307,317 **** you need to break up the statement where the problem happens. - If you are building with a previous GNU C compiler, do not - use @samp{CC=gcc} on the make command or by editing the Makefile. - Instead, use a full pathname to specify the compiler, such as - @samp{CC=/usr/local/bin/gcc}. This is because make might execute - the @file{gcc} in the current directory before all of the - compiler components have been built. - @item If you are building a cross-compiler, stop here. @xref{Cross-Compiler}. --- 327,330 ---- *************** *** 522,528 **** @quotation @c gmicro, alliant, spur and tahoe omitted since they don't work. ! 1750a, a29k, alpha, arm, c@var{n}, clipper, elxsi, h8300, hppa1.0, hppa1.1, ! i370, i386, i486, i860, i960, m68000, m68k, m88k, mips, ! ns32k, pyramid, romp, rs6000, sh, sparc, sparclite, sparc64, vax, we32k. @end quotation --- 535,542 ---- @quotation @c gmicro, alliant, spur and tahoe omitted since they don't work. ! 1750a, a29k, alpha, arm, c@var{n}, clipper, dsp16xx, elxsi, h8300, ! hppa1.0, hppa1.1, i370, i386, i486, i860, i960, m68000, m68k, m88k, ! mips, ns32k, pyramid, romp, rs6000, sh, sparc, sparclite, sparc64, vax, ! we32k. @end quotation *************** *** 548,555 **** @quotation 386bsd, aix, acis, amigados, aos, aout, bosx, bsd, clix, ctix, cxux, ! dgux, dynix, ebmon, elf, esix, freebsd, hms, genix, gnu, hiux, hpux, ! iris, irix, isc, linux, luna, lynxos, mach, minix, msdos, mvs, netbsd, ! newsos, nindy, ns, osf, osfrose, riscix, riscos, rtu, sco, solaris, ! sunos, sym, sysv, ultrix, unicos, uniplus, unos, vms, vxworks, xenix. @end quotation --- 562,570 ---- @quotation 386bsd, aix, acis, amigados, aos, aout, bosx, bsd, clix, ctix, cxux, ! dgux, dynix, ebmon, elf, esix, freebsd, hms, genix, gnu, gnu/linux, ! hiux, hpux, iris, irix, isc, luna, lynxos, mach, minix, msdos, mvs, ! netbsd, newsos, nindy, ns, osf, osfrose, ptx, riscix, riscos, rtu, sco, ! solaris, sunos, sym, sysv, ultrix, unicos, uniplus, unos, vms, vxworks, ! xenix. @end quotation *************** *** 602,606 **** Thus, if you specify @samp{m68k-local}, configuration uses ! files @file{local.md}, @file{local.h}, @file{local.c}, @file{xm-local.h}, @file{t-local}, and @file{x-local}, all in the directory @file{config/m68k}. --- 617,621 ---- Thus, if you specify @samp{m68k-local}, configuration uses ! files @file{m68k.md}, @file{local.h}, @file{m68k.c}, @file{xm-local.h}, @file{t-local}, and @file{x-local}, all in the directory @file{config/m68k}. *************** *** 611,621 **** @table @samp @item 1750a-*-* ! MIL-STD-1750A processors. This port is preliminary. You should ignore a fatal error during the building of libgcc (libgcc is not yet implemented for the 1750A.) ! The Tektronix MIL-STD-1750A Assembler requires the file ! @file{m1750.inc}, which is found in the directory @file{config/1750a}. GNU CC produced the same sections as the Fairchild F9450 C Compiler, --- 626,643 ---- @table @samp @item 1750a-*-* ! MIL-STD-1750A processors. + Starting with GCC 2.6.1, the MIL-STD-1750A cross configuration no longer + supports the Tektronix Assembler, but instead produces output for + @code{as1750}, an assembler/linker available under the GNU Public + License for the 1750A. Contact @emph{okellogg@@salyko.cube.net} for more + details on obtaining @samp{as1750}. A similarly licensed simulator for + the 1750A is available from same address. + You should ignore a fatal error during the building of libgcc (libgcc is not yet implemented for the 1750A.) ! The @code{as1750} assembler requires the file @file{ms1750.inc}, which is ! found in the directory @file{config/1750a}. GNU CC produced the same sections as the Fairchild F9450 C Compiler, *************** *** 760,763 **** --- 782,788 ---- compiling GNU C. Please contact @code{mrs@@cygnus.com} for more details. + @item dsp16xx + A port to the AT&T DSP1610 family of processors. + @ignore @item fx80 *************** *** 854,860 **** have a higher-quality port for this machine soon. ! @item i386-*-linux Bash-1.12 has a bug that causes configure to fail. The symptom is that ! the c++ subdirectory, cp, is not configured. Bash-1.14 and later work fine. @item i386-*-sco --- 879,886 ---- have a higher-quality port for this machine soon. ! @item i386-*-gnu/linux Bash-1.12 has a bug that causes configure to fail. The symptom is that ! the c++ subdirectory, @file{cp}, is not configured. Bash-1.14 and later ! work fine. @item i386-*-sco *************** *** 866,872 **** @item i386-*-isc ! It may be good idea to link with GNU malloc instead of the malloc that comes with the system. @item i386-*-esix It may be good idea to link with GNU malloc instead of the malloc that --- 892,901 ---- @item i386-*-isc ! It may be a good idea to link with GNU malloc instead of the malloc that comes with the system. + In ISC version 4.1, @file{sed} core dumps when building + @file{deduced.h}. Use the version of @file{sed} from version 4.0. + @item i386-*-esix It may be good idea to link with GNU malloc instead of the malloc that *************** *** 877,881 **** GNU binutils version 2.2 or later. ! @item i386-sequent Go to the Berkeley universe before compiling. In addition, you probably need to create a file named @file{string.h} containing just one line: --- 906,910 ---- GNU binutils version 2.2 or later. ! @item i386-sequent-bsd Go to the Berkeley universe before compiling. In addition, you probably need to create a file named @file{string.h} containing just one line: *************** *** 882,885 **** --- 911,920 ---- @samp{#include }. + @item i386-sequent-ptx1* + Sequent DYNIX/ptx 1.x. + + @item i386-sequent-ptx2* + Sequent DYNIX/ptx 2.x. + @item i386-sun-sunos4 You may find that you need another version of GNU CC to begin *************** *** 1006,1010 **** HP 9000 series 300 or 400 running HP-UX. HP-UX version 8.0 has a bug in the assembler that prevents compilation of GNU CC. To fix it, get patch ! PHCO_0800 from HP. In addition, if you wish to use gas @samp{--with-gnu-as} you must use --- 1041,1045 ---- HP 9000 series 300 or 400 running HP-UX. HP-UX version 8.0 has a bug in the assembler that prevents compilation of GNU CC. To fix it, get patch ! PHCO_4484 from HP. In addition, if you wish to use gas @samp{--with-gnu-as} you must use *************** *** 1037,1047 **** @item m88k-*-dgux ! Motorola m88k running DG/UX. To build native or cross compilers on ! DG/UX, you must first change to the 88open BCS software development ! environment. This is done by issuing this command: ! @smallexample ! eval `sde-target m88kbcs` ! @end smallexample @item m88k-tektronix-sysv3 --- 1072,1086 ---- @item m88k-*-dgux ! Motorola m88k running DG/UX. To build 88open BCS native or cross ! compilers on DG/UX, specify the configuration name as ! @samp{m88k-*-dguxbcs} and build in the 88open BCS software development ! environment. To build ELF native or cross compilers on DG/UX, specify ! @samp{m88k-*-dgux} and build in the DG/UX ELF development environment. ! You set the software development environment by issuing ! @samp{sde-target} command and specifying either @samp{m88kbcs} or ! @samp{m88kdguxelf} as the operand. ! If you do not specify a configuration name, @file{configure} guesses the ! configuration based on the current software development environment. @item m88k-tektronix-sysv3 *************** *** 1152,1157 **** reordering---perhaps GNU CC itself was miscompiled as a result. ! See the file @file{README.IRIX5} for information on how to make ! debugging work. @item mips-sony-sysv --- 1191,1197 ---- reordering---perhaps GNU CC itself was miscompiled as a result. ! To enable debugging under Irix 5, you must use GNU as 2.5 or later, ! and use the --with-gnu-as configure option when configuring gcc. ! GNU as is distributed as part of the binutils package. @item mips-sony-sysv *************** *** 1313,1317 **** @example ! ../gcc/configure --srcdir=../gcc sun3 @end example --- 1353,1357 ---- @example ! ../gcc/configure --srcdir=../gcc @var{other options} @end example *************** *** 1346,1351 **** @item ! Cross-compilation between machines of different word sizes has not ! really been addressed yet. @end itemize --- 1386,1391 ---- @item ! Cross-compilation between machines of different word sizes is ! somewhat problematic and sometimes does not work. @end itemize *************** *** 1400,1412 **** To build GNU CC as a cross-compiler, you start out by running ! @code{configure}. You must specify two different configurations, the ! host and the target. Use the @samp{--host=@var{host}} option for the ! host and @samp{--target=@var{target}} to specify the target type. For ! example, here is how to configure for a cross-compiler that runs on a ! hypothetical Intel 386 system and produces code for an HP 68030 system ! running BSD: @smallexample ! ./configure --target=m68k-hp-bsd4.3 --host=i386-bozotheclone-bsd4.3 @end smallexample --- 1440,1452 ---- To build GNU CC as a cross-compiler, you start out by running ! @file{configure}. Use the @samp{--target=@var{target}} to specify the ! target type. If @file{configure} was unable to correctly identify the ! system you are running on, also specify the @samp{--build=@var{build}} ! option. For example, here is how to configure for a cross-compiler that ! produces code for an HP 68030 system running BSD on a system that ! @file{configure} can correctly identify: @smallexample ! ./configure --target=m68k-hp-bsd4.3 @end smallexample diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/integrate.c gcc-2.6.1/integrate.c *** gcc-2.6.0/integrate.c Thu Jun 16 19:33:38 1994 --- gcc-2.6.1/integrate.c Fri Aug 19 17:30:19 1994 *************** *** 135,142 **** return "function with varying-size return value cannot be inline"; ! /* Cannot inline a function with a varying size argument. */ for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms)) ! if (int_size_in_bytes (TREE_TYPE (parms)) < 0) ! return "function with varying-size parameter cannot be inline"; if (!DECL_INLINE (fndecl) && get_max_uid () > max_insns) --- 135,147 ---- return "function with varying-size return value cannot be inline"; ! /* Cannot inline a function with a varying size argument or one that ! receives a transparent union. */ for (parms = DECL_ARGUMENTS (fndecl); parms; parms = TREE_CHAIN (parms)) ! { ! if (int_size_in_bytes (TREE_TYPE (parms)) < 0) ! return "function with varying-size parameter cannot be inline"; ! else if (TYPE_TRANSPARENT_UNION (TREE_TYPE (parms))) ! return "function with transparent unit parameter cannot be inline"; ! } if (!DECL_INLINE (fndecl) && get_max_uid () > max_insns) *************** *** 1236,1239 **** --- 1241,1245 ---- /* Mode of the variable used within the function. */ enum machine_mode mode = TYPE_MODE (TREE_TYPE (formal)); + int invisiref = 0; /* Make sure this formal has some correspondence in the users code *************** *** 1264,1267 **** --- 1270,1274 ---- arg_vals[i] = XEXP (stack_slot, 0); + invisiref = 1; } else if (GET_CODE (loc) != MEM) *************** *** 1289,1294 **** sorts of smart assumptions about their not conflicting. But if ARG_VALS[I] overlaps TARGET, these assumptions are ! wrong, so put ARG_VALS[I] into a fresh register. */ || (target != 0 && (GET_CODE (arg_vals[i]) == REG || GET_CODE (arg_vals[i]) == SUBREG --- 1296,1304 ---- sorts of smart assumptions about their not conflicting. But if ARG_VALS[I] overlaps TARGET, these assumptions are ! wrong, so put ARG_VALS[I] into a fresh register. ! Don't worry about invisible references, since their stack ! temps will never overlap the target. */ || (target != 0 + && ! invisiref && (GET_CODE (arg_vals[i]) == REG || GET_CODE (arg_vals[i]) == SUBREG *************** *** 1641,1645 **** for (insn = insns; insn; insn = NEXT_INSN (insn)) { ! rtx copy, pattern; map->orig_asm_operands_vector = 0; --- 1651,1655 ---- for (insn = insns; insn; insn = NEXT_INSN (insn)) { ! rtx copy, pattern, set; map->orig_asm_operands_vector = 0; *************** *** 1649,1652 **** --- 1659,1663 ---- case INSN: pattern = PATTERN (insn); + set = single_set (insn); copy = 0; if (GET_CODE (pattern) == USE *************** *** 1660,1674 **** /* Ignore setting a function value that we don't want to use. */ if (map->inline_target == 0 ! && GET_CODE (pattern) == SET ! && GET_CODE (SET_DEST (pattern)) == REG ! && REG_FUNCTION_VALUE_P (SET_DEST (pattern))) { ! if (volatile_refs_p (SET_SRC (pattern))) { /* If we must not delete the source, load it into a new temporary. */ copy = emit_insn (copy_rtx_and_substitute (pattern, map)); ! SET_DEST (PATTERN (copy)) ! = gen_reg_rtx (GET_MODE (SET_DEST (PATTERN (copy)))); } else --- 1671,1692 ---- /* Ignore setting a function value that we don't want to use. */ if (map->inline_target == 0 ! && set != 0 ! && GET_CODE (SET_DEST (set)) == REG ! && REG_FUNCTION_VALUE_P (SET_DEST (set))) { ! if (volatile_refs_p (SET_SRC (set))) { + rtx new_set; + /* If we must not delete the source, load it into a new temporary. */ copy = emit_insn (copy_rtx_and_substitute (pattern, map)); ! ! new_set = single_set (copy); ! if (new_set == 0) ! abort (); ! ! SET_DEST (new_set) ! = gen_reg_rtx (GET_MODE (SET_DEST (new_set))); } else *************** *** 1675,1690 **** break; } /* If this is setting the static chain pseudo, set it from the value we want to give it instead. */ else if (static_chain_value != 0 ! && GET_CODE (pattern) == SET ! && rtx_equal_p (SET_SRC (pattern), static_chain_incoming_rtx)) { ! rtx newdest = copy_rtx_and_substitute (SET_DEST (pattern), map); ! ! copy = emit_insn (gen_rtx (SET, VOIDmode, newdest, ! static_chain_value)); static_chain_value = 0; } --- 1693,1715 ---- break; } + + /* If this is setting the static chain rtx, omit it. */ + else if (static_chain_value != 0 + && set != 0 + && GET_CODE (SET_DEST (set)) == REG + && rtx_equal_p (SET_DEST (set), + static_chain_incoming_rtx)) + break; + /* If this is setting the static chain pseudo, set it from the value we want to give it instead. */ else if (static_chain_value != 0 ! && set != 0 ! && rtx_equal_p (SET_SRC (set), static_chain_incoming_rtx)) { ! rtx newdest = copy_rtx_and_substitute (SET_DEST (set), map); + copy = emit_move_insn (newdest, static_chain_value); static_chain_value = 0; } *************** *** 2586,2589 **** --- 2611,2617 ---- if ((map->num_sets < MAX_RECOG_OPERANDS) && (CONSTANT_P (src) + || (GET_CODE (src) == REG + && REGNO (src) >= FIRST_VIRTUAL_REGISTER + && REGNO (src) <= LAST_VIRTUAL_REGISTER) || (GET_CODE (src) == PLUS && GET_CODE (XEXP (src, 0)) == REG diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/invoke.texi gcc-2.6.1/invoke.texi *** gcc-2.6.0/invoke.texi Wed Jul 13 16:15:13 1994 --- gcc-2.6.1/invoke.texi Tue Oct 18 19:20:35 1994 *************** *** 1,3 **** ! @c Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. --- 1,3 ---- ! @c Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. *************** *** 121,126 **** -Wmissing-prototypes -Wnested-externs -Wno-import -Woverloaded-virtual -Wparentheses ! -Wpointer-arith -Wredundant-decls -Wreturn-type -Wshadow ! -Wstrict-prototypes -Wswitch -Wtemplate-debugging -Wtraditional -Wtrigraphs -Wuninitialized -Wunused -Wwrite-strings --- 121,126 ---- -Wmissing-prototypes -Wnested-externs -Wno-import -Woverloaded-virtual -Wparentheses ! -Wpointer-arith -Wredundant-decls -Wreorder -Wreturn-type -Wshadow ! -Wstrict-prototypes -Wswitch -Wsynth -Wtemplate-debugging -Wtraditional -Wtrigraphs -Wuninitialized -Wunused -Wwrite-strings *************** *** 162,166 **** -iwithprefixbefore @var{dir} -isystem @var{dir} -M -MD -MM -MMD -MG -nostdinc -P -trigraphs ! -undef -U@var{macro} @end smallexample --- 162,166 ---- -iwithprefixbefore @var{dir} -isystem @var{dir} -M -MD -MM -MMD -MG -nostdinc -P -trigraphs ! -undef -U@var{macro} -Wp,@var{option} @end smallexample *************** *** 176,180 **** @var{object-file-name} -l@var{library} -nostartfiles -nostdlib ! -static -shared -symbolic -Wl,@var{option} -Xlinker @var{option} -u @var{symbol} --- 176,180 ---- @var{object-file-name} -l@var{library} -nostartfiles -nostdlib ! -s -static -shared -symbolic -Wl,@var{option} -Xlinker @var{option} -u @var{symbol} *************** *** 215,219 **** in addition to the above: ! -mcode-model=@var{code model} -mint32 -mint64 -mlong32 -mlong64 -mno-stack-bias -mstack-bias --- 215,219 ---- in addition to the above: ! -mmedlow -mmedany -mint32 -mint64 -mlong32 -mlong64 -mno-stack-bias -mstack-bias *************** *** 277,280 **** --- 277,281 ---- -m486 -mieee-fp -mno-486 -mno-fancy-math-387 -mno-fp-ret-in-387 -msoft-float -msvr3-shlib + -mno-wide-multiply -mreg-alloc=@var{list} @emph{HPPA Options} *************** *** 477,484 **** @cindex C++ source file suffixes C++ source files conventionally use one of the suffixes @samp{.C}, ! @samp{.cc}, or @samp{.cxx}; preprocessed C++ files use the suffix ! @samp{.ii}. GNU CC recognizes files with these names and compiles ! them as C++ programs even if you call the compiler the same way as for ! compiling C programs (usually with the name @code{gcc}). @findex g++ --- 478,485 ---- @cindex C++ source file suffixes C++ source files conventionally use one of the suffixes @samp{.C}, ! @samp{.cc}, @samp{cpp}, or @samp{.cxx}; preprocessed C++ files use the ! suffix @samp{.ii}. GNU CC recognizes files with these names and ! compiles them as C++ programs even if you call the compiler the same way ! as for compiling C programs (usually with the name @code{gcc}). @findex g++ *************** *** 807,810 **** --- 808,818 ---- any case. + @item -fconserve-space + Put uninitialized or runtime-initialized global variables into the + common segment, as C does. This saves space in the executable at the + cost of not diagnosing duplicate definitions. If your program + mysteriously crashes after @code{main()} has completed, you may have an + object that is being destroyed twice because two definitions were merged. + @item -fdollars-in-identifiers Accept @samp{$} in identifiers. You can also explicitly prohibit use of *************** *** 814,837 **** identifiers. However, ANSI C and C++ forbid @samp{$} in identifiers. - @item -felide-constructors - Elide constructors when this seems plausible. With this option, GNU C++ - initializes @code{y} directly from the call to @code{foo} without going - through a temporary in the following code: - - @smallexample - A foo (); - A y = foo (); - @end smallexample - - Without this option, GNU C++ (1) initializes @code{y} by calling the - appropriate constructor for type @code{A}; (2) assigns the result of - @code{foo} to a temporary; and, finally, (3) replaces the initial value of - @code{y} with the temporary. - - The default behavior (@samp{-fno-elide-constructors}) is specified by - the draft ANSI C++ standard. If your program's constructors have side - effects, @samp{-felide-constructors} can change your program's behavior, - since some constructor calls may be omitted. - @item -fenum-int-equiv Permit implicit conversion of @code{int} to enumeration types. Normally --- 822,825 ---- *************** *** 840,865 **** @item -fexternal-templates ! Produce smaller code for template declarations, by generating only a ! single copy of each template function where it is defined. To use this ! option successfully, you must also mark all files that use templates ! with either @samp{#pragma implementation} (the definition) or ! @samp{#pragma interface} (declarations). @xref{C++ ! Interface,,Declarations and Definitions in One Header}, for more ! discussion of these pragmas. ! ! When your code is compiled with @samp{-fexternal-templates}, all ! template instantiations are external. You must arrange for all ! necessary instantiations to appear in the implementation file; you can ! do this with a @code{typedef} that references each instantiation needed. ! Conversely, when you compile using the default option ! @samp{-fno-external-templates}, all template instantiations are ! explicitly internal. ! ! You do not need to specify @samp{-fexternal-templates} when compiling a ! file that does not define and instantiate templates used in other files, ! even if your file @emph{uses} templates defined in other files that are ! compiled with @samp{-fexternal-templates}. The only side effect is an ! increase in object size for each file that you compile without ! @samp{-fexternal-templates}. @item -fhandle-signatures --- 828,845 ---- @item -fexternal-templates ! Cause template instantiations to obey @samp{#pragma interface} and ! @samp{implementation}; template instances are emitted or not according ! to the location of the template definition. @xref{Template ! Instantiation}, for more information. ! ! @item -falt-external-templates ! Similar to -fexternal-templates, but template instances are emitted or ! not according to the place where they are first instantiated. ! @xref{Template Instantiation}, for more information. ! ! @item -fno-implicit-templates ! Never emit code for templates which are instantiated implicitly (i.e. by ! use); only emit code for explicit instantiations. @xref{Template ! Instantiation}, for more information. @item -fhandle-signatures *************** *** 869,872 **** --- 849,866 ---- Signatures}. + @item -fhuge-objects + Support virtual function calls for objects that exceed the size + representable by a @samp{short int}. Users should not use this flag by + default; if you need to use it, the compiler will tell you so. If you + compile any of your code with this flag, you must compile @emph{all} of + your code with this flag (including libg++, if you use it). + + This flag is not useful when compiling with -fvtable-thunks. + + @item -fno-implement-inlines + To save space, do not emit out-of-line copies of inline functions + controlled by @samp{#pragma implementation}. This will cause linker + errors if these functions are not inlined everywhere they are called. + @item -fmemoize-lookups @itemx -fsave-memoized *************** *** 914,917 **** --- 908,914 ---- that the function @code{foo} takes no arguments. + This option does not work with operator overloading, which places + constraints on the parameter types. + @item -fnonnull-objects Assume that objects reached through references are not null. *************** *** 931,942 **** program doesn't require checking. @item -fthis-is-variable ! Permit assignment to @code{this}. The incorporation of ! user-defined free store management into C++ has made assignment to ! @samp{this} an anachronism. Therefore, by default it is invalid to ! assign to @code{this} within a class member function; that is, GNU C++ ! treats the type of @samp{this} in a member function of class @code{X} ! to be @samp{X *const}. However, for backwards compatibility, you can ! make it valid with @samp{-fthis-is-variable}. @item -nostdinc++ --- 928,954 ---- program doesn't require checking. + This checking is currently only done for conversions to virtual base classes. + @item -fthis-is-variable ! Permit assignment to @code{this}. The incorporation of user-defined ! free store management into C++ has made assignment to @samp{this} an ! anachronism. Therefore, by default it is invalid to assign to ! @code{this} within a class member function; that is, GNU C++ treats ! @samp{this} in a member function of class @code{X} as a non-lvalue of ! type @samp{X *}. However, for backwards compatibility, you can make it ! valid with @samp{-fthis-is-variable}. ! ! @item -fvtable-thunks ! Use @samp{thunks} to implement the virtual function dispatch table ! (@samp{vtable}). The traditional (cfront-style) approach to ! implementing vtables was to store a pointer to the function and two ! offsets for adjusting the @samp{this} pointer at the call site. Newer ! implementations store a single pointer to a @samp{thunk} function which ! does any necessary adjustment and then calls the target function. ! ! This option also enables a heuristic for controlling emission of ! vtables; if a class has any non-inline virtual functions, the vtable ! will be emitted in the translation unit containing the first one of ! those. @item -nostdinc++ *************** *** 1076,1080 **** @item ! An unsigned value is compared against zero with @samp{>} or @samp{<=}. @item --- 1088,1092 ---- @item ! An unsigned value is compared against zero with @samp{<} or @samp{<=}. @item *************** *** 1108,1112 **** @item -Wunused ! Warn whenever a local variable is unused aside from its declaration, whenever a function is declared static but never defined, whenever a label is declared but not used, and whenever a statement computes a --- 1120,1124 ---- @item -Wunused ! Warn whenever a variable is unused aside from its declaration, whenever a function is declared static but never defined, whenever a label is declared but not used, and whenever a statement computes a *************** *** 1113,1116 **** --- 1125,1140 ---- result that is explicitly not used. + To suppress this warning for a local variable or expression, simply cast + it to void. This will also work for file-scope variables, but if you + want to mark them used at the point of definition, you can use this + macro: + + @smallexample + #define USE(var) \ + static void *const use_##var = (&use_##var, &var, 0) + + USE (string); + @end smallexample + @item -Wswitch Warn whenever a @code{switch} statement has an index of enumeral type *************** *** 1193,1197 **** Some spurious warnings can be avoided if you declare all the functions ! you use that never return as @code{volatile}. @xref{Function Attributes}. --- 1217,1221 ---- Some spurious warnings can be avoided if you declare all the functions ! you use that never return as @code{noreturn}. @xref{Function Attributes}. *************** *** 1213,1216 **** --- 1237,1258 ---- fully available (C++ only). + @item -Wreorder (C++ only) + @cindex reordering, warning + @cindex warning for reordering of member initializers + Warn when the order of member initializers given in the code does not + match the order in which they must be executed. For instance: + + @smallexample + struct A @{ + int i; + int j; + A(): j (0), i (1) @{ @} + @}; + @end smallexample + + Here the compiler will warn that the member initializers for @samp{i} + and @samp{j} will be rearranged to match the declaration order of the + members. + @item -Wall All of the above @samp{-W} options combined. These are all the *************** *** 1340,1343 **** --- 1382,1407 ---- declarations from the base class. + @item -Wsynth (C++ only) + @cindex warning for synthesized methods + @cindex synthesized methods, warning + Warn when g++'s synthesis behavior does not match that of cfront. For + instance: + + @smallexample + struct A @{ + operator int (); + A& operator = (int); + @}; + + main () + @{ + A a,b; + a = b; + @} + @end smallexample + + In this example, g++ will synthesize a default @samp{A& operator = + (const A&);}, while cfront will use the user-defined @samp{operator =}. + @item -Werror Make all warnings into errors. *************** *** 1388,1393 **** Produce debugging information in stabs format (if that is supported), without GDB extensions. This is the format used by DBX on most BSD ! systems. On MIPS and Alpha systems this option produces embedded stabs ! debugging output which is not understood by DBX. @item -gstabs+ --- 1452,1458 ---- Produce debugging information in stabs format (if that is supported), without GDB extensions. This is the format used by DBX on most BSD ! systems. On MIPS, Alpha and System V Release 4 systems this option ! produces stabs debugging output which is not understood by DBX or SDB. ! On System V Release 4 systems this option requires the GNU assembler. @item -gstabs+ *************** *** 1607,1613 **** and the performance of the generated code. ! @samp{-O2} turns on all optional optimizations except for loop unrolling, ! function inlining, and, on machines where it interfers with debugging, ! frame pointer elimination. @item -O3 --- 1672,1678 ---- and the performance of the generated code. ! @samp{-O2} turns on all optional optimizations except for loop unrolling ! and function inlining. It also turns on frame pointer elimination on ! machines where doing so does not interfer with debugging. @item -O3 *************** *** 1984,1987 **** --- 2049,2056 ---- @item -trigraphs Support ANSI C trigraphs. The @samp{-ansi} option also has this effect. + + @item -Wp,@var{option} + Pass @var{option} as an option to the preprocessor. If @var{option} + contains commas, it is split into multiple options at the commas. @end table *************** *** 2080,2083 **** --- 2149,2155 ---- constructors will be called; @pxref{Collect2,,@code{collect2}}.) + @item -s + Remove all symbol table and relocation information from the executable. + @item -static On systems that support dynamic linking, this prevents linking with the shared *************** *** 2537,2541 **** With @samp{-mcypress} (the default), the compiler optimizes code for the ! Cypress CY7C602 chip, as used in the SparcStation/SparcSever 3xx series. This is also apropriate for the older SparcStation 1, 2, IPX etc. --- 2609,2613 ---- With @samp{-mcypress} (the default), the compiler optimizes code for the ! Cypress CY7C602 chip, as used in the SparcStation/SparcServer 3xx series. This is also apropriate for the older SparcStation 1, 2, IPX etc. *************** *** 2552,2556 **** @table @code ! @item -mcode-model=medium-low Generate code for the Medium/Low code model: assume a 32 bit address space. Programs are statically linked, PIC is not supported. Pointers are still --- 2624,2628 ---- @table @code ! @item -mmedlow Generate code for the Medium/Low code model: assume a 32 bit address space. Programs are statically linked, PIC is not supported. Pointers are still *************** *** 2557,2561 **** 64 bits. ! @item -mcode-model=medium-anywhere Generate code for the Medium/Anywhere code model: assume a 32 bit text segment starting at offset 0, and a 32 bit data segment starting anywhere --- 2629,2635 ---- 64 bits. ! It is very likely that a future version of GCC will rename this option. ! ! @item -mmedany Generate code for the Medium/Anywhere code model: assume a 32 bit text segment starting at offset 0, and a 32 bit data segment starting anywhere *************** *** 2563,2566 **** --- 2637,2642 ---- supported. Pointers are still 64 bits. + It is very likely that a future version of GCC will rename this option. + @item -mint64 Types long and int are 64 bits. *************** *** 2894,2911 **** @kindex -mno-serialize-volatile @cindex sequential consistency on 88k ! Do, or do not, generate code to guarantee sequential consistency of ! volatile memory references. ! ! GNU CC always guarantees consistency by default. ! ! The order of memory references made by the m88110 processor does not ! always match the order of the instructions requesting those references. ! In particular, a load instruction may execute before a preceding store ! instruction. Such reordering violates sequential consistency of ! volatile memory references, when there are multiple processors. The extra code generated to guarantee consistency may affect the ! performance of your application. If you know that you can safely forgo ! this guarantee, you may use the option @samp{-mno-serialize-volatile}. @item -msvr4 --- 2970,2996 ---- @kindex -mno-serialize-volatile @cindex sequential consistency on 88k ! Do, or don't, generate code to guarantee sequential consistency ! of volatile memory references. By default, consistency is ! guaranteed. ! ! The order of memory references made by the MC88110 processor does ! not always match the order of the instructions requesting those ! references. In particular, a load instruction may execute before ! a preceding store instruction. Such reordering violates ! sequential consistency of volatile memory references, when there ! are multiple processors. When consistency must be guaranteed, ! GNU C generates special instructions, as needed, to force ! execution in the proper order. ! ! The MC88100 processor does not reorder memory references and so ! always provides sequential consistency. However, by default, GNU ! C generates the special instructions to guarantee consistency ! even when you use @samp{-m88100}, so that the code may be run on an ! MC88110 processor. If you intend to run your code only on the ! MC88100 processor, you may use @samp{-mno-serialize-volatile}. The extra code generated to guarantee consistency may affect the ! performance of your application. If you know that you can safely ! forgo this guarantee, you may use @samp{-mno-serialize-volatile}. @item -msvr4 *************** *** 2920,2925 **** @enumerate @item ! Which variant of the assembler syntax to emit (which you can select ! independently using @samp{-mversion-03.00}). @item @samp{-msvr4} makes the C preprocessor recognize @samp{#pragma weak} --- 3005,3009 ---- @enumerate @item ! Which variant of the assembler syntax to emit. @item @samp{-msvr4} makes the C preprocessor recognize @samp{#pragma weak} *************** *** 2930,2941 **** @end enumerate ! @samp{-msvr3} is the default for all m88k configurations except ! the SVr4 configuration. @item -mversion-03.00 @kindex -mversion-03.00 ! In the DG/UX configuration, there are two flavors of SVr4. This option ! modifies @samp{-msvr4} to select whether the hybrid-COFF or real-ELF ! flavor is used. All other configurations ignore this option. @c ??? which asm syntax better for GAS? option there too? --- 3014,3024 ---- @end enumerate ! @samp{-msvr4} is the default for the m88k-motorola-sysv4 and ! m88k-dg-dgux m88k configurations. @samp{-msvr3} is the default for all ! other m88k configurations. @item -mversion-03.00 @kindex -mversion-03.00 ! This option is obsolete, and is ignored. @c ??? which asm syntax better for GAS? option there too? *************** *** 2945,2964 **** @kindex -mcheck-zero-division @cindex zero division on 88k ! Early models of the 88k architecture had problems with division by zero; ! in particular, many of them didn't trap. Use these options to avoid ! including (or to include explicitly) additional code to detect division ! by zero and signal an exception. All GNU CC configurations for the 88k use ! @samp{-mcheck-zero-division} by default. @item -muse-div-instruction @kindex -muse-div-instruction @cindex divide instruction, 88k ! Do not emit code to check both the divisor and dividend when doing ! signed integer division to see if either is negative, and adjust the ! signs so the divide is done using non-negative numbers. Instead, rely ! on the operating system to calculate the correct value when the ! @code{div} instruction traps. This results in different behavior when ! the most negative number is divided by -1, but is useful when most or ! all signed integer divisions are done with positive numbers. @item -mtrap-large-shift --- 3028,3076 ---- @kindex -mcheck-zero-division @cindex zero division on 88k ! Do, or don't, generate code to guarantee that integer division by ! zero will be detected. By default, detection is guaranteed. + Some models of the MC88100 processor fail to trap upon integer + division by zero under certain conditions. By default, when + compiling code that might be run on such a processor, GNU C + generates code that explicitly checks for zero-valued divisors + and traps with exception number 503 when one is detected. Use of + mno-check-zero-division suppresses such checking for code + generated to run on an MC88100 processor. + + GNU C assumes that the MC88110 processor correctly detects all + instances of integer division by zero. When @samp{-m88110} is + specified, both @samp{-mcheck-zero-division} and + @samp{-mno-check-zero-division} are ignored, and no explicit checks for + zero-valued divisors are generated. + @item -muse-div-instruction @kindex -muse-div-instruction @cindex divide instruction, 88k ! Use the div instruction for signed integer division on the ! MC88100 processor. By default, the div instruction is not used. ! ! On the MC88100 processor the signed integer division instruction ! div) traps to the operating system on a negative operand. The ! operating system transparently completes the operation, but at a ! large cost in execution time. By default, when compiling code ! that might be run on an MC88100 processor, GNU C emulates signed ! integer division using the unsigned integer division instruction ! divu), thereby avoiding the large penalty of a trap to the ! operating system. Such emulation has its own, smaller, execution ! cost in both time and space. To the extent that your code's ! important signed integer division operations are performed on two ! nonnegative operands, it may be desirable to use the div ! instruction directly. ! ! On the MC88110 processor the div instruction (also known as the ! divs instruction) processes negative operands without trapping to ! the operating system. When @samp{-m88110} is specified, ! @samp{-muse-div-instruction} is ignored, and the div instruction is used ! for signed integer division. ! ! Note that the result of dividing INT_MIN by -1 is undefined. In ! particular, the behavior of such a division with and without ! @samp{-muse-div-instruction} may differ. @item -mtrap-large-shift *************** *** 3203,3206 **** --- 3315,3319 ---- Issue instructions from level 3 of the MIPS ISA (64 bit instructions). @samp{r4000} is the default @var{cpu type} at this ISA level. + This option does not change the sizes of any of the C data types. @item -mfp32 *************** *** 3221,3230 **** @item -mint64 ! Types long and int are 64 bits. This works only if @samp{-mips3} is also ! specified. @item -mlong64 ! Type long is 64 bits, and type int is 32 bits. This works only if ! @samp{-mips3} is also specified. @item -mmips-as --- 3334,3343 ---- @item -mint64 ! Types long, int, and pointer are 64 bits. This works only if @samp{-mips3} ! is also specified. @item -mlong64 ! Types long and pointer are 64 bits, and type int is 32 bits. ! This works only if @samp{-mips3} is also specified. @item -mmips-as *************** *** 3362,3365 **** --- 3475,3484 ---- 386. Code generated for an 486 will run on a 386 and vice versa. + @item -mieee-fp + @itemx -m-no-ieee-fp + Control whether or not the compiler uses IEEE floating point + comparisons. These handle correctly the case where the result of a + comparison is unordered. + @item -msoft-float Generate output containing library calls for floating point. *************** *** 3389,3395 **** @code{sqrt} instructions for the 387. Specify this option to avoid generating those instructions. This option is the default on FreeBSD. ! @c FIXME!! What about these options listed in @node Option Summary ?? ! @c -msvr3-shlib -mieee-fp @end table --- 3508,3532 ---- @code{sqrt} instructions for the 387. Specify this option to avoid generating those instructions. This option is the default on FreeBSD. + As of revision 2.6.1, these instructions are not generated unless you + also use the @samp{-ffast-math} switch. ! @item -msvr3-shlib ! @itemx -mno-svr3-shlib ! Control whether GNU CC places uninitialized locals into @code{bss} or ! @code{data}. @samp{-msvr3-shlib} places these locals into @code{bss}. ! These options are meaningful only on System V Release 3. ! ! @item -mno-wide-multiply ! @itemx -mwide-multiply ! Control whether GNU CC uses the @code{mul} and @code{imul} that produce ! 64 bit results in @code{eax:edx} from 32 bit operands to do @code{long ! long} multiplies and 32-bit division by constants. ! ! @item -mreg-alloc=@var{regs} ! Control the default allocation order of integer registers. The ! string @var{regs} is a series of letters specifing a register. The ! supported letters are: @code{a} allocate EAX; @code{b} allocate EBX; ! @code{c} allocate ECX; @code{d} allocate EDX; @code{S} allocate ESI; ! @code{D} allocate EDI; @code{B} allocate EBP. @end table *************** *** 3433,3437 **** @item -mgas ! Unable the use of assembler directives only GAS understands. @end table --- 3570,3574 ---- @item -mgas ! Enable the use of assembler directives only GAS understands. @end table diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/jump.c gcc-2.6.1/jump.c *** gcc-2.6.0/jump.c Tue Jul 5 17:03:39 1994 --- gcc-2.6.1/jump.c Sat Oct 1 20:34:13 1994 *************** *** 662,665 **** --- 662,666 ---- if (reallabelprev == insn && condjump_p (insn)) { + next = next_real_insn (JUMP_LABEL (insn)); delete_jump (insn); changed = 1; *************** *** 2203,2210 **** } - delete_insn (next_nonnote_insn (loop_start)); - /* Mark the exit code as the virtual top of the converted loop. */ emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode); return 1; --- 2204,2211 ---- } /* Mark the exit code as the virtual top of the converted loop. */ emit_note_before (NOTE_INSN_LOOP_VTOP, exitcode); + + delete_insn (next_nonnote_insn (loop_start)); return 1; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/just-fixinc gcc-2.6.1/just-fixinc *** gcc-2.6.0/just-fixinc Sat Nov 6 03:59:25 1993 --- gcc-2.6.1/just-fixinc Tue Aug 16 16:42:50 1994 *************** *** 1,8 **** #!/bin/sh # This script exists for use after installing ! # the Solaris binaries from a distribution tape/CDROM. # Use it *after* copying the directory of binaries # to the proper installed location. ! # It runs fixinc.svr4 to correct bugs in the Solaris header files. # The corrected header files go in the GCC installation directory --- 1,12 ---- #!/bin/sh + # $Id: just-fixinc,v 1.5 1994/08/16 20:42:48 friedman Exp $ # This script exists for use after installing ! # the GCC binaries from a distribution tape/CD-ROM. # Use it *after* copying the directory of binaries # to the proper installed location. ! # It runs fixincludes (or fixinc.svr4, if appropriate) to correct bugs in ! # the system header files. ! # This script needs to be customized for each type of installation so that ! # others may run it after the installation-sans-fixincludes is completed. # The corrected header files go in the GCC installation directory *************** *** 11,15 **** # It only modifies copies in the GCC installation directory. ! installed=/opt/gnu/lib/gcc-lib/sparc-sun-solaris2/2.5.0 cd $installed/include --- 15,19 ---- # It only modifies copies in the GCC installation directory. ! installed=/opt/gnu/lib/gcc-lib/sparc-sun-solaris2/2.6.0 cd $installed/include diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/libgcc2.c gcc-2.6.1/libgcc2.c *** gcc-2.6.0/libgcc2.c Thu Jun 2 18:09:48 1994 --- gcc-2.6.1/libgcc2.c Fri Oct 21 15:13:56 1994 *************** *** 1429,1432 **** --- 1429,1433 ---- #undef NULL /* Avoid errors if stdio.h and our stddef.h mismatch. */ #include + char *ctime (); #ifdef HAVE_ATEXIT *************** *** 1996,2014 **** DO_GLOBAL_DTORS_BODY; #else ! unsigned nptrs = (unsigned HOST_WIDE_INT) __DTOR_LIST__[0]; ! unsigned i; ! ! /* Some systems place the number of pointers ! in the first word of the table. ! On other systems, that word is -1. ! In all cases, the table is null-terminated. */ ! ! /* If the length is not recorded, count up to the null. */ ! if (nptrs == -1) ! for (nptrs = 0; __DTOR_LIST__[nptrs + 1] != 0; nptrs++); ! ! /* GNU LD format. */ ! for (i = nptrs; i >= 1; i--) ! __DTOR_LIST__[i] (); #endif } --- 1997,2003 ---- DO_GLOBAL_DTORS_BODY; #else ! func_ptr *p; ! for (p = __DTOR_LIST__ + 1; *p; ) ! (*p++) (); #endif } *************** *** 2149,2151 **** --- 2138,2299 ---- #include "gbl-ctors.h" func_ptr __DTOR_LIST__[2]; + #endif + + #ifdef L_eh + typedef struct { + void *start; + void *end; + void *exception_handler; + } exception_table; + + struct exception_table_node { + exception_table *table; + void *start; + void *end; + struct exception_table_node *next; + }; + + static int except_table_pos = 0; + static void *except_pc = (void *)0; + static struct exception_table_node *exception_table_list = 0; + + static exception_table * + find_exception_table (pc) + void* pc; + { + register struct exception_table_node *table = exception_table_list; + for ( ; table != 0; table = table->next) + { + if (table->start <= pc && table->end > pc) + return table->table; + } + return 0; + } + + /* this routine takes a pc, and the address of the exception handler associated + with the closest exception table handler entry associated with that PC, + or 0 if there are no table entries the PC fits in. The algorithm works + something like this: + + while(current_entry exists) { + if(current_entry.start < pc ) + current_entry = next_entry; + else { + if(prev_entry.start <= pc && prev_entry.end > pc) { + save pointer to prev_entry; + return prev_entry.exception_handler; + } + else return 0; + } + } + return 0; + + Assuming a correctly sorted table (ascending order) this routine should + return the tighest match... + + In the advent of a tie, we have to give the last entry, as it represents + an inner block. + */ + + + void * + __find_first_exception_table_match(pc) + void *pc; + { + exception_table *table = find_exception_table (pc); + int pos = 0; + int best = 0; + if (table == 0) + return (void*)0; + #if 0 + printf("find_first_exception_table_match(): pc = %x!\n",pc); + #endif + + except_pc = pc; + + #if 0 + /* We can't do this yet, as we don't know that the table is sorted. */ + do { + ++pos; + if (table[pos].start > except_pc) + /* found the first table[pos].start > except_pc, so the previous + entry better be the one we want! */ + break; + } while(table[pos].exception_handler != (void*)-1); + + --pos; + if (table[pos].start <= except_pc && table[pos].end > except_pc) + { + except_table_pos = pos; + #if 0 + printf("find_first_eh_table_match(): found match: %x\n",table[pos].exception_handler); + #endif + return table[pos].exception_handler; + } + #else + while (table[++pos].exception_handler != (void*)-1) { + if (table[pos].start <= except_pc && table[pos].end > except_pc) + { + /* This can apply. Make sure it is better or as good as the previous + best. */ + /* The best one ends first. */ + if (best == 0 || (table[pos].end <= table[best].end + /* The best one starts last. */ + && table[pos].start >= table[best].start)) + best = pos; + } + } + if (best != 0) + return table[best].exception_handler; + #endif + + #if 0 + printf("find_first_eh_table_match(): else: returning NULL!\n"); + #endif + return (void*)0; + } + + int + __throw_type_match (const char *catch_type, const char *throw_type) + { + #if 0 + printf("__throw_type_match (): catch_type = %s, throw_type = %s\n", + catch_type, throw_type); + #endif + return strcmp (catch_type, throw_type); + } + + void + __register_exceptions (exception_table *table) + { + struct exception_table_node *node = (struct exception_table_node*) + malloc (sizeof (struct exception_table_node)); + exception_table *range = table + 1; + node->table = table; + + /* This look can be optimized away either if the table + is sorted, or if we pass in extra parameters. */ + node->start = range->start; + node->end = range->end; + for (range++ ; range->start != (void*)(-1); range++) + { + if (range->start < node->start) + node->start = range->start; + if (range->end < node->end) + node->end = range->end; + } + + node->next = exception_table_list; + exception_table_list = node; + } + #endif /* L_eh */ + + #ifdef L_pure + #define MESSAGE "pure virtual method called\n" + void + __pure_virtual () + { + write (2, MESSAGE, sizeof (MESSAGE) - 1); + _exit (-1); + } #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/listing gcc-2.6.1/listing *** gcc-2.6.0/listing Fri Nov 5 20:20:32 1993 --- gcc-2.6.1/listing Wed Aug 31 09:52:49 1994 *************** *** 4,7 **** --- 4,10 ---- # Author: Igor Metz + # Revision 1.4 94/08/26 13:58:27 coxs + # lister now guesses how to should be configured. Added elf and coff support. + # # Revision 1.3 89/12/18 13:58:27 metz # lister must now be configured before it can be used. This is done in the *************** *** 32,36 **** # i386-linux for i386 (Linux, ...) ! # uncomment the line you need: # MYSYS=mc68020 # MYSYS=mc68030 --- 35,62 ---- # i386-linux for i386 (Linux, ...) ! # Guess what kind of objects we are creating and thus what type of assembler ! # symbols to look for ! ! ex /tmp/$$.c </dev/null ! a ! main (){} ! . ! w ! q ! END ! WD=`pwd` ! cd /tmp ! gcc -c $$.c ! case "`file $$.o`" in ! *ELF*) MYSYS=elf ;; ! *COFF*|*BCS*) MYSYS=coff ;; ! *mc68k*|*M68000*) MYSYS=mc68030 ;; ! *SPARC*) MYSYS=sparc ;; ! *386*) MYSYS=i386 ;; ! esac ! rm $$.c $$.o ! cd $WD ! ! # uncomment the line you need if the above guesses incorrectly: # MYSYS=mc68020 # MYSYS=mc68030 *************** *** 39,47 **** # MYSYS=i386-linux # MYSYS=`mach` # this will work on Suns with SunOS > 4.0.0 FILENAME=$1 shift ! exec gawk -vsys=$MYSYS -voptions="$*" ' # commandline arguments: # ARGV[0] = "gawk" --- 65,78 ---- # MYSYS=i386-linux # MYSYS=`mach` # this will work on Suns with SunOS > 4.0.0 + # MYSYS=elf + # MYSYS=coff + WHOAMI=$0 + if [ $# -gt 0 ] ; then FILENAME=$1 shift + fi ! exec gawk -v whoami=$WHOAMI -vsys=$MYSYS -voptions="$*" ' # commandline arguments: # ARGV[0] = "gawk" *************** *** 69,75 **** --- 100,123 ---- if (sys == "sparc" || sys == "i386") { line_hint = "^[ \t]*\.stabn.*" + line_field = 3; + line_delimiter = ","; + line_offset = 0; } else if (sys == "mc68020" || sys == "mc68030" || sys == "i386-linux") { line_hint = "^[ \t]*\.stabd.*" + line_field = 3; + line_delimiter = ","; + line_offset = 0; + } + else if (sys == "elf") { + line_hint = "section.*\.line" + line_field = 3; + line_delimiter = "\t"; + line_offset = 0; + } + else if (sys == "coff") { + line_hint = "^[ \t]*ln" + line_field = 3; + line_delimiter = "\t"; } else { *************** *** 90,101 **** while ( getline asm_code < asm_filename > 0 ) { if ( (ignore_stabd==0) && (asm_code ~ line_hint)) { # source line hint found. Split the line into fields separated by commas. # num_of_fields is 4 for sparc, 3 for m68k ! num_of_fields = split(asm_code, fields, ",") ! newlineno = fields[3] + 0 # the line number we are looking for is field 3 if (newlineno > oldlineno) { ! while ( newlineno > c_lineno ) { ! getline c_code < c_filename c_lineno++ printf("%4d %s\n", c_lineno, c_code) --- 138,150 ---- while ( getline asm_code < asm_filename > 0 ) { if ( (ignore_stabd==0) && (asm_code ~ line_hint)) { + while ( sys == "elf" && (asm_code !~ "word" && asm_code !~ "byte") && + getline asm_code < asm_filename > 0); # source line hint found. Split the line into fields separated by commas. # num_of_fields is 4 for sparc, 3 for m68k ! num_of_fields = split(asm_code, fields, line_delimiter) ! newlineno = fields[line_field] + line_offset; if (newlineno > oldlineno) { ! while ( newlineno > c_lineno && getline c_code < c_filename > 0) { c_lineno++ printf("%4d %s\n", c_lineno, c_code) *************** *** 113,116 **** --- 162,184 ---- } } + else if ( sys == "elf" && asm_code ~ "section.*\.debug" ) { + while ( asm_code !~ "^[ \t]*[.]*previous" && + asm_code !~ "\.popsection" && + getline asm_code < asm_filename > 0 ); + if ( ! (getline asm_code < asm_filename > 0)) break; + } + else if ( sys == "coff" && asm_code ~ "^[ \t]*sdef" ) { + if ( asm_code ~ "\.bf" ) { + while ( asm_code !~ "^[ \t]*line" && + getline asm_code < asm_filename > 0 ) { + num_of_fields = split(asm_code, fields, "\t") + line_offset = fields[line_field] - 1; + } + } + while ( asm_code !~ "^[ \t]*endef" && + getline asm_code < asm_filename > 0 ) { + } + if ( ! (getline asm_code < asm_filename > 0)) break; + } printf("\t\t\t%s\n", asm_code) } *************** *** 121,125 **** function usage() { ! printf("usage: %s filename compiler-options\n", argv[0]) > "/dev/stderr" } --- 189,193 ---- function usage() { ! printf("usage: %s filename compiler-options\n", whoami) > "/dev/stderr" } *************** *** 140,144 **** cmdline = "g++" } ! else if (match(c_filename, ".c")) { cmdline = "gcc" } --- 208,212 ---- cmdline = "g++" } ! else if (match(c_filename, ".c") || match(c_filename, ".i")) { cmdline = "gcc" } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/local-alloc.c gcc-2.6.1/local-alloc.c *** gcc-2.6.0/local-alloc.c Tue Jun 14 18:03:25 1994 --- gcc-2.6.1/local-alloc.c Mon Aug 8 16:14:13 1994 *************** *** 166,169 **** --- 166,174 ---- static rtx *qty_scratch_rtx; + /* Element Q is nonzero if this quantity has been used in a SUBREG + that changes its size. */ + + static char *qty_changes_size; + /* Element Q is the register number of one pseudo register whose reg_qty value is Q, or -1 is this quantity is for a SCRATCH. This *************** *** 290,293 **** --- 295,299 ---- qty_alternate_class[qty] = reg_alternate_class (regno); qty_n_refs[qty] = reg_n_refs[regno]; + qty_changes_size[qty] = reg_changes_size[regno]; } *************** *** 379,382 **** --- 385,389 ---- qty_alternate_class[qty] = NO_REGS; qty_n_refs[qty] = 1; + qty_changes_size[qty] = 0; } *************** *** 440,443 **** --- 447,451 ---- = (enum reg_class *) alloca (max_qty * sizeof (enum reg_class)); qty_n_refs = (int *) alloca (max_qty * sizeof (int)); + qty_changes_size = (char *) alloca (max_qty * sizeof (char)); reg_qty = (int *) alloca (max_regno * sizeof (int)); *************** *** 1926,1929 **** --- 1934,1940 ---- if (reg_class_subset_p (rclass, qty_alternate_class[qty])) qty_alternate_class[qty] = rclass; + + if (reg_changes_size[reg]) + qty_changes_size[qty] = 1; } *************** *** 2107,2110 **** --- 2118,2127 ---- #else SET_HARD_REG_BIT (used, FRAME_POINTER_REGNUM); + #endif + + #ifdef CLASS_CANNOT_CHANGE_SIZE + if (qty_changes_size[qty]) + IOR_HARD_REG_SET (used, + reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]); #endif diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/loop.c gcc-2.6.1/loop.c *** gcc-2.6.0/loop.c Wed Jun 29 19:20:54 1994 --- gcc-2.6.1/loop.c Mon Jul 18 21:39:27 1994 *************** *** 1792,1797 **** contains objects other than hard registers we need to copy it. */ ! CALL_INSN_FUNCTION_USAGE (i1) = ! copy_rtx (CALL_INSN_FUNCTION_USAGE (temp)); } else --- 1792,1798 ---- contains objects other than hard registers we need to copy it. */ ! if (CALL_INSN_FUNCTION_USAGE (temp)) ! CALL_INSN_FUNCTION_USAGE (i1) = ! copy_rtx (CALL_INSN_FUNCTION_USAGE (temp)); } else *************** *** 1835,1840 **** contains objects other than hard registers we need to copy it. */ ! CALL_INSN_FUNCTION_USAGE (i1) = ! copy_rtx (CALL_INSN_FUNCTION_USAGE (p)); } else --- 1836,1842 ---- contains objects other than hard registers we need to copy it. */ ! if (CALL_INSN_FUNCTION_USAGE (p)) ! CALL_INSN_FUNCTION_USAGE (i1) = ! copy_rtx (CALL_INSN_FUNCTION_USAGE (p)); } else diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/machmode.def gcc-2.6.1/machmode.def *** gcc-2.6.0/machmode.def Mon Jul 11 19:26:26 1994 --- gcc-2.6.1/machmode.def Wed Sep 28 19:31:23 1994 *************** *** 68,72 **** Useful if a pointer is 4 bytes but has some bits that are not significant, so it is really not quite as wide as an integer. */ ! DEF_MACHMODE (PSImode, "PSI", MODE_PARTIAL_INT, 4, 4, VOIDmode) DEF_MACHMODE (SImode, "SI", MODE_INT, 4, 4, DImode) DEF_MACHMODE (PDImode, "PDI", MODE_PARTIAL_INT, 8, 8, VOIDmode) --- 68,72 ---- Useful if a pointer is 4 bytes but has some bits that are not significant, so it is really not quite as wide as an integer. */ ! DEF_MACHMODE (PSImode, "PSI", MODE_PARTIAL_INT, 4, 4, PDImode) DEF_MACHMODE (SImode, "SI", MODE_INT, 4, 4, DImode) DEF_MACHMODE (PDImode, "PDI", MODE_PARTIAL_INT, 8, 8, VOIDmode) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/md.texi gcc-2.6.1/md.texi *** gcc-2.6.0/md.texi Thu Jun 23 12:18:51 1994 --- gcc-2.6.1/md.texi Sun Aug 7 08:58:43 1994 *************** *** 1,3 **** ! @c Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. --- 1,3 ---- ! @c Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. *************** *** 1728,1732 **** @cindex @code{load_multiple} instruction pattern ! @item @code{load_multiple} Load several consecutive memory locations into consecutive registers. Operand 0 is the first of the consecutive registers, operand 1 --- 1728,1732 ---- @cindex @code{load_multiple} instruction pattern ! @item @samp{load_multiple} Load several consecutive memory locations into consecutive registers. Operand 0 is the first of the consecutive registers, operand 1 *************** *** 1752,1756 **** @cindex @samp{store_multiple} instruction pattern ! @item @code{store_multiple} Similar to @samp{load_multiple}, but store several consecutive registers into consecutive memory locations. Operand 0 is the first of the --- 1752,1756 ---- @cindex @samp{store_multiple} instruction pattern ! @item @samp{store_multiple} Similar to @samp{load_multiple}, but store several consecutive registers into consecutive memory locations. Operand 0 is the first of the diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/Object.m gcc-2.6.1/objc/Object.m *** gcc-2.6.0/objc/Object.m Wed Jul 13 06:46:14 1994 --- gcc-2.6.1/objc/Object.m Wed Sep 7 11:30:36 1994 *************** *** 195,204 **** // Indicates if the receiving class or instance conforms to the given protocol // not usually overridden by subclasses ! - (BOOL) conformsTo: (Protocol*)aProtocol { int i; struct objc_protocol_list* proto_list; ! for (proto_list = isa->protocols; proto_list; proto_list = proto_list->next) { --- 195,209 ---- // Indicates if the receiving class or instance conforms to the given protocol // not usually overridden by subclasses ! // ! // Modified 9/5/94 to always search the class object's protocol list, rather ! // than the meta class. ! ! + (BOOL) conformsTo: (Protocol*)aProtocol { int i; struct objc_protocol_list* proto_list; + id parent; ! for (proto_list = ((Class*)self)->protocols; proto_list; proto_list = proto_list->next) { *************** *** 210,217 **** } ! if ([self superClass]) ! return [[self superClass] conformsTo: aProtocol]; else return NO; } --- 215,227 ---- } ! if (parent = [self superClass]) ! return [parent conformsTo: aProtocol]; else return NO; + } + + - (BOOL) conformsTo: (Protocol*)aProtocol + { + return [[self class] conformsTo:aProtocol]; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/README gcc-2.6.1/objc/README *** gcc-2.6.0/objc/README Tue Aug 24 06:09:48 1993 --- gcc-2.6.1/objc/README Fri Sep 16 11:51:24 1994 *************** *** 1,12 **** ! [ This is probably out of date -- ask Kresten for details if needed ] ! GNU Objective C release notes for gcc 2.4 ! ***************************************** ! ! Since gcc 2.3.3 the Objective C as part of gcc has changed a lot. ! This document is to explain what has been done, and a little about ! how specific features differ from other implementations. The runtime ! has been completely rewritten. The earlier runtime had several severe bugs and was rather incomplete. The compiler has had several new features added as well. --- 1,9 ---- ! GNU Objective C notes ! ********************* ! This document is to explain what has been done, and a little about how ! specific features differ from other implementations. The runtime has ! been completely rewritten in gcc 2.4. The earlier runtime had several severe bugs and was rather incomplete. The compiler has had several new features added as well. *************** *** 65,76 **** rewritten it in Objective C, but this implementation is not part of 2.4, it is available from the GNU Objective C prerelease archive. ! There is one semathic difference worth noting concerning objects ! stored with objc_write_object_reference (aka NXWriteObjectReference). ! When these are read back in, their object is not guaranteed to be ! available until the `-awake' method is called in the object that ! requests that object. To objc_read_object you must pass a pointer to ! an id, which is valid after exit from the function calling it (like ! e.g. an instance variable). In general, you should not use objects ! read in until the -awake method is called. --- 62,73 ---- rewritten it in Objective C, but this implementation is not part of 2.4, it is available from the GNU Objective C prerelease archive. ! There is one difference worth noting concerning objects stored with ! objc_write_object_reference (aka NXWriteObjectReference). When these ! are read back in, their object is not guaranteed to be available until ! the `-awake' method is called in the object that requests that object. ! To objc_read_object you must pass a pointer to an id, which is valid ! after exit from the function calling it (like e.g. an instance ! variable). In general, you should not use objects read in until the ! -awake method is called. *************** *** 92,103 **** has been very helpful with implementation details in the compiler. - - - Prerelease Archive - ================== - - Intermediate releases, bugfixes and additional other information of - the GNU Objective C will be available from iesd.auc.dk in the - directory /pub/ObjC. --- 89,92 ---- diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/archive.c gcc-2.6.1/objc/archive.c *** gcc-2.6.0/objc/archive.c Mon Jul 11 14:02:05 1994 --- gcc-2.6.1/objc/archive.c Mon Oct 10 11:22:17 1994 *************** *** 1363,1366 **** --- 1363,1372 ---- } + static void + __objc_free (void* p) + { + free (p); + } + static int __objc_fread(FILE* file, char* data, int len) *************** *** 1428,1434 **** --- 1434,1442 ---- { node_ptr node; + struct objc_list* free_list; SEL awake_sel = sel_get_any_uid ("awake"); /* resolve object forward references */ + free_list = list_cons(NULL, NULL); for (node = hash_next (stream->object_refs, NULL); node; node = hash_next (stream->object_refs, node)) *************** *** 1440,1447 **** { *((id*)reflist->head) = object; reflist = reflist->tail; } - list_free (node->value); } /* empty object reference table */ --- 1448,1458 ---- { *((id*)reflist->head) = object; + if (list_find(&free_list, reflist) == NULL) + free_list = list_cons (reflist, free_list); reflist = reflist->tail; } } + list_mapcar (free_list, __objc_free); + list_free (free_list); /* empty object reference table */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/class.c gcc-2.6.1/objc/class.c *** gcc-2.6.0/objc/class.c Mon Jul 11 14:02:06 1994 --- gcc-2.6.1/objc/class.c Mon Aug 29 19:01:25 1994 *************** *** 133,136 **** --- 133,142 ---- } + MetaClass* + objc_get_meta_class(const char *name) + { + return objc_get_class(name)->class_pointer; + } + /* This function provides a way to enumerate all the classes in the executable. Pass *ENUM_STATE == NULL to start the enumeration. The diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/encoding.c gcc-2.6.1/objc/encoding.c *** gcc-2.6.0/objc/encoding.c Mon Jul 11 14:02:07 1994 --- gcc-2.6.1/objc/encoding.c Mon Aug 15 12:04:21 1994 *************** *** 104,107 **** --- 104,115 ---- break; + case _C_FLT: + return sizeof(float); + break; + + case _C_DBL: + return sizeof(double); + break; + case _C_PTR: case _C_ATOM: *************** *** 123,130 **** int align; while (*type != _C_STRUCT_E && *type++ != '='); /* skip "=" */ ! while (*type != _C_STRUCT_E); { align = objc_alignof_type (type); /* padd to alignment */ ! acc_size += ROUND (acc_size, align); acc_size += objc_sizeof_type (type); /* add component size */ type = objc_skip_typespec (type); /* skip component */ --- 131,138 ---- int align; while (*type != _C_STRUCT_E && *type++ != '='); /* skip "=" */ ! while (*type != _C_STRUCT_E) { align = objc_alignof_type (type); /* padd to alignment */ ! acc_size = ROUND (acc_size, align); acc_size += objc_sizeof_type (type); /* add component size */ type = objc_skip_typespec (type); /* skip component */ *************** *** 201,204 **** --- 209,220 ---- case _C_ULNG: return __alignof__(unsigned long); + break; + + case _C_FLT: + return __alignof__(float); + break; + + case _C_DBL: + return __alignof__(double); break; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/init.c gcc-2.6.1/objc/init.c *** gcc-2.6.0/objc/init.c Mon Jul 11 14:02:10 1994 --- gcc-2.6.1/objc/init.c Wed Sep 7 11:30:34 1994 *************** *** 250,254 **** --- 250,256 ---- } + #if 0 assert (protos->next == 0); /* only single ones allowed */ + #endif for(i = 0; i < protos->count; i++) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/misc.c gcc-2.6.1/objc/misc.c *** gcc-2.6.0/objc/misc.c Mon Jul 11 14:02:13 1994 --- gcc-2.6.1/objc/misc.c Fri Oct 28 19:12:54 1994 *************** *** 1,4 **** /* GNU Objective C Runtime Miscellanious ! Copyright (C) 1993 Free Software Foundation, Inc. Author: Kresten Krab Thorup --- 1,4 ---- /* GNU Objective C Runtime Miscellanious ! Copyright (C) 1993, 1994 Free Software Foundation, Inc. Author: Kresten Krab Thorup *************** *** 72,82 **** __objc_xcalloc(size_t nelem, size_t size) { ! #ifdef __alpha__ ! extern bzero (void *, size_t); ! #endif ! void* res = (void*)malloc(nelem * size); if(!res) objc_fatal("Virtual memory exhausted\n"); - bzero (res, nelem * size); return res; } --- 72,78 ---- __objc_xcalloc(size_t nelem, size_t size) { ! void* res = (void*)calloc(nelem, size); if(!res) objc_fatal("Virtual memory exhausted\n"); return res; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/objc.h gcc-2.6.1/objc/objc.h *** gcc-2.6.0/objc/objc.h Mon Jul 11 14:02:14 1994 --- gcc-2.6.1/objc/objc.h Thu Oct 6 12:24:32 1994 *************** *** 36,40 **** ** Definition of the boolean type. */ ! typedef char BOOL; #define YES (BOOL)1 #define NO (BOOL)0 --- 36,40 ---- ** Definition of the boolean type. */ ! typedef unsigned char BOOL; #define YES (BOOL)1 #define NO (BOOL)0 diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/selector.c gcc-2.6.1/objc/selector.c *** gcc-2.6.0/objc/selector.c Mon Jul 11 14:02:20 1994 --- gcc-2.6.1/objc/selector.c Mon Aug 15 11:52:00 1994 *************** *** 27,30 **** --- 27,31 ---- #include "runtime.h" #include "objc/sarray.h" + #include "encoding.h" /* Initial selector hash table size. Value doesnt matter much */ *************** *** 88,91 **** --- 89,120 ---- } + + /* Returns YES iff t1 and t2 have same method types, but we ignore + the argframe layout */ + BOOL + sel_types_match (const char* t1, const char* t2) + { + if (!t1 || !t2) + return NO; + while (*t1 && *t2) + { + if (*t1 == '+') t1++; + if (*t2 == '+') t2++; + while (isdigit(*t1)) t1++; + while (isdigit(*t2)) t2++; + /* xxx Remove these next two lines when qualifiers are put in + all selectors, not just Protocol selectors. */ + t1 = objc_skip_type_qualifiers(t1); + t2 = objc_skip_type_qualifiers(t2); + if (!*t1 && !*t2) + return YES; + if (*t1 != *t2) + return NO; + t1++; + t2++; + } + return NO; + } + /* return selector representing name */ SEL *************** *** 110,114 **** } } ! else if (! strcmp (s->sel_types, types)) { return s; --- 139,143 ---- } } ! else if (sel_types_match (s->sel_types, types)) { return s; *************** *** 151,155 **** if ((soffset_decode((sidx)selector->sel_id) > 0) && (soffset_decode((sidx)selector->sel_id) <= __objc_selector_max_index)) ! return sarray_get (__objc_selector_array, (sidx) selector->sel_id); else return 0; --- 180,184 ---- if ((soffset_decode((sidx)selector->sel_id) > 0) && (soffset_decode((sidx)selector->sel_id) <= __objc_selector_max_index)) ! return sarray_get (__objc_selector_names, (sidx) selector->sel_id); else return 0; *************** *** 206,210 **** } } ! else if (strcmp (s->sel_types, types)) { if (orig) --- 235,239 ---- } } ! else if (!strcmp (s->sel_types, types)) { if (orig) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc/sendmsg.c gcc-2.6.1/objc/sendmsg.c *** gcc-2.6.0/objc/sendmsg.c Mon Jul 11 14:02:20 1994 --- gcc-2.6.1/objc/sendmsg.c Tue Sep 20 14:37:57 1994 *************** *** 69,73 **** /* Given a class and selector, return the selector's implementation. */ ! __inline__ IMP get_imp (Class* class, SEL sel) { --- 69,74 ---- /* Given a class and selector, return the selector's implementation. */ ! __inline__ ! IMP get_imp (Class* class, SEL sel) { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/objc-act.c gcc-2.6.1/objc-act.c *** gcc-2.6.0/objc-act.c Mon Jul 11 18:14:29 1994 --- gcc-2.6.1/objc-act.c Tue Sep 27 18:30:44 1994 *************** *** 1,4 **** /* Implement classes and message passing for Objective C. ! Copyright (C) 1992, 1993 Free Software Foundation, Inc. Author: Steve Naroff. --- 1,4 ---- /* Implement classes and message passing for Objective C. ! Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. Author: Steve Naroff. *************** *** 1569,1578 **** TREE_PUBLIC (current_function_decl) = 1; - DECL_EXTERNAL (current_function_decl) = 1; finish_function (0); /* Return the name of the constructor function. */ ! return IDENTIFIER_POINTER (init_function_name); } } --- 1569,1578 ---- TREE_PUBLIC (current_function_decl) = 1; + function_decl = current_function_decl; finish_function (0); /* Return the name of the constructor function. */ ! return XSTR (XEXP (DECL_RTL (function_decl), 0), 0); } } *************** *** 1789,1792 **** --- 1789,1793 ---- nreverse (initlist)); finish_decl (UOBJC_SELECTOR_TABLE_decl, initlist, NULLT); + current_function_decl = NULLT; } } *************** *** 6448,6452 **** warn_with_method (message, mtype, method) char *message; ! char mtype; tree method; { --- 6449,6453 ---- warn_with_method (message, mtype, method) char *message; ! int mtype; tree method; { diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/obstack.c gcc-2.6.1/obstack.c *** gcc-2.6.0/obstack.c Thu Jul 14 22:18:02 1994 --- gcc-2.6.1/obstack.c Tue Nov 1 21:35:58 1994 *************** *** 32,36 **** ! #ifdef __STDC__ #define POINTER void * #else --- 32,36 ---- ! #if defined (__STDC__) && __STDC__ #define POINTER void * #else *************** *** 268,272 **** If you use it in a program, you are probably losing. */ ! #ifdef __STDC__ /* Suppress -Wmissing-prototypes warning. We don't want to declare this in obstack.h because it is just for debugging. */ --- 268,272 ---- If you use it in a program, you are probably losing. */ ! #if defined (__STDC__) && __STDC__ /* Suppress -Wmissing-prototypes warning. We don't want to declare this in obstack.h because it is just for debugging. */ *************** *** 375,379 **** Define them to simply use the corresponding macros to do the job. */ ! #ifdef __STDC__ /* These function definitions do not work with non-ANSI preprocessors; they won't pass through the macro names in parentheses. */ --- 375,379 ---- Define them to simply use the corresponding macros to do the job. */ ! #if defined (__STDC__) && __STDC__ /* These function definitions do not work with non-ANSI preprocessors; they won't pass through the macro names in parentheses. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/obstack.h gcc-2.6.1/obstack.h *** gcc-2.6.0/obstack.h Thu Jul 14 22:18:03 1994 --- gcc-2.6.1/obstack.h Tue Nov 1 21:35:59 1994 *************** *** 120,124 **** don't already have ptrdiff_t get it. */ ! #if defined (__STDC__) && ! defined (offsetof) #if defined (__GNUC__) && defined (IN_GCC) /* On Next machine, the system's stddef.h screws up if included --- 120,124 ---- don't already have ptrdiff_t get it. */ ! #if defined (__STDC__) && __STDC__ && ! defined (offsetof) #if defined (__GNUC__) && defined (IN_GCC) /* On Next machine, the system's stddef.h screws up if included *************** *** 133,137 **** #endif ! #ifdef __STDC__ #define PTR_INT_TYPE ptrdiff_t #else --- 133,137 ---- #endif ! #if defined (__STDC__) && __STDC__ #define PTR_INT_TYPE ptrdiff_t #else *************** *** 168,172 **** /* Declare the external functions we use; they are in obstack.c. */ ! #ifdef __STDC__ extern void _obstack_newchunk (struct obstack *, int); extern void _obstack_free (struct obstack *, void *); --- 168,172 ---- /* Declare the external functions we use; they are in obstack.c. */ ! #if defined (__STDC__) && __STDC__ extern void _obstack_newchunk (struct obstack *, int); extern void _obstack_free (struct obstack *, void *); *************** *** 182,186 **** #endif ! #ifdef __STDC__ /* Do the function-declarations after the structs --- 182,186 ---- #endif ! #if defined (__STDC__) && __STDC__ /* Do the function-declarations after the structs *************** *** 493,497 **** __INT_TO_PTR ((h)->temp))) ! #ifdef __STDC__ #define obstack_free(h,obj) \ ( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ --- 493,497 ---- __INT_TO_PTR ((h)->temp))) ! #if defined (__STDC__) && __STDC__ #define obstack_free(h,obj) \ ( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/optabs.c gcc-2.6.1/optabs.c *** gcc-2.6.0/optabs.c Mon Jul 11 18:35:00 1994 --- gcc-2.6.1/optabs.c Thu Oct 13 17:10:17 1994 *************** *** 118,121 **** --- 118,128 ---- rtx bzero_libfunc; + rtx eqhf2_libfunc; + rtx nehf2_libfunc; + rtx gthf2_libfunc; + rtx gehf2_libfunc; + rtx lthf2_libfunc; + rtx lehf2_libfunc; + rtx eqsf2_libfunc; rtx nesf2_libfunc; *************** *** 690,700 **** inter = 0; else - inter = expand_binop (word_mode, binoptab, outof_input, - op1, outof_target, unsignedp, next_methods); - - if (inter != 0 && inter != outof_target) - emit_move_insn (outof_target, inter); - - if (inter != 0) inter = expand_binop (word_mode, unsigned_shift, into_input, op1, 0, unsignedp, next_methods); --- 697,700 ---- *************** *** 706,709 **** --- 706,716 ---- if (inter != 0 && inter != into_target) emit_move_insn (into_target, inter); + + if (inter != 0) + inter = expand_binop (word_mode, binoptab, outof_input, + op1, outof_target, unsignedp, next_methods); + + if (inter != 0 && inter != outof_target) + emit_move_insn (outof_target, inter); } *************** *** 1261,1266 **** if (temp1 == 0 || temp2 == 0) ! res = expand_binop (submode, add_optab, temp1, temp2, ! imagr, unsignedp, methods); if (res == 0) --- 1268,1275 ---- if (temp1 == 0 || temp2 == 0) ! break; ! ! res = expand_binop (submode, add_optab, temp1, temp2, ! imagr, unsignedp, methods); if (res == 0) *************** *** 2761,2765 **** rtx libfunc = 0; ! if (mode == SFmode) switch (comparison) { --- 2770,2801 ---- rtx libfunc = 0; ! if (mode == HFmode) ! switch (comparison) ! { ! case EQ: ! libfunc = eqhf2_libfunc; ! break; ! ! case NE: ! libfunc = nehf2_libfunc; ! break; ! ! case GT: ! libfunc = gthf2_libfunc; ! break; ! ! case GE: ! libfunc = gehf2_libfunc; ! break; ! ! case LT: ! libfunc = lthf2_libfunc; ! break; ! ! case LE: ! libfunc = lehf2_libfunc; ! break; ! } ! else if (mode == SFmode) switch (comparison) { *************** *** 3238,3243 **** /* Multiply by 2 to undo the shift above. */ ! target = expand_binop (fmode, add_optab, target, target, target, 0, OPTAB_LIB_WIDEN); do_pending_stack_adjust (); emit_label (label); --- 3274,3282 ---- /* Multiply by 2 to undo the shift above. */ ! temp = expand_binop (fmode, add_optab, target, target, target, 0, OPTAB_LIB_WIDEN); + if (temp != target) + emit_move_insn (target, temp); + do_pending_stack_adjust (); emit_label (label); *************** *** 3279,3283 **** #endif ! /* No hardware instruction available; call a library rotine to convert from SImode, DImode, or TImode into SFmode, DFmode, XFmode, or TFmode. */ { --- 3318,3322 ---- #endif ! /* No hardware instruction available; call a library routine to convert from SImode, DImode, or TImode into SFmode, DFmode, XFmode, or TFmode. */ { *************** *** 3563,3566 **** --- 3602,3606 ---- { rtx insns; + rtx value; to = protect_from_queue (to, 1); *************** *** 3572,3581 **** start_sequence (); ! emit_library_call (libfcn, 1, GET_MODE (to), 1, from, GET_MODE (from)); insns = get_insns (); end_sequence (); ! emit_libcall_block (insns, target, hard_libcall_value (GET_MODE (to)), ! gen_rtx (unsignedp ? FIX : UNSIGNED_FIX, GET_MODE (to), from)); } --- 3612,3623 ---- start_sequence (); ! value = emit_library_call_value (libfcn, NULL_RTX, 1, GET_MODE (to), ! ! 1, from, GET_MODE (from)); insns = get_insns (); end_sequence (); ! emit_libcall_block (insns, target, value, ! gen_rtx (unsignedp ? UNSIGNED_FIX : FIX, GET_MODE (to), from)); } *************** *** 3957,3960 **** --- 3999,4009 ---- memset_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memset"); bzero_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bzero"); + + eqhf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqhf2"); + nehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nehf2"); + gthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gthf2"); + gehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gehf2"); + lthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lthf2"); + lehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lehf2"); eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqsf2"); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/print-tree.c gcc-2.6.1/print-tree.c *** gcc-2.6.0/print-tree.c Tue Jun 14 17:59:00 1994 --- gcc-2.6.1/print-tree.c Thu Aug 25 11:46:10 1994 *************** *** 110,117 **** if (TREE_INT_CST_HIGH (node) == 0) ! fprintf (file, " %1u", TREE_INT_CST_LOW (node)); else if (TREE_INT_CST_HIGH (node) == -1 && TREE_INT_CST_LOW (node) != 0) ! fprintf (file, " -%1u", -TREE_INT_CST_LOW (node)); else fprintf (file, --- 110,129 ---- if (TREE_INT_CST_HIGH (node) == 0) ! fprintf (file, ! #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT ! " %1u", ! #else ! " %1lu", ! #endif ! TREE_INT_CST_LOW (node)); else if (TREE_INT_CST_HIGH (node) == -1 && TREE_INT_CST_LOW (node) != 0) ! fprintf (file, ! #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT ! " -%1u", ! #else ! " -%1lu", ! #endif ! -TREE_INT_CST_LOW (node)); else fprintf (file, *************** *** 133,138 **** if (TREE_CODE (node) == REAL_CST) { ! #ifndef REAL_IS_NOT_DOUBLE ! fprintf (file, " %e", TREE_REAL_CST (node)); #else { --- 145,166 ---- if (TREE_CODE (node) == REAL_CST) { ! REAL_VALUE_TYPE d; ! ! if (TREE_OVERFLOW (node)) ! fprintf (file, " overflow"); ! ! #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) ! d = TREE_REAL_CST (node); ! if (REAL_VALUE_ISINF (d)) ! fprintf (file, " Inf"); ! else if (REAL_VALUE_ISNAN (d)) ! fprintf (file, " Nan"); ! else ! { ! char string[100]; ! ! REAL_VALUE_TO_DECIMAL (d, "%e", string); ! fprintf (file, " %s", string); ! } #else { *************** *** 144,148 **** fprintf (file, ""); } ! #endif /* REAL_IS_NOT_DOUBLE */ } --- 172,176 ---- fprintf (file, ""); } ! #endif } *************** *** 325,344 **** mode = DECL_MODE (node); if (DECL_EXTERNAL (node)) fputs (" external", file); - if (DECL_NONLOCAL (node)) - fputs (" nonlocal", file); if (DECL_REGISTER (node)) fputs (" regdecl", file); if (DECL_INLINE (node)) fputs (" inline", file); ! if (DECL_BIT_FIELD (node)) fputs (" bit-field", file); if (DECL_VIRTUAL_P (node)) fputs (" virtual", file); ! if (DECL_IGNORED_P (node)) ! fputs (" ignored", file); ! if (DECL_IN_SYSTEM_HEADER (node)) ! fputs (" in_system_header", file); if (DECL_LANG_FLAG_0 (node)) fputs (" decl_0", file); --- 353,397 ---- mode = DECL_MODE (node); + if (DECL_IGNORED_P (node)) + fputs (" ignored", file); + if (DECL_ABSTRACT (node)) + fputs (" abstract", file); + if (DECL_IN_SYSTEM_HEADER (node)) + fputs (" in_system_header", file); + if (DECL_COMMON (node)) + fputs (" common", file); if (DECL_EXTERNAL (node)) fputs (" external", file); if (DECL_REGISTER (node)) fputs (" regdecl", file); + if (DECL_PACKED (node)) + fputs (" packed", file); + if (DECL_NONLOCAL (node)) + fputs (" nonlocal", file); if (DECL_INLINE (node)) fputs (" inline", file); ! ! if (TREE_CODE (node) == TYPE_DECL && TYPE_DECL_SUPPRESS_DEBUG (node)) ! fputs (" supress-debug", file); ! ! if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN (node)) ! fputs (" built-in", file); ! if (TREE_CODE (node) == FUNCTION_DECL && DECL_BUILT_IN_NONANSI (node)) ! fputs (" built-in-nonansi", file); ! ! if (TREE_CODE (node) == FIELD_DECL && DECL_BIT_FIELD (node)) fputs (" bit-field", file); + if (TREE_CODE (node) == LABEL_DECL && DECL_TOO_LATE (node)) + fputs (" too-late", file); + if (TREE_CODE (node) == VAR_DECL && DECL_IN_TEXT_SECTION (node)) + fputs (" in-text-section", file); + if (DECL_VIRTUAL_P (node)) fputs (" virtual", file); ! if (DECL_DEFER_OUTPUT (node)) ! fputs (" defer-output", file); ! if (DECL_TRANSPARENT_UNION (node)) ! fputs (" transparent-union", file); ! if (DECL_LANG_FLAG_0 (node)) fputs (" decl_0", file); *************** *** 414,418 **** case 't': if (TYPE_NO_FORCE_BLK (node)) ! fputs (" no_force_blk", file); if (TYPE_LANG_FLAG_0 (node)) fputs (" type_0", file); --- 467,478 ---- case 't': if (TYPE_NO_FORCE_BLK (node)) ! fputs (" no-force-blk", file); ! if (TYPE_STRING_FLAG (node)) ! fputs (" string-flag", file); ! if (TYPE_NEEDS_CONSTRUCTING (node)) ! fputs (" needs-constructing", file); ! if (TYPE_TRANSPARENT_UNION (node)) ! fputs (" transparent-union", file); ! if (TYPE_LANG_FLAG_0 (node)) fputs (" type_0", file); *************** *** 559,566 **** if (TREE_INT_CST_HIGH (node) == 0) ! fprintf (file, " %1u", TREE_INT_CST_LOW (node)); else if (TREE_INT_CST_HIGH (node) == -1 && TREE_INT_CST_LOW (node) != 0) ! fprintf (file, " -%1u", -TREE_INT_CST_LOW (node)); else fprintf (file, --- 619,638 ---- if (TREE_INT_CST_HIGH (node) == 0) ! fprintf (file, ! #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT ! " %1u", ! #else ! " %1lu", ! #endif ! TREE_INT_CST_LOW (node)); else if (TREE_INT_CST_HIGH (node) == -1 && TREE_INT_CST_LOW (node) != 0) ! fprintf (file, ! #if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_INT ! " -%1u", ! #else ! " -%1lu", ! #endif ! -TREE_INT_CST_LOW (node)); else fprintf (file, *************** *** 582,596 **** case REAL_CST: - #ifndef REAL_IS_NOT_DOUBLE - fprintf (file, " %e", TREE_REAL_CST (node)); - #else { ! char *p = (char *) &TREE_REAL_CST (node); ! fprintf (file, " 0x"); ! for (i = 0; i < sizeof TREE_REAL_CST (node); i++) ! fprintf (file, "%02x", *p++); ! fprintf (file, ""); } - #endif /* REAL_IS_NOT_DOUBLE */ break; --- 654,687 ---- case REAL_CST: { ! REAL_VALUE_TYPE d; ! ! if (TREE_OVERFLOW (node)) ! fprintf (file, " overflow"); ! ! #if !defined(REAL_IS_NOT_DOUBLE) || defined(REAL_ARITHMETIC) ! d = TREE_REAL_CST (node); ! if (REAL_VALUE_ISINF (d)) ! fprintf (file, " Inf"); ! else if (REAL_VALUE_ISNAN (d)) ! fprintf (file, " Nan"); ! else ! { ! char string[100]; ! ! REAL_VALUE_TO_DECIMAL (d, "%e", string); ! fprintf (file, " %s", string); ! } ! #else ! { ! int i; ! unsigned char *p = (unsigned char *) &TREE_REAL_CST (node); ! fprintf (file, " 0x"); ! for (i = 0; i < sizeof TREE_REAL_CST (node); i++) ! fprintf (file, "%02x", *p++); ! fprintf (file, ""); ! } ! #endif } break; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/protoize.c gcc-2.6.1/protoize.c *** gcc-2.6.0/protoize.c Mon Jul 11 15:10:20 1994 --- gcc-2.6.1/protoize.c Tue Oct 4 23:17:40 1994 *************** *** 122,125 **** --- 122,126 ---- #include #include + #include #else /* !defined(POSIX) */ *************** *** 133,136 **** --- 134,150 ---- #define O_WRONLY 1 + #ifndef WIFSIGNALED + #define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f) + #endif + #ifndef WTERMSIG + #define WTERMSIG(S) ((S) & 0x7f) + #endif + #ifndef WIFEXITED + #define WIFEXITED(S) (((S) & 0xff) == 0) + #endif + #ifndef WEXITSTATUS + #define WEXITSTATUS(S) (((S) & 0xff00) >> 8) + #endif + /* Declaring stat or __flsbuf with a prototype causes conflicts with system headers on some systems. */ *************** *** 2091,2104 **** return 0; } ! if ((wait_status & 0x7F) != 0) { fprintf (stderr, "%s: subprocess got fatal signal %d", ! pname, (wait_status & 0x7F)); return 0; } ! if (((wait_status & 0xFF00) >> 8) != 0) { fprintf (stderr, "%s: %s exited with status %d\n", ! pname, base_filename, ((wait_status & 0xFF00) >> 8)); return 0; } --- 2105,2118 ---- return 0; } ! if (WIFSIGNALED (wait_status)) { fprintf (stderr, "%s: subprocess got fatal signal %d", ! pname, WTERMSIG (wait_status)); return 0; } ! if (WIFEXITED (wait_status) && WEXITSTATUS (wait_status) != 0) { fprintf (stderr, "%s: %s exited with status %d\n", ! pname, base_filename, WEXITSTATUS (wait_status)); return 0; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/recog.c gcc-2.6.1/recog.c *** gcc-2.6.0/recog.c Sun Mar 6 15:17:42 1994 --- gcc-2.6.1/recog.c Mon Oct 17 11:28:23 1994 *************** *** 1719,1725 **** case 'p': /* p is used for address_operands. When we are called by ! gen_input_reload, no one will have checked that the ! address is strictly valid, i.e., that all pseudos ! requiring hard regs have gotten them. */ if (strict <= 0 || (strict_memory_address_p --- 1719,1725 ---- case 'p': /* p is used for address_operands. When we are called by ! gen_reload, no one will have checked that the address is ! strictly valid, i.e., that all pseudos requiring hard regs ! have gotten them. */ if (strict <= 0 || (strict_memory_address_p diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/reg-stack.c gcc-2.6.1/reg-stack.c *** gcc-2.6.0/reg-stack.c Fri Jun 24 14:42:52 1994 --- gcc-2.6.1/reg-stack.c Sun Oct 2 15:17:11 1994 *************** *** 1592,1596 **** NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED; NOTE_SOURCE_FILE (insn) = 0; - INSN_DELETED_P (insn) = 1; } --- 1592,1595 ---- *************** *** 2582,2586 **** REG_UNUSED will already have been dealt with, so just return. */ ! if (INSN_DELETED_P (insn)) return; --- 2581,2585 ---- REG_UNUSED will already have been dealt with, so just return. */ ! if (GET_CODE (insn) == NOTE) return; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/regs.h gcc-2.6.1/regs.h *** gcc-2.6.0/regs.h Tue Apr 19 23:23:08 1994 --- gcc-2.6.1/regs.h Sun Aug 7 08:50:23 1994 *************** *** 1,4 **** /* Define per-register tables for data flow info and register allocation. ! Copyright (C) 1987, 1993 Free Software Foundation, Inc. This file is part of GNU CC. --- 1,4 ---- /* Define per-register tables for data flow info and register allocation. ! Copyright (C) 1987, 1993, 1994 Free Software Foundation, Inc. This file is part of GNU CC. *************** *** 53,56 **** --- 53,62 ---- extern short *reg_n_deaths; + + /* Indexed by N; says whether a psuedo register N was ever used + within a SUBREG that changes the size of the reg. Some machines prohibit + such objects to be in certain (usually floating-point) registers. */ + + extern char *reg_changes_size; /* Get the number of consecutive words required to hold pseudo-reg N. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/reload.c gcc-2.6.1/reload.c *** gcc-2.6.0/reload.c Tue Jul 12 15:07:50 1994 --- gcc-2.6.1/reload.c Thu Oct 27 13:04:09 1994 *************** *** 87,90 **** --- 87,91 ---- #define REG_OK_STRICT + #include #include "config.h" #include "rtl.h" *************** *** 778,783 **** register is a pseudo, also reload the inside expression. For machines that extend byte loads, do this for any SUBREG of a pseudo ! where both M1 and M2 are a word or smaller unless they are the same ! size. Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where either M1 is not valid for R or M2 is wider than a word but we only --- 779,784 ---- register is a pseudo, also reload the inside expression. For machines that extend byte loads, do this for any SUBREG of a pseudo ! where both M1 and M2 are a word or smaller, M1 is wider than M2, and ! M2 is an integral mode that gets extended when loaded. Similar issue for (SUBREG:M1 (REG:M2 ...) ...) for a hard register R where either M1 is not valid for R or M2 is wider than a word but we only *************** *** 793,798 **** Also reload the inner expression if it does not require a secondary ! reload but the SUBREG does. */ if (in != 0 && GET_CODE (in) == SUBREG && (CONSTANT_P (SUBREG_REG (in)) --- 794,803 ---- Also reload the inner expression if it does not require a secondary ! reload but the SUBREG does. + Finally, reload the inner expression if it is a register that is in + the class whose registers cannot be referenced in a different size + and M1 is not the same size as M2. */ + if (in != 0 && GET_CODE (in) == SUBREG && (CONSTANT_P (SUBREG_REG (in)) *************** *** 809,813 **** <= UNITS_PER_WORD) && (GET_MODE_SIZE (inmode) ! != GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))))) #endif )) --- 814,820 ---- <= UNITS_PER_WORD) && (GET_MODE_SIZE (inmode) ! > GET_MODE_SIZE (GET_MODE (SUBREG_REG (in)))) ! && INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (in))) ! && LOAD_EXTEND_OP (GET_MODE (SUBREG_REG (in))) != NIL) #endif )) *************** *** 834,837 **** --- 841,853 ---- == NO_REGS)) #endif + #ifdef CLASS_CANNOT_CHANGE_SIZE + || (GET_CODE (SUBREG_REG (in)) == REG + && REGNO (SUBREG_REG (in)) < FIRST_PSEUDO_REGISTER + && (TEST_HARD_REG_BIT + (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], + REGNO (SUBREG_REG (in)))) + && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (in))) + != GET_MODE_SIZE (inmode))) + #endif )) { *************** *** 886,898 **** || GET_CODE (SUBREG_REG (out)) == MEM) && ((GET_MODE_SIZE (outmode) ! > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))) ! #ifdef LOAD_EXTEND_OP ! || (GET_MODE_SIZE (outmode) <= UNITS_PER_WORD ! && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) ! <= UNITS_PER_WORD) ! && (GET_MODE_SIZE (outmode) ! != GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))))) ! #endif ! )) || (GET_CODE (SUBREG_REG (out)) == REG && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER --- 902,906 ---- || GET_CODE (SUBREG_REG (out)) == MEM) && ((GET_MODE_SIZE (outmode) ! > GET_MODE_SIZE (GET_MODE (SUBREG_REG (out)))))) || (GET_CODE (SUBREG_REG (out)) == REG && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER *************** *** 914,917 **** --- 922,934 ---- == NO_REGS)) #endif + #ifdef CLASS_CANNOT_CHANGE_SIZE + || (GET_CODE (SUBREG_REG (out)) == REG + && REGNO (SUBREG_REG (out)) < FIRST_PSEUDO_REGISTER + && (TEST_HARD_REG_BIT + (reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE], + REGNO (SUBREG_REG (out)))) + && (GET_MODE_SIZE (GET_MODE (SUBREG_REG (out))) + != GET_MODE_SIZE (outmode))) + #endif )) { *************** *** 1882,1886 **** int n_occurrences (c, s) ! char c; char *s; { --- 1899,1903 ---- int n_occurrences (c, s) ! int c; char *s; { *************** *** 2402,2406 **** else if (code == PLUS) /* We can get a PLUS as an "operand" as a result of ! register elimination. See eliminate_regs and gen_input_reload. */ substed_operand[i] = recog_operand[i] = *recog_operand_loc[i] = find_reloads_toplev (recog_operand[i], i, address_type[i], --- 2419,2423 ---- else if (code == PLUS) /* We can get a PLUS as an "operand" as a result of ! register elimination. See eliminate_regs and gen_reload. */ substed_operand[i] = recog_operand[i] = *recog_operand_loc[i] = find_reloads_toplev (recog_operand[i], i, address_type[i], *************** *** 2551,2560 **** /* We must force a reload of paradoxical SUBREGs of a MEM because the alignment of the inner value ! may not be enough to do the outer reference. On machines that extend byte operations and we have a ! SUBREG where both the inner and outer modes are different ! size but no wider than a word, combine.c has made ! assumptions about the behavior of the machine in such register access. If the data is, in fact, in memory we must always load using the size assumed to be in the --- 2568,2580 ---- /* We must force a reload of paradoxical SUBREGs of a MEM because the alignment of the inner value ! may not be enough to do the outer reference. On ! big-endian machines, it may also reference outside ! the object. On machines that extend byte operations and we have a ! SUBREG where both the inner and outer modes are no wider ! than a word and the inner mode is narrower, is integral, ! and gets extended when loaded from memory, combine.c has ! made assumptions about the behavior of the machine in such register access. If the data is, in fact, in memory we must always load using the size assumed to be in the *************** *** 2568,2571 **** --- 2588,2592 ---- && (GET_MODE_SIZE (operand_mode[i]) > GET_MODE_SIZE (GET_MODE (operand)))) + || (GET_CODE (operand) == MEM && BYTES_BIG_ENDIAN) #ifdef LOAD_EXTEND_OP || (GET_MODE_SIZE (operand_mode[i]) <= UNITS_PER_WORD *************** *** 2573,2577 **** <= UNITS_PER_WORD) && (GET_MODE_SIZE (operand_mode[i]) ! != GET_MODE_SIZE (GET_MODE (operand)))) #endif )) --- 2594,2600 ---- <= UNITS_PER_WORD) && (GET_MODE_SIZE (operand_mode[i]) ! > GET_MODE_SIZE (GET_MODE (operand))) ! && INTEGRAL_MODE_P (GET_MODE (operand)) ! && LOAD_EXTEND_OP (GET_MODE (operand)) != NIL) #endif )) *************** *** 2709,2713 **** /* All necessary reloads for an address_operand were handled in find_reloads_address. */ ! this_alternative[i] = (int) ALL_REGS; win = 1; break; --- 2732,2736 ---- /* All necessary reloads for an address_operand were handled in find_reloads_address. */ ! this_alternative[i] = (int) BASE_REG_CLASS; win = 1; break; *************** *** 4234,4243 **** { *loc = ad = gen_rtx (PLUS, GET_MODE (ad), plus_constant (XEXP (XEXP (ad, 0), 1), ! INTVAL (XEXP (ad, 1))), ! XEXP (XEXP (ad, 0), 0)); ! find_reloads_address_part (XEXP (ad, 0), &XEXP (ad, 0), BASE_REG_CLASS, GET_MODE (ad), opnum, type, ind_levels); ! find_reloads_address_1 (XEXP (ad, 1), 1, &XEXP (ad, 1), opnum, type, 0); return 1; --- 4257,4266 ---- { *loc = ad = gen_rtx (PLUS, GET_MODE (ad), + XEXP (XEXP (ad, 0), 0), plus_constant (XEXP (XEXP (ad, 0), 1), ! INTVAL (XEXP (ad, 1)))); ! find_reloads_address_part (XEXP (ad, 1), &XEXP (ad, 1), BASE_REG_CLASS, GET_MODE (ad), opnum, type, ind_levels); ! find_reloads_address_1 (XEXP (ad, 0), 1, &XEXP (ad, 0), opnum, type, 0); return 1; *************** *** 5648,5650 **** --- 5671,5780 ---- return 0; + } + + static char *reload_when_needed_name[] = + { + "RELOAD_FOR_INPUT", + "RELOAD_FOR_OUTPUT", + "RELOAD_FOR_INSN", + "RELOAD_FOR_INPUT_ADDRESS", + "RELOAD_FOR_OUTPUT_ADDRESS", + "RELOAD_FOR_OPERAND_ADDRESS", + "RELOAD_FOR_OPADDR_ADDR", + "RELOAD_OTHER", + "RELOAD_FOR_OTHER_ADDRESS" + }; + + static char *reg_class_names[] = REG_CLASS_NAMES; + + /* This function is used to print the variables set by 'find_reloads' */ + + void + debug_reload() + { + int r; + + fprintf (stderr, "\nn_reloads = %d\n", n_reloads); + + for (r = 0; r < n_reloads; r++) + { + fprintf (stderr, "\nRELOAD %d\n", r); + + if (reload_in[r]) + { + fprintf (stderr, "\nreload_in (%s) = ", mode_name[reload_inmode[r]]); + debug_rtx (reload_in[r]); + } + + if (reload_out[r]) + { + fprintf (stderr, "\nreload_out (%s) = ", mode_name[reload_outmode[r]]); + debug_rtx (reload_out[r]); + } + + fprintf (stderr, "%s, ", reg_class_names[(int) reload_reg_class[r]]); + + fprintf (stderr, "%s (opnum = %d)", reload_when_needed_name[(int)reload_when_needed[r]], + reload_opnum[r]); + + if (reload_optional[r]) + fprintf (stderr, ", optional"); + + if (reload_in[r]) + fprintf (stderr, ", inc by %d\n", reload_inc[r]); + + if (reload_nocombine[r]) + fprintf (stderr, ", can combine", reload_nocombine[r]); + + if (reload_secondary_p[r]) + fprintf (stderr, ", secondary_reload_p"); + + if (reload_in_reg[r]) + { + fprintf (stderr, "\nreload_in_reg:\t\t\t"); + debug_rtx (reload_in_reg[r]); + } + + if (reload_reg_rtx[r]) + { + fprintf (stderr, "\nreload_reg_rtx:\t\t\t"); + debug_rtx (reload_reg_rtx[r]); + } + + if (reload_secondary_in_reload[r] != -1) + { + fprintf (stderr, "\nsecondary_in_reload = "); + fprintf (stderr, "%d ", reload_secondary_in_reload[r]); + } + + if (reload_secondary_out_reload[r] != -1) + { + if (reload_secondary_in_reload[r] != -1) + fprintf (stderr, ", secondary_out_reload = "); + else + fprintf (stderr, "\nsecondary_out_reload = "); + + fprintf (stderr, "%d", reload_secondary_out_reload[r]); + } + + + if (reload_secondary_in_icode[r] != CODE_FOR_nothing) + { + fprintf (stderr, "\nsecondary_in_icode = "); + fprintf (stderr, "%s", insn_name[r]); + } + + if (reload_secondary_out_icode[r] != CODE_FOR_nothing) + { + if (reload_secondary_in_icode[r] != CODE_FOR_nothing) + fprintf (stderr, ", secondary_out_icode = "); + else + fprintf (stderr, "\nsecondary_out_icode = "); + + fprintf (stderr, "%s ", insn_name[r]); + } + fprintf (stderr, "\n"); + } + + fprintf (stderr, "\n"); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/reload.h gcc-2.6.1/reload.h *** gcc-2.6.0/reload.h Tue Jun 14 17:34:40 1994 --- gcc-2.6.1/reload.h Mon Oct 17 11:28:49 1994 *************** *** 217,223 **** extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx)); ! /* Emit code to perform an input reload of IN to RELOADREG. IN is from ! operand OPNUM with reload type TYPE. */ ! extern rtx gen_input_reload PROTO((rtx, rtx, int, enum reload_type)); /* Functions in caller-save.c: */ --- 217,224 ---- extern rtx eliminate_regs PROTO((rtx, enum machine_mode, rtx)); ! /* Emit code to perform a reload from IN (which may be a reload register) to ! OUT (which may also be a reload register). IN or OUT is from operand ! OPNUM with reload type TYPE. */ ! extern rtx gen_reload PROTO((rtx, rtx, int, enum reload_type)); /* Functions in caller-save.c: */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/reload1.c gcc-2.6.1/reload1.c *** gcc-2.6.0/reload1.c Sun Jul 10 08:11:56 1994 --- gcc-2.6.1/reload1.c Thu Oct 27 18:57:09 1994 *************** *** 328,332 **** static int possible_group_p PROTO((int, int *)); static void count_possible_groups PROTO((int *, enum machine_mode *, ! int *)); static int modes_equiv_for_class_p PROTO((enum machine_mode, enum machine_mode, --- 328,332 ---- static int possible_group_p PROTO((int, int *)); static void count_possible_groups PROTO((int *, enum machine_mode *, ! int *, int)); static int modes_equiv_for_class_p PROTO((enum machine_mode, enum machine_mode, *************** *** 1154,1158 **** && ! modes_equiv_for_class_p (allocate_mode, other_mode, class)) ! abort (); } else if (size == 1) --- 1154,1159 ---- && ! modes_equiv_for_class_p (allocate_mode, other_mode, class)) ! fatal_insn ("Two dissimilar machine modes both need groups of consecutive regs of the same class", ! insn); } else if (size == 1) *************** *** 1350,1360 **** /* Now count extra regs if there might be a conflict with ! the return value register. - ??? This is not quite correct because we don't properly - handle the case of groups, but if we end up doing - something wrong, it either will end up not mattering or - we will abort elsewhere. */ - for (r = regno; r < regno + nregs; r++) if (spill_reg_order[r] >= 0) --- 1351,1356 ---- /* Now count extra regs if there might be a conflict with ! the return value register. */ for (r = regno; r < regno + nregs; r++) if (spill_reg_order[r] >= 0) *************** *** 1362,1366 **** if (TEST_HARD_REG_BIT (reg_class_contents[i], r)) { ! if (basic_needs[i] > 0 || basic_groups[i] > 0) { enum reg_class *p; --- 1358,1362 ---- if (TEST_HARD_REG_BIT (reg_class_contents[i], r)) { ! if (basic_needs[i] > 0) { enum reg_class *p; *************** *** 1371,1374 **** --- 1367,1379 ---- insn_needs.other.regs[0][(int) *p++]++; } + if (basic_groups[i] > 0) + { + enum reg_class *p; + + insn_needs.other.groups[i]++; + p = reg_class_superclasses[i]; + while (*p != LIM_REG_CLASSES) + insn_needs.other.groups[(int) *p++]++; + } } } *************** *** 1604,1608 **** count them now. Maybe we don't really need to spill another group. */ ! count_possible_groups (group_size, group_mode, max_groups); if (max_groups[class] <= 0) --- 1609,1614 ---- count them now. Maybe we don't really need to spill another group. */ ! count_possible_groups (group_size, group_mode, max_groups, ! class); if (max_groups[class] <= 0) *************** *** 2064,2077 **** } ! /* Count any groups that can be formed from the registers recently spilled. ! This is done class by class, in order of ascending class number. */ static void ! count_possible_groups (group_size, group_mode, max_groups) int *group_size; enum machine_mode *group_mode; int *max_groups; { ! int i; /* Now find all consecutive groups of spilled registers and mark each group off against the need for such groups. --- 2070,2086 ---- } ! /* Count any groups of CLASS that can be formed from the registers recently ! spilled. */ static void ! count_possible_groups (group_size, group_mode, max_groups, class) int *group_size; enum machine_mode *group_mode; int *max_groups; + int class; { ! HARD_REG_SET new; ! int i, j; ! /* Now find all consecutive groups of spilled registers and mark each group off against the need for such groups. *************** *** 2078,2129 **** But don't count them against ordinary need, yet. */ ! for (i = 0; i < N_REG_CLASSES; i++) ! if (group_size[i] > 1) { ! HARD_REG_SET new; ! int j; ! CLEAR_HARD_REG_SET (new); ! /* Make a mask of all the regs that are spill regs in class I. */ ! for (j = 0; j < n_spills; j++) ! if (TEST_HARD_REG_BIT (reg_class_contents[i], spill_regs[j]) ! && ! TEST_HARD_REG_BIT (counted_for_groups, spill_regs[j]) ! && ! TEST_HARD_REG_BIT (counted_for_nongroups, ! spill_regs[j])) ! SET_HARD_REG_BIT (new, spill_regs[j]); ! ! /* Find each consecutive group of them. */ ! for (j = 0; j < FIRST_PSEUDO_REGISTER && max_groups[i] > 0; j++) ! if (TEST_HARD_REG_BIT (new, j) ! && j + group_size[i] <= FIRST_PSEUDO_REGISTER ! /* Next line in case group-mode for this class ! demands an even-odd pair. */ ! && HARD_REGNO_MODE_OK (j, group_mode[i])) ! { ! int k; ! for (k = 1; k < group_size[i]; k++) ! if (! TEST_HARD_REG_BIT (new, j + k)) ! break; ! if (k == group_size[i]) ! { ! /* We found a group. Mark it off against this class's ! need for groups, and against each superclass too. */ ! register enum reg_class *p; ! max_groups[i]--; ! p = reg_class_superclasses[i]; ! while (*p != LIM_REG_CLASSES) ! max_groups[(int) *p++]--; ! /* Don't count these registers again. */ ! for (k = 0; k < group_size[i]; k++) ! SET_HARD_REG_BIT (counted_for_groups, j + k); ! } ! /* Skip to the last reg in this group. When j is incremented ! above, it will then point to the first reg of the next ! possible group. */ ! j += k - 1; ! } } - } --- 2087,2132 ---- But don't count them against ordinary need, yet. */ ! if (group_size[class] == 0) ! return; ! ! CLEAR_HARD_REG_SET (new); ! ! /* Make a mask of all the regs that are spill regs in class I. */ ! for (i = 0; i < n_spills; i++) ! if (TEST_HARD_REG_BIT (reg_class_contents[class], spill_regs[i]) ! && ! TEST_HARD_REG_BIT (counted_for_groups, spill_regs[i]) ! && ! TEST_HARD_REG_BIT (counted_for_nongroups, spill_regs[i])) ! SET_HARD_REG_BIT (new, spill_regs[i]); ! ! /* Find each consecutive group of them. */ ! for (i = 0; i < FIRST_PSEUDO_REGISTER && max_groups[class] > 0; i++) ! if (TEST_HARD_REG_BIT (new, i) ! && i + group_size[class] <= FIRST_PSEUDO_REGISTER ! && HARD_REGNO_MODE_OK (i, group_mode[class])) { ! for (j = 1; j < group_size[class]; j++) ! if (! TEST_HARD_REG_BIT (new, i + j)) ! break; ! if (j == group_size[class]) ! { ! /* We found a group. Mark it off against this class's need for ! groups, and against each superclass too. */ ! register enum reg_class *p; ! ! max_groups[class]--; ! p = reg_class_superclasses[class]; ! while (*p != LIM_REG_CLASSES) ! max_groups[(int) *p++]--; ! ! /* Don't count these registers again. */ ! for (j = 0; j < group_size[class]; j++) ! SET_HARD_REG_BIT (counted_for_groups, i + j); ! } ! /* Skip to the last reg in this group. When i is incremented above, ! it will then point to the first reg of the next possible group. */ ! i += j - 1; } } *************** *** 2166,2170 **** error_for_asm (insn, "`asm' needs too many reloads"); else ! abort (); } --- 2169,2173 ---- error_for_asm (insn, "`asm' needs too many reloads"); else ! fatal_insn ("Unable to find a register to spill.", insn); } *************** *** 2887,2895 **** /* If we didn't change anything, we must retain the pseudo. */ if (new == reg_equiv_memory_loc[REGNO (SUBREG_REG (x))]) ! new = XEXP (x, 0); else ! /* Otherwise, ensure NEW isn't shared in case we have to reload ! it. */ ! new = copy_rtx (new); } else --- 2890,2907 ---- /* If we didn't change anything, we must retain the pseudo. */ if (new == reg_equiv_memory_loc[REGNO (SUBREG_REG (x))]) ! new = SUBREG_REG (x); else ! { ! /* Otherwise, ensure NEW isn't shared in case we have to reload ! it. */ ! new = copy_rtx (new); ! ! /* In this case, we must show that the pseudo is used in this ! insn so that delete_output_reload will do the right thing. */ ! if (insn != 0 && GET_CODE (insn) != EXPR_LIST ! && GET_CODE (insn) != INSN_LIST) ! emit_insn_before (gen_rtx (USE, VOIDmode, SUBREG_REG (x)), ! insn); ! } } else *************** *** 2908,2912 **** && ! (GET_CODE (SUBREG_REG (x)) == REG && GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD ! && GET_MODE_SIZE (GET_MODE (new)) <= UNITS_PER_WORD) #endif ) --- 2920,2928 ---- && ! (GET_CODE (SUBREG_REG (x)) == REG && GET_MODE_SIZE (GET_MODE (x)) <= UNITS_PER_WORD ! && GET_MODE_SIZE (GET_MODE (new)) <= UNITS_PER_WORD ! && (GET_MODE_SIZE (GET_MODE (x)) ! > GET_MODE_SIZE (GET_MODE (new))) ! && INTEGRAL_MODE_P (GET_MODE (new)) ! && LOAD_EXTEND_OP (GET_MODE (new)) != NIL) #endif ) *************** *** 3669,3672 **** --- 3685,3689 ---- /* Used in reload_as_needed to sort the spilled regs. */ + static int compare_spill_regs (r1, r2) *************** *** 3673,3677 **** short *r1, *r2; { ! return *r1 < *r2 ? -1: 1; } --- 3690,3694 ---- short *r1, *r2; { ! return *r1 - *r2; } *************** *** 3841,3845 **** && (reload_in[i] != 0 || reload_out[i] != 0 || reload_secondary_p[i] != 0)) ! abort (); /* Now compute which reload regs to reload them into. Perhaps --- 3858,3862 ---- && (reload_in[i] != 0 || reload_out[i] != 0 || reload_secondary_p[i] != 0)) ! fatal_insn ("Non-optional registers need a spill register", insn); /* Now compute which reload regs to reload them into. Perhaps *************** *** 4837,4841 **** if (asm_noperands (PATTERN (insn)) < 0) /* It's the compiler's fault. */ ! abort (); /* It's the user's fault; the operand's mode and constraint --- 4854,4858 ---- if (asm_noperands (PATTERN (insn)) < 0) /* It's the compiler's fault. */ ! fatal_insn ("Could not find a spill register", insn); /* It's the user's fault; the operand's mode and constraint *************** *** 5629,5633 **** register rtx old; rtx oldequiv_reg = 0; ! rtx store_insn = 0; old = reload_in[j]; --- 5646,5652 ---- register rtx old; rtx oldequiv_reg = 0; ! ! if (reload_spill_index[j] >= 0) ! new_spill_reg_store[reload_spill_index[j]] = 0; old = reload_in[j]; *************** *** 6011,6017 **** } else ! gen_input_reload (second_reload_reg, oldequiv, ! reload_opnum[j], ! reload_when_needed[j]); oldequiv = second_reload_reg; --- 6030,6036 ---- } else ! gen_reload (second_reload_reg, oldequiv, ! reload_opnum[j], ! reload_when_needed[j]); oldequiv = second_reload_reg; *************** *** 6022,6027 **** if (! special && ! rtx_equal_p (reloadreg, oldequiv)) ! gen_input_reload (reloadreg, oldequiv, reload_opnum[j], ! reload_when_needed[j]); #if defined(SECONDARY_INPUT_RELOAD_CLASS) && defined(PRESERVE_DEATH_INFO_REGNO_P) --- 6041,6046 ---- if (! special && ! rtx_equal_p (reloadreg, oldequiv)) ! gen_reload (reloadreg, oldequiv, reload_opnum[j], ! reload_when_needed[j]); #if defined(SECONDARY_INPUT_RELOAD_CLASS) && defined(PRESERVE_DEATH_INFO_REGNO_P) *************** *** 6247,6251 **** if (asm_noperands (PATTERN (insn)) < 0) /* It's the compiler's fault. */ ! abort (); error_for_asm (insn, "output operand is constant in `asm'"); /* Prevent crash--use something we know is valid. */ --- 6266,6270 ---- if (asm_noperands (PATTERN (insn)) < 0) /* It's the compiler's fault. */ ! fatal_insn ("VOIDmode on an output", insn); error_for_asm (insn, "output operand is constant in `asm'"); /* Prevent crash--use something we know is valid. */ *************** *** 6260,6264 **** /* If we need two reload regs, set RELOADREG to the intermediate ! one, since it will be stored into OUT. We might need a secondary register only for an input reload, so check again here. */ --- 6279,6283 ---- /* If we need two reload regs, set RELOADREG to the intermediate ! one, since it will be stored into OLD. We might need a secondary register only for an input reload, so check again here. */ *************** *** 6290,6297 **** /* See if we need both a scratch and intermediate reload register. */ int secondary_reload = reload_secondary_out_reload[j]; enum insn_code tertiary_icode = reload_secondary_out_icode[secondary_reload]; - rtx pat; if (GET_MODE (reloadreg) != mode) --- 6309,6316 ---- /* See if we need both a scratch and intermediate reload register. */ + int secondary_reload = reload_secondary_out_reload[j]; enum insn_code tertiary_icode = reload_secondary_out_icode[secondary_reload]; if (GET_MODE (reloadreg) != mode) *************** *** 6302,6343 **** rtx third_reloadreg = reload_reg_rtx[reload_secondary_out_reload[secondary_reload]]; ! pat = (GEN_FCN (tertiary_icode) ! (reloadreg, second_reloadreg, third_reloadreg)); ! } ! #ifdef SECONDARY_MEMORY_NEEDED ! /* If we need a memory location to do the move, do it that way. */ ! else if (GET_CODE (reloadreg) == REG ! && REGNO (reloadreg) < FIRST_PSEUDO_REGISTER ! && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (reloadreg)), ! REGNO_REG_CLASS (REGNO (second_reloadreg)), ! GET_MODE (second_reloadreg))) ! { ! /* Get the memory to use and rewrite both registers ! to its mode. */ ! rtx loc ! = get_secondary_mem (reloadreg, ! GET_MODE (second_reloadreg), ! reload_opnum[j], ! reload_when_needed[j]); ! rtx tmp_reloadreg; ! ! if (GET_MODE (loc) != GET_MODE (second_reloadreg)) ! second_reloadreg = gen_rtx (REG, GET_MODE (loc), ! REGNO (second_reloadreg)); ! ! if (GET_MODE (loc) != GET_MODE (reloadreg)) ! tmp_reloadreg = gen_rtx (REG, GET_MODE (loc), ! REGNO (reloadreg)); ! else ! tmp_reloadreg = reloadreg; ! ! emit_move_insn (loc, second_reloadreg); ! pat = gen_move_insn (tmp_reloadreg, loc); } ! #endif else ! pat = gen_move_insn (reloadreg, second_reloadreg); ! emit_insn (pat); } } --- 6321,6342 ---- rtx third_reloadreg = reload_reg_rtx[reload_secondary_out_reload[secondary_reload]]; ! ! /* Copy primary reload reg to secondary reload reg. ! (Note that these have been swapped above, then ! secondary reload reg to OLD using our insn. */ ! ! gen_reload (reloadreg, second_reloadreg, ! reload_opnum[j], reload_when_needed[j]); ! emit_insn ((GEN_FCN (tertiary_icode) ! (real_old, reloadreg, third_reloadreg))); ! special = 1; } ! else ! /* Copy between the reload regs here and then to ! OUT later. */ ! gen_reload (reloadreg, second_reloadreg, ! reload_opnum[j], reload_when_needed[j]); } } *************** *** 6347,6378 **** /* Output the last reload insn. */ if (! special) ! { ! #ifdef SECONDARY_MEMORY_NEEDED ! /* If we need a memory location to do the move, do it that way. */ ! if (GET_CODE (old) == REG && REGNO (old) < FIRST_PSEUDO_REGISTER ! && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (old)), ! REGNO_REG_CLASS (REGNO (reloadreg)), ! GET_MODE (reloadreg))) ! { ! /* Get the memory to use and rewrite both registers to ! its mode. */ ! rtx loc = get_secondary_mem (old, GET_MODE (reloadreg), ! reload_opnum[j], ! reload_when_needed[j]); ! ! if (GET_MODE (loc) != GET_MODE (reloadreg)) ! reloadreg = gen_rtx (REG, GET_MODE (loc), ! REGNO (reloadreg)); ! ! if (GET_MODE (loc) != GET_MODE (old)) ! old = gen_rtx (REG, GET_MODE (loc), REGNO (old)); ! ! emit_insn (gen_move_insn (loc, reloadreg)); ! emit_insn (gen_move_insn (old, loc)); ! } ! else ! #endif ! emit_insn (gen_move_insn (old, reloadreg)); ! } #ifdef PRESERVE_DEATH_INFO_REGNO_P --- 6346,6351 ---- /* Output the last reload insn. */ if (! special) ! gen_reload (old, reloadreg, reload_opnum[j], ! reload_when_needed[j]); #ifdef PRESERVE_DEATH_INFO_REGNO_P *************** *** 6409,6414 **** note_stores (PATTERN (p), forget_old_reloads_1); ! if (reg_mentioned_p (reload_reg_rtx[j], PATTERN (p))) ! store_insn = p; } --- 6382,6388 ---- note_stores (PATTERN (p), forget_old_reloads_1); ! if (reg_mentioned_p (reload_reg_rtx[j], PATTERN (p)) ! && reload_spill_index[j] >= 0) ! new_spill_reg_store[reload_spill_index[j]] = p; } *************** *** 6415,6423 **** output_reload_insns[reload_opnum[j]] = get_insns (); end_sequence (); - } - - if (reload_spill_index[j] >= 0) - new_spill_reg_store[reload_spill_index[j]] = store_insn; } --- 6389,6393 ---- *************** *** 6641,6646 **** } ! /* Emit code to perform an input reload of IN to RELOADREG. IN is from ! operand OPNUM with reload type TYPE. Returns first insn emitted. */ --- 6611,6617 ---- } ! /* Emit code to perform a reload from IN (which may be a reload register) to ! OUT (which may also be a reload register). IN or OUT is from operand ! OPNUM with reload type TYPE. Returns first insn emitted. */ *************** *** 6647,6652 **** rtx ! gen_input_reload (reloadreg, in, opnum, type) ! rtx reloadreg; rtx in; int opnum; --- 6618,6623 ---- rtx ! gen_reload (out, in, opnum, type) ! rtx out; rtx in; int opnum; *************** *** 6715,6719 **** if (GET_CODE (XEXP (in, 1)) == REG ! && REGNO (reloadreg) == REGNO (XEXP (in, 1))) tem = op0, op0 = op1, op1 = tem; --- 6686,6690 ---- if (GET_CODE (XEXP (in, 1)) == REG ! && REGNO (out) == REGNO (XEXP (in, 1))) tem = op0, op0 = op1, op1 = tem; *************** *** 6721,6725 **** in = gen_rtx (PLUS, GET_MODE (in), op0, op1); ! insn = emit_insn (gen_rtx (SET, VOIDmode, reloadreg, in)); code = recog_memoized (insn); --- 6692,6696 ---- in = gen_rtx (PLUS, GET_MODE (in), op0, op1); ! insn = emit_insn (gen_rtx (SET, VOIDmode, out, in)); code = recog_memoized (insn); *************** *** 6750,6756 **** tem = op0, op0 = op1, op1 = tem; ! emit_insn (gen_move_insn (reloadreg, op0)); ! /* If OP0 and OP1 are the same, we can use RELOADREG for OP1. This fixes a problem on the 32K where the stack pointer cannot be used as an operand of an add insn. */ --- 6721,6727 ---- tem = op0, op0 = op1, op1 = tem; ! emit_insn (gen_move_insn (out, op0)); ! /* If OP0 and OP1 are the same, we can use OUT for OP1. This fixes a problem on the 32K where the stack pointer cannot be used as an operand of an add insn. */ *************** *** 6757,6763 **** if (rtx_equal_p (op0, op1)) ! op1 = reloadreg; ! insn = emit_insn (gen_add2_insn (reloadreg, op1)); /* If that failed, copy the address register to the reload register. --- 6728,6734 ---- if (rtx_equal_p (op0, op1)) ! op1 = out; ! insn = emit_insn (gen_add2_insn (out, op1)); /* If that failed, copy the address register to the reload register. *************** *** 6778,6783 **** delete_insns_since (last); ! emit_insn (gen_move_insn (reloadreg, op1)); ! emit_insn (gen_add2_insn (reloadreg, op0)); } --- 6749,6754 ---- delete_insns_since (last); ! emit_insn (gen_move_insn (out, op1)); ! emit_insn (gen_add2_insn (out, op0)); } *************** *** 6785,6797 **** /* If we need a memory location to do the move, do it that way. */ else if (GET_CODE (in) == REG && REGNO (in) < FIRST_PSEUDO_REGISTER && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (in)), ! REGNO_REG_CLASS (REGNO (reloadreg)), ! GET_MODE (reloadreg))) { /* Get the memory to use and rewrite both registers to its mode. */ ! rtx loc = get_secondary_mem (in, GET_MODE (reloadreg), opnum, type); ! if (GET_MODE (loc) != GET_MODE (reloadreg)) ! reloadreg = gen_rtx (REG, GET_MODE (loc), REGNO (reloadreg)); if (GET_MODE (loc) != GET_MODE (in)) --- 6756,6769 ---- /* If we need a memory location to do the move, do it that way. */ else if (GET_CODE (in) == REG && REGNO (in) < FIRST_PSEUDO_REGISTER + && GET_CODE (out) == REG && REGNO (out) < FIRST_PSEUDO_REGISTER && SECONDARY_MEMORY_NEEDED (REGNO_REG_CLASS (REGNO (in)), ! REGNO_REG_CLASS (REGNO (out)), ! GET_MODE (out))) { /* Get the memory to use and rewrite both registers to its mode. */ ! rtx loc = get_secondary_mem (in, GET_MODE (out), opnum, type); ! if (GET_MODE (loc) != GET_MODE (out)) ! out = gen_rtx (REG, GET_MODE (loc), REGNO (out)); if (GET_MODE (loc) != GET_MODE (in)) *************** *** 6799,6803 **** emit_insn (gen_move_insn (loc, in)); ! emit_insn (gen_move_insn (reloadreg, loc)); } #endif --- 6771,6775 ---- emit_insn (gen_move_insn (loc, in)); ! emit_insn (gen_move_insn (out, loc)); } #endif *************** *** 6805,6818 **** /* If IN is a simple operand, use gen_move_insn. */ else if (GET_RTX_CLASS (GET_CODE (in)) == 'o' || GET_CODE (in) == SUBREG) ! emit_insn (gen_move_insn (reloadreg, in)); #ifdef HAVE_reload_load_address else if (HAVE_reload_load_address) ! emit_insn (gen_reload_load_address (reloadreg, in)); #endif ! /* Otherwise, just write (set REGLOADREG IN) and hope for the best. */ else ! emit_insn (gen_rtx (SET, VOIDmode, reloadreg, in)); /* Return the first insn emitted. --- 6777,6790 ---- /* If IN is a simple operand, use gen_move_insn. */ else if (GET_RTX_CLASS (GET_CODE (in)) == 'o' || GET_CODE (in) == SUBREG) ! emit_insn (gen_move_insn (out, in)); #ifdef HAVE_reload_load_address else if (HAVE_reload_load_address) ! emit_insn (gen_reload_load_address (out, in)); #endif ! /* Otherwise, just write (set OUT IN) and hope for the best. */ else ! emit_insn (gen_rtx (SET, VOIDmode, out, in)); /* Return the first insn emitted. *************** *** 6961,6965 **** /* See if we can directly increment INCLOC. Use a method similar to that ! in gen_input_reload. */ last = get_last_insn (); --- 6933,6937 ---- /* See if we can directly increment INCLOC. Use a method similar to that ! in gen_reload. */ last = get_last_insn (); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/reorg.c gcc-2.6.1/reorg.c *** gcc-2.6.0/reorg.c Fri Jul 1 19:28:40 1994 --- gcc-2.6.1/reorg.c Mon Oct 31 07:48:33 1994 *************** *** 608,611 **** --- 608,627 ---- return; + case SUBREG: + if (in_dest) + { + if (GET_CODE (SUBREG_REG (x)) != REG) + mark_set_resources (SUBREG_REG (x), res, + in_dest, include_delayed_effects); + else + { + int regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x); + int last_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x)); + for (i = regno; i < last_regno; i++) + SET_HARD_REG_BIT (res->regs, i); + } + } + return; + case REG: if (in_dest) *************** *** 1763,1766 **** --- 1779,1783 ---- { rtx pat = PATTERN (trial); + rtx oldtrial = trial; next_trial = next_nonnote_insn (trial); *************** *** 1782,1785 **** --- 1799,1804 ---- /* Update next_trial, in case try_split succeeded. */ && (next_trial = next_nonnote_insn (trial)) + /* Likewise THREAD. */ + && (thread = oldtrial == thread ? trial : thread) && rtx_equal_p (PATTERN (next_to_match), PATTERN (trial)) /* Have to test this condition if annul condition is different *************** *** 1791,1794 **** --- 1810,1816 ---- { update_block (trial, thread); + if (trial == thread) + thread = next_active_insn (thread); + delete_insn (trial); INSN_FROM_TARGET_P (next_to_match) = 0; *************** *** 3266,3269 **** --- 3288,3298 ---- { update_block (trial, thread); + if (trial == thread) + { + thread = next_active_insn (thread); + if (new_thread == trial) + new_thread = thread; + } + delete_insn (trial); } *************** *** 3285,3288 **** --- 3314,3319 ---- if (new_thread == old_trial) new_thread = trial; + if (thread == old_trial) + thread = trial; pat = PATTERN (trial); if (eligible_for_delay (insn, *pslots_filled, trial, flags)) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/rtl.h gcc-2.6.1/rtl.h *** gcc-2.6.0/rtl.h Fri May 6 17:33:57 1994 --- gcc-2.6.1/rtl.h Thu Sep 1 22:13:31 1994 *************** *** 923,926 **** --- 923,930 ---- extern union tree_node *make_tree PROTO((union tree_node *, rtx)); + /* Abort routines */ + extern void fatal_insn_not_found PROTO((rtx)); + extern void fatal_insn PROTO((char *, rtx)); + /* Define a default value for STORE_FLAG_VALUE. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/rtl.texi gcc-2.6.1/rtl.texi *** gcc-2.6.0/rtl.texi Thu Jun 2 07:58:29 1994 --- gcc-2.6.1/rtl.texi Sun Aug 7 08:58:53 1994 *************** *** 1,3 **** ! @c Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. --- 1,3 ---- ! @c Copyright (C) 1988, 1989, 1992, 1994 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/rtlanal.c gcc-2.6.1/rtlanal.c *** gcc-2.6.0/rtlanal.c Sun May 29 15:58:01 1994 --- gcc-2.6.1/rtlanal.c Thu Aug 25 18:48:16 1994 *************** *** 1604,1607 **** --- 1604,1611 ---- if (GET_CODE (XEXP (x, 1)) == CONST_INT && INTVAL (XEXP (x, 1)) == 0) return 1; + case EXPR_LIST: + /* An EXPR_LIST is used to represent a function call. This + certainly may trap. */ + return 1; default: /* Any floating arithmetic may trap. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/sched.c gcc-2.6.1/sched.c *** gcc-2.6.0/sched.c Tue Jun 14 18:04:28 1994 --- gcc-2.6.1/sched.c Tue Sep 20 15:55:14 1994 *************** *** 316,320 **** static void sched_analyze_1 PROTO((rtx, rtx)); static void sched_analyze_2 PROTO((rtx, rtx)); ! static void sched_analyze_insn PROTO((rtx, rtx)); static int sched_analyze PROTO((rtx, rtx)); static void sched_note_set PROTO((int, rtx, int)); --- 316,320 ---- static void sched_analyze_1 PROTO((rtx, rtx)); static void sched_analyze_2 PROTO((rtx, rtx)); ! static void sched_analyze_insn PROTO((rtx, rtx, rtx)); static int sched_analyze PROTO((rtx, rtx)); static void sched_note_set PROTO((int, rtx, int)); *************** *** 2014,2019 **** static void ! sched_analyze_insn (x, insn) rtx x, insn; { register RTX_CODE code = GET_CODE (x); --- 2014,2020 ---- static void ! sched_analyze_insn (x, insn, loop_notes) rtx x, insn; + rtx loop_notes; { register RTX_CODE code = GET_CODE (x); *************** *** 2049,2052 **** --- 2050,2083 ---- } + /* If there is a LOOP_{BEG,END} note in the middle of a basic block, then + we must be sure that no instructions are scheduled across it. + Otherwise, the reg_n_refs info (which depends on loop_depth) would + become incorrect. */ + + if (loop_notes) + { + int max_reg = max_reg_num (); + rtx link; + + for (i = 0; i < max_reg; i++) + { + rtx u; + for (u = reg_last_uses[i]; u; u = XEXP (u, 1)) + add_dependence (insn, XEXP (u, 0), REG_DEP_ANTI); + reg_last_uses[i] = 0; + if (reg_last_sets[i]) + add_dependence (insn, reg_last_sets[i], 0); + } + reg_pending_sets_all = 1; + + flush_pending_lists (insn); + + link = loop_notes; + while (XEXP (link, 1)) + link = XEXP (link, 1); + XEXP (link, 1) = REG_NOTES (insn); + REG_NOTES (insn) = loop_notes; + } + /* After reload, it is possible for an instruction to have a REG_DEAD note for a register that actually dies a few instructions earlier. For *************** *** 2108,2112 **** dep_insn = PREV_INSN (insn); while (GET_CODE (dep_insn) == INSN ! && GET_CODE (PATTERN (dep_insn)) == USE) { SCHED_GROUP_P (prev_dep_insn) = 1; --- 2139,2144 ---- dep_insn = PREV_INSN (insn); while (GET_CODE (dep_insn) == INSN ! && GET_CODE (PATTERN (dep_insn)) == USE ! && GET_CODE (XEXP (PATTERN (dep_insn), 0)) == REG) { SCHED_GROUP_P (prev_dep_insn) = 1; *************** *** 2136,2139 **** --- 2168,2172 ---- register rtx u; register int luid = 0; + rtx loop_notes = 0; for (insn = head; ; insn = NEXT_INSN (insn)) *************** *** 2143,2147 **** if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN) { ! sched_analyze_insn (PATTERN (insn), insn); n_insns += 1; } --- 2176,2181 ---- if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN) { ! sched_analyze_insn (PATTERN (insn), insn, loop_notes); ! loop_notes = 0; n_insns += 1; } *************** *** 2180,2184 **** /* Add a fake REG_NOTE which we will later convert back into a NOTE_INSN_SETJMP note. */ ! REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_DEAD, constm1_rtx, REG_NOTES (insn)); } --- 2214,2219 ---- /* Add a fake REG_NOTE which we will later convert back into a NOTE_INSN_SETJMP note. */ ! REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_DEAD, ! GEN_INT (NOTE_INSN_SETJMP), REG_NOTES (insn)); } *************** *** 2208,2212 **** LOG_LINKS (sched_before_next_call) = 0; ! sched_analyze_insn (PATTERN (insn), insn); /* We don't need to flush memory for a function call which does --- 2243,2248 ---- LOG_LINKS (sched_before_next_call) = 0; ! sched_analyze_insn (PATTERN (insn), insn, loop_notes); ! loop_notes = 0; /* We don't need to flush memory for a function call which does *************** *** 2225,2228 **** --- 2261,2269 ---- n_insns += 1; } + else if (GET_CODE (insn) == NOTE + && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG + || NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_END)) + loop_notes = gen_rtx (EXPR_LIST, REG_DEAD, + GEN_INT (NOTE_LINE_NUMBER (insn)), loop_notes); if (insn == tail) *************** *** 2826,2829 **** --- 2867,2880 ---- if (! all_needed && ! dead_or_set_p (insn, x)) { + /* Check for the case where the register dying partially + overlaps the register set by this insn. */ + if (regno < FIRST_PSEUDO_REGISTER + && HARD_REGNO_NREGS (regno, GET_MODE (x)) > 1) + { + int n = HARD_REGNO_NREGS (regno, GET_MODE (x)); + while (--n >= 0) + some_needed |= dead_or_set_regno_p (insn, regno + n); + } + /* If none of the words in X is needed, make a REG_DEAD note. Otherwise, we must make partial REG_DEAD *************** *** 2986,2991 **** /* Don't save away NOTE_INSN_SETJMPs, because they must remain immediately after the call they follow. We use a fake ! (REG_DEAD (const_int -1)) note to remember them. */ ! else if (NOTE_LINE_NUMBER (insn) != NOTE_INSN_SETJMP) { /* Insert the note at the end of the notes list. */ --- 3037,3045 ---- /* Don't save away NOTE_INSN_SETJMPs, because they must remain immediately after the call they follow. We use a fake ! (REG_DEAD (const_int -1)) note to remember them. ! Likewise with NOTE_INSN_LOOP_BEG and NOTE_INSN_LOOP_END. */ ! else if (NOTE_LINE_NUMBER (insn) != NOTE_INSN_SETJMP ! && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_BEG ! && NOTE_LINE_NUMBER (insn) != NOTE_INSN_LOOP_END) { /* Insert the note at the end of the notes list. */ *************** *** 3804,3818 **** last = insn; ! /* Check to see if we need to re-emit a NOTE_INSN_SETJMP here. */ ! if (GET_CODE (insn) == CALL_INSN) ! { ! rtx note = find_reg_note (insn, REG_DEAD, constm1_rtx); ! if (note) ! { ! emit_note_after (NOTE_INSN_SETJMP, insn); ! remove_note (insn, note); ! } ! } /* Everything that precedes INSN now either becomes "ready", if --- 3858,3878 ---- last = insn; ! /* Check to see if we need to re-emit any notes here. */ ! { ! rtx note; ! for (note = REG_NOTES (insn); note; note = XEXP (note, 1)) ! { ! if (REG_NOTE_KIND (note) == REG_DEAD ! && GET_CODE (XEXP (note, 0)) == CONST_INT) ! { ! if (INTVAL (XEXP (note, 0)) == NOTE_INSN_SETJMP) ! emit_note_after (INTVAL (XEXP (note, 0)), insn); ! else ! last = emit_note_before (INTVAL (XEXP (note, 0)), last); ! remove_note (insn, note); ! } ! } ! } /* Everything that precedes INSN now either becomes "ready", if diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/sdbout.c gcc-2.6.1/sdbout.c *** gcc-2.6.0/sdbout.c Sat Jun 18 17:00:09 1994 --- gcc-2.6.1/sdbout.c Fri Sep 30 17:23:57 1994 *************** *** 54,58 **** /* Mips systems use the SDB functions to dump out symbols, but do not supply usable syms.h include files. */ ! #if defined(USG) && !defined(MIPS) && !defined (hpux) #include /* Use T_INT if we don't have T_VOID. */ --- 54,58 ---- /* Mips systems use the SDB functions to dump out symbols, but do not supply usable syms.h include files. */ ! #if defined(USG) && !defined(MIPS) && !defined (hpux) && !defined(WINNT) #include /* Use T_INT if we don't have T_VOID. */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/stmt.c gcc-2.6.1/stmt.c *** gcc-2.6.0/stmt.c Sun Jul 10 08:12:30 1994 --- gcc-2.6.1/stmt.c Thu Sep 29 19:37:39 1994 *************** *** 1381,1384 **** --- 1381,1386 ---- if (i >= 0 || i == -4) ++nclobbers; + else if (i == -2) + error ("unknown register name `%s' in `asm'", regname); } *************** *** 1570,1575 **** } ! error ("unknown register name `%s' in `asm'", regname); ! return; } --- 1572,1576 ---- } ! /* Ignore unknown register, error already signalled. */ } *************** *** 1731,1735 **** tem = TREE_OPERAND (tem, 0); ! if (TREE_CODE (tem) == MODIFY_EXPR) return 0; } --- 1732,1736 ---- tem = TREE_OPERAND (tem, 0); ! if (TREE_CODE (tem) == MODIFY_EXPR || TREE_CODE (tem) == INIT_EXPR) return 0; } *************** *** 1933,1936 **** --- 1934,1948 ---- } + /* After calling expand_start_else, turn this "else" into an "else if" + by providing another condition. */ + + void + expand_elseif (cond) + tree cond; + { + cond_stack->data.cond.next_label = gen_label_rtx (); + do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX); + } + /* Generate RTL for the end of an if-then. Pop the record for it off of cond_stack. */ *************** *** 2502,2506 **** --- 2514,2526 ---- /* Are any cleanups needed? E.g. C++ destructors to be run? */ + /* This is not sufficient. We also need to watch for cleanups of the + expression we are about to expand. Unfortunately, we cannot know + if it has cleanups until we expand it, and we want to change how we + expand it depending upon if we need cleanups. We can't win. */ + #if 0 cleanups = any_pending_cleanups (1); + #else + cleanups = 1; + #endif if (TREE_CODE (retval) == RESULT_DECL) *************** *** 3511,3514 **** --- 3531,3545 ---- enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt)); + /* Propagate the union's alignment to the elements. */ + DECL_ALIGN (decl_elt) = DECL_ALIGN (decl); + + /* If the element has BLKmode and the union doesn't, the union is + aligned such that the element doesn't need to have BLKmode, so + change the element's mode to the appropriate one for its size. */ + if (mode == BLKmode && DECL_MODE (decl) != BLKmode) + DECL_MODE (decl_elt) = mode + = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl_elt)), + MODE_INT, 1); + /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we instead create a new MEM rtx with the proper mode. */ *************** *** 4056,4059 **** --- 4087,4275 ---- } + /* Returns the number of possible values of TYPE. + Returns -1 if the number is unknown or variable. + Returns -2 if the number does not fit in a HOST_WIDE_INT. + Sets *SPARENESS to 2 if TYPE is an ENUMERAL_TYPE whose values + do not increase monotonically (there may be duplicates); + to 1 if the values increase monotonically, but not always by 1; + otherwise sets it to 0. */ + + HOST_WIDE_INT + all_cases_count (type, spareness) + tree type; + int *spareness; + { + HOST_WIDE_INT count, count_high = 0; + *spareness = 0; + + switch (TREE_CODE (type)) + { + tree t; + case BOOLEAN_TYPE: + count = 2; + break; + case CHAR_TYPE: + count = 1 << BITS_PER_UNIT; + break; + default: + case INTEGER_TYPE: + if (TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST + || TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST) + return -1; + else + { + /* count + = TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)) + - TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + 1 + but with overflow checking. */ + tree mint = TYPE_MIN_VALUE (type); + tree maxt = TYPE_MAX_VALUE (type); + HOST_WIDE_INT lo, hi; + neg_double(TREE_INT_CST_LOW (mint), TREE_INT_CST_HIGH (mint), + &lo, &hi); + add_double(TREE_INT_CST_LOW (maxt), TREE_INT_CST_HIGH (maxt), + lo, hi, &lo, &hi); + add_double (lo, hi, 1, 0, &lo, &hi); + if (hi != 0 || lo < 0) + return -2; + count = lo; + } + break; + case ENUMERAL_TYPE: + count = 0; + for (t = TYPE_VALUES (type); t != NULL_TREE; t = TREE_CHAIN (t)) + { + if (TREE_CODE (TYPE_MIN_VALUE (type)) != INTEGER_CST + || TREE_CODE (TREE_VALUE (t)) != INTEGER_CST + || TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + count + != TREE_INT_CST_LOW (TREE_VALUE (t))) + *spareness = 1; + count++; + } + if (*spareness == 1) + { + tree prev = TREE_VALUE (TYPE_VALUES (type)); + for (t = TYPE_VALUES (type); t = TREE_CHAIN (t), t != NULL_TREE; ) + { + if (! tree_int_cst_lt (prev, TREE_VALUE (t))) + { + *spareness = 2; + break; + } + prev = TREE_VALUE (t); + } + + } + } + return count; + } + + + #define BITARRAY_TEST(ARRAY, INDEX) \ + ((ARRAY)[(unsigned)(INDEX) / HOST_BITS_PER_CHAR]\ + & (1 << ((unsigned)(INDEX) % HOST_BITS_PER_CHAR))) + #define BITARRAY_SET(ARRAY, INDEX) \ + ((ARRAY)[(unsigned)(INDEX) / HOST_BITS_PER_CHAR]\ + |= 1 << ((unsigned)(INDEX) % HOST_BITS_PER_CHAR)) + + /* Set the elements of the bitstring CASES_SEEN (which has length COUNT), + with the case values we have seen, assuming the case expression + has the given TYPE. + SPARSENESS is as determined by all_cases_count. + + The time needed is propotional to COUNT, unless + SPARSENESS is 2, in which case quadratic time is needed. */ + + void + mark_seen_cases (type, cases_seen, count, sparseness) + tree type; + unsigned char *cases_seen; + long count; + int sparseness; + { + long i; + + tree next_node_to_try = NULL_TREE; + long next_node_offset = 0; + + register struct case_node *n; + tree val = make_node (INTEGER_CST); + TREE_TYPE (val) = type; + for (n = case_stack->data.case_stmt.case_list; n; + n = n->right) + { + TREE_INT_CST_LOW (val) = TREE_INT_CST_LOW (n->low); + TREE_INT_CST_HIGH (val) = TREE_INT_CST_HIGH (n->low); + while ( ! tree_int_cst_lt (n->high, val)) + { + /* Calculate (into xlo) the "offset" of the integer (val). + The element with lowest value has offset 0, the next smallest + element has offset 1, etc. */ + + HOST_WIDE_INT xlo, xhi; + tree t; + if (sparseness == 2) + { + /* This less efficient loop is only needed to handle + duplicate case values (multiple enum constants + with the same value). */ + for (t = TYPE_VALUES (type), xlo = 0; t != NULL_TREE; + t = TREE_CHAIN (t), xlo++) + { + if (tree_int_cst_equal (val, TREE_VALUE (t))) + BITARRAY_SET (cases_seen, xlo); + } + } + else + { + if (sparseness && TYPE_VALUES (type) != NULL_TREE) + { + /* The TYPE_VALUES will be in increasing order, so + starting searching where we last ended. */ + t = next_node_to_try; + xlo = next_node_offset; + xhi = 0; + for (;;) + { + if (t == NULL_TREE) + { + t = TYPE_VALUES (type); + xlo = 0; + } + if (tree_int_cst_equal (val, TREE_VALUE (t))) + { + next_node_to_try = TREE_CHAIN (t); + next_node_offset = xlo + 1; + break; + } + xlo++; + t = TREE_CHAIN (t); + if (t == next_node_to_try) + break; + } + } + else + { + t = TYPE_MIN_VALUE (type); + if (t) + neg_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), + &xlo, &xhi); + else + xlo = xhi = 0; + add_double (xlo, xhi, + TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val), + &xlo, &xhi); + } + + if (xhi == 0 && xlo >= 0 && xlo < count) + BITARRAY_SET (cases_seen, xlo); + } + add_double (TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val), + 1, 0, + &TREE_INT_CST_LOW (val), &TREE_INT_CST_HIGH (val)); + } + } + } + /* Called when the index of a switch statement is an enumerated type and there is no default label. *************** *** 4076,4079 **** --- 4292,4309 ---- int all_values = 1; + /* True iff the selector type is a numbered set mode. */ + int sparseness = 0; + + /* The number of possible selector values. */ + HOST_WIDE_INT size; + + /* For each possible selector value. a one iff it has been matched + by a case value alternative. */ + unsigned char *cases_seen; + + /* The allocated size of cases_seen, in chars. */ + long bytes_needed; + tree t; + if (output_bytecode) { *************** *** 4082,4110 **** } ! /* The time complexity of this loop is currently O(N * M), with ! N being the number of members in the enumerated type, and ! M being the number of case expressions in the switch. */ ! ! for (chain = TYPE_VALUES (type); ! chain; ! chain = TREE_CHAIN (chain)) ! { ! /* Find a match between enumeral and case expression, if possible. ! Quit looking when we've gone too far (since case expressions ! are kept sorted in ascending order). Warn about enumerators not ! handled in the switch statement case expression list. */ ! ! for (n = case_stack->data.case_stmt.case_list; ! n && tree_int_cst_lt (n->high, TREE_VALUE (chain)); ! n = n->right) ! ; ! if (!n || tree_int_cst_lt (TREE_VALUE (chain), n->low)) { ! if (warn_switch) warning ("enumeration value `%s' not handled in switch", ! IDENTIFIER_POINTER (TREE_PURPOSE (chain))); ! all_values = 0; } } --- 4312,4344 ---- } ! if (! warn_switch) ! return; ! ! size = all_cases_count (type, &sparseness); ! bytes_needed = (size + HOST_BITS_PER_CHAR) / HOST_BITS_PER_CHAR; ! ! if (size > 0 && size < 600000 ! /* We deliberately use malloc here - not xmalloc. */ ! && (cases_seen = (unsigned char *) malloc (bytes_needed)) != NULL) ! { ! long i; ! tree v = TYPE_VALUES (type); ! bzero (cases_seen, bytes_needed); ! ! /* The time complexity of this code is normally O(N), where ! N being the number of members in the enumerated type. ! However, if type is a ENUMERAL_TYPE whose values do not ! increase monotonically, quadratic time may be needed. */ ! mark_seen_cases (type, cases_seen, size, sparseness); ! ! for (i = 0; v != NULL_TREE && i < size; i++, v = TREE_CHAIN (v)) { ! if (BITARRAY_TEST(cases_seen, i) == 0) warning ("enumeration value `%s' not handled in switch", ! IDENTIFIER_POINTER (TREE_PURPOSE (v))); } + + free (cases_seen); } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/stor-layout.c gcc-2.6.1/stor-layout.c *** gcc-2.6.0/stor-layout.c Wed May 18 16:50:37 1994 --- gcc-2.6.1/stor-layout.c Thu Oct 20 09:41:02 1994 *************** *** 45,48 **** --- 45,52 ---- int maximum_field_alignment; + /* If non-zero, the alignment of a bitsting or (power-)set value, in bits. + May be overridden by front-ends. */ + int set_alignment = 0; + #define GET_MODE_ALIGNMENT(MODE) \ MIN (BIGGEST_ALIGNMENT, \ *************** *** 85,90 **** /* If the language-processor is to take responsibility for variable-sized items (e.g., languages which have elaboration procedures like Ada), ! just return SIZE unchanged. */ ! if (global_bindings_p () < 0) return size; --- 89,94 ---- /* If the language-processor is to take responsibility for variable-sized items (e.g., languages which have elaboration procedures like Ada), ! just return SIZE unchanged. Likewise for self-referential sizes. */ ! if (global_bindings_p () < 0 || contains_placeholder_p (size)) return size; *************** *** 897,900 **** --- 901,929 ---- TYPE_PRECISION (type) = GET_MODE_BITSIZE (TYPE_MODE (type)); TYPE_ALIGN (type) = GET_MODE_ALIGNMENT (TYPE_MODE (type)); + break; + + case SET_TYPE: + if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST + || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) != INTEGER_CST) + abort(); + else + { + #ifndef SET_WORD_SIZE + #define SET_WORD_SIZE BITS_PER_WORD + #endif + int alignment = set_alignment ? set_alignment : SET_WORD_SIZE; + int size_in_bits = + TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1; + int rounded_size + = ((size_in_bits + alignment - 1) / alignment) * alignment; + if (rounded_size > alignment) + TYPE_MODE (type) = BLKmode; + else + TYPE_MODE (type) = mode_for_size (alignment, MODE_INT, 1); + TYPE_SIZE (type) = size_int (rounded_size); + TYPE_ALIGN (type) = alignment; + TYPE_PRECISION (type) = size_in_bits; + } break; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/stupid.c gcc-2.6.1/stupid.c *** gcc-2.6.0/stupid.c Tue Jun 14 18:02:33 1994 --- gcc-2.6.1/stupid.c Fri Aug 12 14:54:20 1994 *************** *** 83,86 **** --- 83,91 ---- static char *regs_live; + /* Indexed by reg number, nonzero if reg was used in a SUBREG that changes + its size. */ + + static char *regs_change_size; + /* Indexed by insn's suid, the set of hard regs live after that insn. */ *************** *** 94,98 **** static int stupid_reg_compare PROTO((int *, int *)); static int stupid_find_reg PROTO((int, enum reg_class, enum machine_mode, ! int, int)); static void stupid_mark_refs PROTO((rtx, rtx)); --- 99,103 ---- static int stupid_reg_compare PROTO((int *, int *)); static int stupid_find_reg PROTO((int, enum reg_class, enum machine_mode, ! int, int, int)); static void stupid_mark_refs PROTO((rtx, rtx)); *************** *** 158,161 **** --- 163,169 ---- bzero ((char *) reg_order, nregs * sizeof (int)); + regs_change_size = (char *) alloca (nregs * sizeof (char)); + bzero ((char *) regs_change_size, nregs * sizeof (char)); + reg_renumber = (short *) oballoc (nregs * sizeof (short)); for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) *************** *** 255,259 **** PSEUDO_REGNO_MODE (r), reg_where_born[r], ! reg_where_dead[r]); /* If no reg available in that class, try alternate class. */ --- 263,268 ---- PSEUDO_REGNO_MODE (r), reg_where_born[r], ! reg_where_dead[r], ! regs_change_size[r]); /* If no reg available in that class, try alternate class. */ *************** *** 263,267 **** PSEUDO_REGNO_MODE (r), reg_where_born[r], ! reg_where_dead[r]); } --- 272,277 ---- PSEUDO_REGNO_MODE (r), reg_where_born[r], ! reg_where_dead[r], ! regs_change_size[r]); } *************** *** 304,311 **** If CALL_PRESERVED is nonzero, insist on registers preserved ! over subroutine calls, and return -1 if cannot find such. */ static int ! stupid_find_reg (call_preserved, class, mode, born_insn, dead_insn) int call_preserved; enum reg_class class; --- 314,325 ---- If CALL_PRESERVED is nonzero, insist on registers preserved ! over subroutine calls, and return -1 if cannot find such. ! ! If CHANGES_SIZE is nonzero, it means this register was used as the ! operand of a SUBREG that changes its size. */ static int ! stupid_find_reg (call_preserved, class, mode, ! born_insn, dead_insn, changes_size) int call_preserved; enum reg_class class; *************** *** 312,315 **** --- 326,330 ---- enum machine_mode mode; int born_insn, dead_insn; + int changes_size; { register int i, ins; *************** *** 340,343 **** --- 355,364 ---- IOR_COMPL_HARD_REG_SET (used, reg_class_contents[(int) class]); + #ifdef CLASS_CANNOT_CHANGE_SIZE + if (changes_size) + IOR_HARD_REG_SET (used, + reg_class_contents[(int) CLASS_CANNOT_CHANGE_SIZE]); + #endif + for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) { *************** *** 472,478 **** } /* Register value being used, not set. */ ! if (code == REG) { regno = REGNO (x); --- 493,508 ---- } + else if (code == SUBREG + && GET_CODE (SUBREG_REG (x)) == REG + && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER + && (GET_MODE_SIZE (GET_MODE (x)) + != GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))) + && (INTEGRAL_MODE_P (GET_MODE (x)) + || INTEGRAL_MODE_P (GET_MODE (SUBREG_REG (x))))) + regs_change_size[REGNO (SUBREG_REG (x))] = 1; + /* Register value being used, not set. */ ! else if (code == REG) { regno = REGNO (x); diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/texinfo.tex gcc-2.6.1/texinfo.tex *** gcc-2.6.0/texinfo.tex Thu Jul 14 22:18:23 1994 --- gcc-2.6.1/texinfo.tex Tue Nov 1 21:36:19 1994 *************** *** 25,29 **** % This automatically updates the version number based on RCS. \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}} ! \deftexinfoversion$Revision: 2.131 $ \message{Loading texinfo package [Version \texinfoversion]:} --- 25,29 ---- % This automatically updates the version number based on RCS. \def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}} ! \deftexinfoversion$Revision: 2.136 $ \message{Loading texinfo package [Version \texinfoversion]:} *************** *** 169,175 **** --- 169,180 ---- \def\cropmarks{\let\onepageout=\croppageout } + \newinsert\margin \dimen\margin=\maxdimen + \def\pagebody#1{\vbox to\pageheight{\boxmaxdepth=\maxdepth #1}} {\catcode`\@ =11 \gdef\pagecontents#1{\ifvoid\topins\else\unvbox\topins\fi + % marginal hacks, juha@viisa.uucp (Juha Takala) + \ifvoid\margin\else % marginal info is present + \rlap{\kern\hsize\vbox to\z@{\kern1pt\box\margin \vss}}\fi \dimen@=\dp#1 \unvbox#1 \ifvoid\footins\else\vskip\skip\footins\footnoterule \unvbox\footins\fi *************** *** 360,363 **** --- 365,377 ---- \def\.{.\spacefactor=3000 } + % @enddots{} is an end-of-sentence ellipsis. + \gdef\enddots{$\mathinner{\ldotp\ldotp\ldotp\ldotp}$\spacefactor=3000} + + % @! is an end-of-sentence bang. + \gdef\!{!\spacefactor=3000 } + + % @? is an end-of-sentence query. + \gdef\?{?\spacefactor=3000 } + % @w prevents a word break. Without the \leavevmode, @w at the % beginning of a paragraph, when TeX is still in vertical mode, would *************** *** 617,623 **** \def\ignore{\doignore{ignore}} ! % Also ignore @ifinfo, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} --- 631,639 ---- \def\ignore{\doignore{ignore}} ! % Also ignore @ifinfo, @ifhtml, @html, @menu, and @direntry text. % \def\ifinfo{\doignore{ifinfo}} + \def\ifhtml{\doignore{ifhtml}} + \def\html{\doignore{html}} \def\menu{\doignore{menu}} \def\direntry{\doignore{direntry}} *************** *** 889,899 **** \let\mainmagstep=\magstephalf \ifx\bigger\relax \let\mainmagstep=\magstep1 ! \font\textrm=cmr12 ! \font\texttt=cmtt12 \else ! \font\textrm=cmr10 scaled \mainmagstep ! \font\texttt=cmtt10 scaled \mainmagstep \fi % Instead of cmb10, you many want to use cmbx10. --- 905,926 ---- \let\mainmagstep=\magstephalf + % Set the font macro #1 to the font named #2, adding on the + % specified font prefix (normally `cm'). + \def\setfont#1#2{\font#1=\fontprefix#2} + + % Use cm as the default font prefix. + % To specify the font prefix, you must define \fontprefix + % before you read in texinfo.tex. + \ifx\fontprefix\undefined + \def\fontprefix{cm} + \fi + \ifx\bigger\relax \let\mainmagstep=\magstep1 ! \setfont\textrm{r12} ! \setfont\texttt{tt12} \else ! \setfont\textrm{r10 scaled \mainmagstep} ! \setfont\texttt{tt10 scaled \mainmagstep} \fi % Instead of cmb10, you many want to use cmbx10. *************** *** 900,908 **** % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. ! \font\textbf=cmb10 scaled \mainmagstep ! \font\textit=cmti10 scaled \mainmagstep ! \font\textsl=cmsl10 scaled \mainmagstep ! \font\textsf=cmss10 scaled \mainmagstep ! \font\textsc=cmcsc10 scaled \mainmagstep \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep --- 927,935 ---- % cmbx10 is a prettier font on its own, but cmb10 % looks better when embedded in a line with cmr10. ! \setfont\textbf{b10 scaled \mainmagstep} ! \setfont\textit{ti10 scaled \mainmagstep} ! \setfont\textsl{sl10 scaled \mainmagstep} ! \setfont\textsf{ss10 scaled \mainmagstep} ! \setfont\textsc{csc10 scaled \mainmagstep} \font\texti=cmmi10 scaled \mainmagstep \font\textsy=cmsy10 scaled \mainmagstep *************** *** 909,914 **** % A few fonts for @defun, etc. ! \font\defbf=cmbx10 scaled \magstep1 %was 1314 ! \font\deftt=cmtt10 scaled \magstep1 \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} --- 936,941 ---- % A few fonts for @defun, etc. ! \setfont\defbf{bx10 scaled \magstep1} %was 1314 ! \setfont\deftt{tt10 scaled \magstep1} \def\df{\let\tentt=\deftt \let\tenbf = \defbf \bf} *************** *** 918,924 **** % Do not make many font distinctions in general in the index, since they % aren't very useful. ! \font\ninett=cmtt9 ! \font\indrm=cmr9 ! \font\indit=cmsl9 \let\indsl=\indit \let\indtt=\ninett --- 945,951 ---- % Do not make many font distinctions in general in the index, since they % aren't very useful. ! \setfont\ninett{tt9} ! \setfont\indrm{r9} ! \setfont\indit{sl9} \let\indsl=\indit \let\indtt=\ninett *************** *** 930,974 **** % Fonts for headings ! \font\chaprm=cmbx12 scaled \magstep2 ! \font\chapit=cmti12 scaled \magstep2 ! \font\chapsl=cmsl12 scaled \magstep2 ! \font\chaptt=cmtt12 scaled \magstep2 ! \font\chapsf=cmss12 scaled \magstep2 \let\chapbf=\chaprm ! \font\chapsc=cmcsc10 scaled\magstep3 \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 ! \font\secrm=cmbx12 scaled \magstep1 ! \font\secit=cmti12 scaled \magstep1 ! \font\secsl=cmsl12 scaled \magstep1 ! \font\sectt=cmtt12 scaled \magstep1 ! \font\secsf=cmss12 scaled \magstep1 ! \font\secbf=cmbx12 scaled \magstep1 ! \font\secsc=cmcsc10 scaled\magstep2 \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 ! % \font\ssecrm=cmbx10 scaled \magstep1 % This size an font looked bad. ! % \font\ssecit=cmti10 scaled \magstep1 % The letters were too crowded. ! % \font\ssecsl=cmsl10 scaled \magstep1 ! % \font\ssectt=cmtt10 scaled \magstep1 ! % \font\ssecsf=cmss10 scaled \magstep1 ! ! %\font\ssecrm=cmb10 scaled 1315 % Note the use of cmb rather than cmbx. ! %\font\ssecit=cmti10 scaled 1315 % Also, the size is a little larger than ! %\font\ssecsl=cmsl10 scaled 1315 % being scaled magstep1. ! %\font\ssectt=cmtt10 scaled 1315 ! %\font\ssecsf=cmss10 scaled 1315 %\let\ssecbf=\ssecrm ! \font\ssecrm=cmbx12 scaled \magstephalf ! \font\ssecit=cmti12 scaled \magstephalf ! \font\ssecsl=cmsl12 scaled \magstephalf ! \font\ssectt=cmtt12 scaled \magstephalf ! \font\ssecsf=cmss12 scaled \magstephalf ! \font\ssecbf=cmbx12 scaled \magstephalf ! \font\ssecsc=cmcsc10 scaled \magstep1 \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled \magstep1 --- 957,1001 ---- % Fonts for headings ! \setfont\chaprm{bx12 scaled \magstep2} ! \setfont\chapit{ti12 scaled \magstep2} ! \setfont\chapsl{sl12 scaled \magstep2} ! \setfont\chaptt{tt12 scaled \magstep2} ! \setfont\chapsf{ss12 scaled \magstep2} \let\chapbf=\chaprm ! \setfont\chapsc{csc10 scaled\magstep3} \font\chapi=cmmi12 scaled \magstep2 \font\chapsy=cmsy10 scaled \magstep3 ! \setfont\secrm{bx12 scaled \magstep1} ! \setfont\secit{ti12 scaled \magstep1} ! \setfont\secsl{sl12 scaled \magstep1} ! \setfont\sectt{tt12 scaled \magstep1} ! \setfont\secsf{ss12 scaled \magstep1} ! \setfont\secbf{bx12 scaled \magstep1} ! \setfont\secsc{csc10 scaled\magstep2} \font\seci=cmmi12 scaled \magstep1 \font\secsy=cmsy10 scaled \magstep2 ! % \setfont\ssecrm{bx10 scaled \magstep1} % This size an font looked bad. ! % \setfont\ssecit{cmti10 scaled \magstep1} % The letters were too crowded. ! % \setfont\ssecsl{sl10 scaled \magstep1} ! % \setfont\ssectt{tt10 scaled \magstep1} ! % \setfont\ssecsf{ss10 scaled \magstep1} ! ! %\setfont\ssecrm{b10 scaled 1315} % Note the use of cmb rather than cmbx. ! %\setfont\ssecit{ti10 scaled 1315} % Also, the size is a little larger than ! %\setfont\ssecsl{sl10 scaled 1315} % being scaled magstep1. ! %\setfont\ssectt{tt10 scaled 1315} ! %\setfont\ssecsf{ss10 scaled 1315} %\let\ssecbf=\ssecrm ! \setfont\ssecrm{bx12 scaled \magstephalf} ! \setfont\ssecit{ti12 scaled \magstephalf} ! \setfont\ssecsl{sl12 scaled \magstephalf} ! \setfont\ssectt{tt12 scaled \magstephalf} ! \setfont\ssecsf{ss12 scaled \magstephalf} ! \setfont\ssecbf{bx12 scaled \magstephalf} ! \setfont\ssecsc{csc10 scaled \magstep1} \font\sseci=cmmi12 scaled \magstephalf \font\ssecsy=cmsy10 scaled \magstep1 *************** *** 977,981 **** % Fonts for title page: ! \font\titlerm = cmbx12 scaled \magstep3 \let\authorrm = \secrm --- 1004,1008 ---- % Fonts for title page: ! \setfont\titlerm{bx12 scaled \magstep3} \let\authorrm = \secrm *************** *** 1033,1039 **** % Fonts for short table of contents. ! \font\shortcontrm=cmr12 ! \font\shortcontbf=cmbx12 ! \font\shortcontsl=cmsl12 %% Add scribe-like font environments, plus @l for inline lisp (usually sans --- 1060,1066 ---- % Fonts for short table of contents. ! \setfont\shortcontrm{r12} ! \setfont\shortcontbf{bx12} ! \setfont\shortcontsl{sl12} %% Add scribe-like font environments, plus @l for inline lisp (usually sans *************** *** 1665,1668 **** --- 1692,1848 ---- \flushcr} + % @multitable macros + % Amy Hendrickson, 8/18/94 + % + % @multitable ... @endmultitable will make as many columns as desired. + % Contents of each column will wrap at width given in preamble. Width + % can be specified either with sample text given in a template line, + % or in percent of \hsize, the current width of text on page. + + % Table can continue over pages but will only break between lines. + + % To make preamble: + % + % Either define widths of columns in terms of percent of \hsize: + % @multitable @percentofhsize .2 .3 .5 + % @item ... + % + % Numbers following @percentofhsize are the percent of the total + % current hsize to be used for each column. You may use as many + % columns as desired. + + % Or use a template: + % @multitable {Column 1 template} {Column 2 template} {Column 3 template} + % @item ... + % using the widest term desired in each column. + + + % Each new table line starts with @item, each subsequent new column + % starts with @tab. Empty columns may be produced by supplying @tab's + % with nothing between them for as many times as empty columns are needed, + % ie, @tab@tab@tab will produce two empty columns. + + % @item, @tab, @multicolumn or @endmulticolumn do not need to be on their + % own lines, but it will not hurt if they are. + + % Sample multitable: + + % @multitable {Column 1 template} {Column 2 template} {Column 3 template} + % @item first col stuff @tab second col stuff @tab third col + % @item + % first col stuff + % @tab + % second col stuff + % @tab + % third col + % @item first col stuff @tab second col stuff + % @tab Many paragraphs of text may be used in any column. + % + % They will wrap at the width determined by the template. + % @item@tab@tab This will be in third column. + % @endmultitable + + % Default dimensions may be reset by user. + % @intableparskip will set vertical space between paragraphs in table. + % @intableparindent will set paragraph indent in table. + % @spacebetweencols will set horizontal space to be left between columns. + % @spacebetweenlines will set vertical space to be left between lines. + + %%%% + % Dimensions + + \newdimen\intableparskip + \newdimen\intableparindent + \newdimen\spacebetweencols + \newdimen\spacebetweenlines + \intableparskip=0pt + \intableparindent=6pt + \spacebetweencols=12pt + \spacebetweenlines=12pt + + %%%% + % Macros used to set up halign preamble: + \let\endsetuptable\relax + \def\xendsetuptable{\endsetuptable} + \let\percentofhsize\relax + \def\xpercentofhsize{\percentofhsize} + \newif\ifsetpercent + + \newcount\colcount + \def\setuptable#1{\def\firstarg{#1}% + \ifx\firstarg\xendsetuptable\let\go\relax% + \else + \ifx\firstarg\xpercentofhsize\global\setpercenttrue% + \else + \ifsetpercent + \if#1.\else% + \global\advance\colcount by1 % + \expandafter\xdef\csname col\the\colcount\endcsname{.#1\hsize}% + \fi + \else + \global\advance\colcount by1 + \setbox0=\hbox{#1}% + \expandafter\xdef\csname col\the\colcount\endcsname{\the\wd0}% + \fi% + \fi% + \let\go\setuptable% + \fi\go} + %%%% + % multitable syntax + \def\tab{&} + + %%%% + % @multitable ... @endmultitable definitions: + + \def\multitable#1\item{\bgroup + \let\item\cr + \tolerance=9500 + \hbadness=9500 + \parskip=\intableparskip + \parindent=\intableparindent + \overfullrule=0pt + \global\colcount=0\relax% + \def\Emultitable{\global\setpercentfalse\global\everycr{}\cr\egroup\egroup}% + % To parse everything between @multitable and @item : + \def\one{#1}\expandafter\setuptable\one\endsetuptable + % Need to reset this to 0 after \setuptable. + \global\colcount=0\relax% + % + % This preamble sets up a generic column definition, which will + % be used as many times as user calls for columns. + % \vtop will set a single line and will also let text wrap and + % continue for many paragraphs if desired. + \halign\bgroup&\global\advance\colcount by 1\relax% + \vtop{\hsize=\expandafter\csname col\the\colcount\endcsname + % In order to keep entries from bumping into each other + % we will add a \leftskip of \spacebetweencols to all columns after + % the first one. + % If a template has been used, we will add \spacebetweencols + % to the width of each template entry. + % If user has set preamble in terms of percent of \hsize + % we will use that dimension as the width of the column, and + % the \leftskip will keep entries from bumping into each other. + % Table will start at left margin and final column will justify at + % right margin. + \ifnum\colcount=1 + \else + \ifsetpercent + \else + % If user has set preamble in terms of percent of \hsize + % we will advance \hsize by \spacebetweencols + \advance\hsize by \spacebetweencols + \fi + % In either case we will make \leftskip=\spacebetweencols: + \leftskip=\spacebetweencols + \fi + \noindent##}\cr% + % \everycr will reset column counter, \colcount, at the end of + % each line. Every column entry will cause \colcount to advance by one. + % The table preamble + % looks at the current \colcount to find the correct column width. + \global\everycr{\noalign{\nointerlineskip\vskip\spacebetweenlines + \filbreak%% keeps underfull box messages off when table breaks over pages. + \global\colcount=0\relax}}} + \message{indexing,} % Index generation facilities *************** *** 1859,1863 **** --- 2039,2049 ---- \let\indexbackslash=0 %overridden during \printindex. + % workhorse for all \fooindexes + % #1 is name of index, #2 is stuff to put there \def\doind #1#2{% + % Put the index entry in the margin if desired. + \ifx\SETmarginindex\relax\else% + \insert\margin{\hbox{\vrule height8pt depth3pt width0pt #2}}% + \fi% {\count10=\lastpenalty % {\indexdummies % Must do this here, since \bf, etc expand at this stage *************** *** 2295,2299 **** \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 ! \global\advance \chapno by 1 \message{Chapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% --- 2481,2485 ---- \def\chapterzzz #1{\seccheck{chapter}% \secno=0 \subsecno=0 \subsubsecno=0 ! \global\advance \chapno by 1 \message{\putwordChapter \the\chapno}% \chapmacro {#1}{\the\chapno}% \gdef\thissection{#1}% *************** *** 2682,2685 **** --- 2868,2872 ---- \begingroup % Set up to handle contents files properly. \catcode`\\=0 \catcode`\{=1 \catcode`\}=2 \catcode`\@=11 + \catcode`\^=7 % to see ^^e4 as \"a etc. juha@piuha.ydi.vtt.fi \raggedbottom % Worry more about breakpoints than the bottom. \advance\hsize by -\contentsrightmargin % Don't use the full line length. *************** *** 3399,3403 **** \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index ! \begingroup\defname {\code{#1} #2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody --- 3586,3590 ---- \def\deftypefunheaderx #1#2 #3\relax{% \doind {fn}{\code{#2}}% Make entry in function index ! \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Function}% \deftypefunargs {#3}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody *************** *** 3408,3411 **** --- 3595,3602 ---- \def\deftypefn{\defmethparsebody\Edeftypefn\deftypefnx\deftypefnheader} + % \defheaderxcond#1\relax$$$ + % puts #1 in @code, followed by a space, but does nothing if #1 is null. + \def\defheaderxcond#1#2$$${\ifx#1\relax\else\code{#1#2} \fi} + % #1 is the classification. #2 is the data type. #3 is the name and args. \def\deftypefnheader #1#2#3{\deftypefnheaderx{#1}{#2}#3 \relax} *************** *** 3416,3420 **** \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working ! \defname {\code{#2} #3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody --- 3607,3611 ---- \normalparens % notably, turn off `&' magic, which prevents % at least some C++ text from working ! \defname {\defheaderxcond#2\relax$$$#3}{#1}% \deftypefunargs {#4}\endgroup % \catcode 61=\other % Turn off change made in \defparsebody *************** *** 3544,3548 **** \def\deftypevarheader #1#2{% \doind {vr}{\code{#2}}% Make entry in variables index ! \begingroup\defname {\code{#1} #2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 --- 3735,3739 ---- \def\deftypevarheader #1#2{% \doind {vr}{\code{#2}}% Make entry in variables index ! \begingroup\defname {\defheaderxcond#1\relax$$$#2}{Variable}% \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 *************** *** 3554,3558 **** \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}% ! \begingroup\defname {\code{#2} #3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 --- 3745,3749 ---- \def\deftypevrheader #1#2#3{\doind {vr}{\code{#3}}% ! \begingroup\defname {\defheaderxcond#2\relax$$$#3}{#1} \interlinepenalty=10000 \endgraf\penalty 10000\vskip -\parskip\penalty 10000 *************** *** 3671,3675 **** % Use \turnoffactive so that punctuation chars such as underscore % work in node names. ! \def\dosetq #1#2{{\let\folio=0 \turnoffactive% \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} --- 3862,3866 ---- % Use \turnoffactive so that punctuation chars such as underscore % work in node names. ! \def\dosetq #1#2{{\let\folio=0 \turnoffactive \auxhat% \edef\next{\write\auxfile{\internalsetq {#1}{#2}}}% \next}} *************** *** 3810,3813 **** --- 4001,4005 ---- \catcode `\%=\other \catcode `\'=0 + \catcode`\^=7 % to make ^^e4 etc usable in xref tags \catcode `\\=\other \openin 1 \jobname.aux *************** *** 4027,4030 **** --- 4219,4244 ---- } + % Allow control of the text dimensions. Parameters in order: textheight; + % textwidth; \voffset; \hoffset (!); binding offset. All require a dimension; + % header is additional; added length extends the bottom of the page. + + \def\changepagesizes#1#2#3#4#5{ + \global\vsize= #1 + \advance\vsize by \topskip + \global\voffset= #3 + \global\hsize= #2 + \global\outerhsize=\hsize + \global\advance\outerhsize by 0.5in + \global\outervsize=\vsize + \global\advance\outervsize by 0.6in + \global\pagewidth=\hsize + \global\pageheight=\vsize + \global\normaloffset= #4 + \global\bindingoffset= #5} + + % This layout is compatible with Latex on A4 paper. + + \def\afourlatex{\changepagesizes{22cm}{15cm}{7mm}{4.6mm}{5mm}} + % Define macros to output various characters with catcode for normal text. \catcode`\"=\other *************** *** 4068,4071 **** --- 4282,4286 ---- \chardef\hat=`\^ \catcode`\^=\active + \def\auxhat{\def^{'hat}} \def^{{\tt \hat}} diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/tm.texi gcc-2.6.1/tm.texi *** gcc-2.6.0/tm.texi Wed Jul 13 08:34:11 1994 --- gcc-2.6.1/tm.texi Sun Oct 30 04:53:20 1994 *************** *** 1,3 **** ! @c Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. --- 1,3 ---- ! @c Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, Inc. @c This is part of the GCC manual. @c For copying conditions, see the file gcc.texi. *************** *** 1812,1822 **** of class @var{class} needed to hold a value of mode @var{mode}. ! This is closely related to the macro @code{HARD_REGNO_NREGS}. ! In fact, the value of the macro @code{CLASS_MAX_NREGS (@var{class}, @var{mode})} ! should be the maximum value of @code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} ! for all @var{regno} values in the class @var{class}. This macro helps control the handling of multiple-word values in the reload pass. @end table --- 1812,1834 ---- of class @var{class} needed to hold a value of mode @var{mode}. ! This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact, ! the value of the macro @code{CLASS_MAX_NREGS (@var{class}, @var{mode})} ! should be the maximum value of @code{HARD_REGNO_NREGS (@var{regno}, ! @var{mode})} for all @var{regno} values in the class @var{class}. This macro helps control the handling of multiple-word values in the reload pass. + + @item CLASS_CANNOT_CHANGE_SIZE + If defined, a C expression for a class that contains registers which the + compiler must always access in a mode that is the same size as the mode + in which it loaded the register, unless neither mode is integral. + + For the example, loading 32-bit integer or floating-point objects into + floating-point registers on the Alpha extends them to 64-bits. + Therefore loading a 64-bit object and then storing it as a 32-bit object + does not store the low-order 32-bits, as would be the case for a normal + register. Therefore, @file{alpha.h} defines this macro as + @code{FLOAT_REGS}. @end table *************** *** 4921,4924 **** --- 4933,4951 ---- initialization functions. + @item HAS_INIT_SECTION + @findex HAS_INIT_SECTION + If defined, @code{main} will not call @code{__main} as described above. + This macro should be defined for systems that control the contents of the + init section on a symbol-by-symbol basis, such as OSF/1, and should not + be defined explicitly for systems that support + @code{INIT_SECTION_ASM_OP}. + + @item INVOKE__main + @findex INVOKE__main + If defined, @code{main} will call @code{__main} despite the presence of + @code{INIT_SECTION_ASM_OP}. This macro should be defined for systems + where the init section is not actually run automatically, but is still + useful for collecting the lists of constructors and destructors. + @item ASM_OUTPUT_CONSTRUCTOR (@var{stream}, @var{name}) @findex ASM_OUTPUT_CONSTRUCTOR *************** *** 4963,4972 **** @code{collect2} can assume this format and scan object files directly for dynamic constructor/destructor functions. - @end table - - These macros are effective only in a native compiler; @code{collect2} as - part of a cross compiler always uses @code{nm}. - @table @code @findex REAL_NM_FILE_NAME @item REAL_NM_FILE_NAME --- 4990,4994 ---- *************** *** 4976,4979 **** --- 4998,5004 ---- @end table + These macros are effective only in a native compiler; @code{collect2} as + part of a cross compiler always uses @code{nm} for the target machine. + @node Instruction Output @subsection Output of Assembler Instructions *************** *** 5458,5461 **** --- 5483,5492 ---- that block. Normally, in DBX format, the @code{N_LBRAC} symbol comes first. + + @findex DBX_BLOCKS_FUNCTION_RELATIVE + @item DBX_BLOCKS_FUNCTION_RELATIVE + Define this macro if the value of a symbol describing the scope of a + block (@code{N_LBRAC} or @code{N_RBRAC}) should be relative to the start + of the enclosing function. Normally, GNU C uses an absolute address. @end table diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/toplev.c gcc-2.6.1/toplev.c *** gcc-2.6.0/toplev.c Wed Jul 6 22:58:55 1994 --- gcc-2.6.1/toplev.c Tue Oct 25 16:09:12 1994 *************** *** 37,40 **** --- 37,41 ---- #include + #ifndef WINNT #ifdef USG #undef FLOAT *************** *** 51,54 **** --- 52,56 ---- #endif #endif + #endif #include "input.h" *************** *** 431,439 **** int flag_keep_inline_functions; ! /* Nonzero means that functions declared `inline' will be treated ! as `static'. Prevents generation of zillions of copies of unused ! static inline functions; instead, `inlines' are written out ! only when actually used. Used in conjunction with -g. Also ! does the right thing with #pragma interface. */ int flag_no_inline; --- 433,437 ---- int flag_keep_inline_functions; ! /* Nonzero means that functions will not be inlined. */ int flag_no_inline; *************** *** 641,644 **** --- 639,644 ---- "-+e1", "-+e2", + "-faccess-control", + "-fno-access-control", "-fall-virtual", "-fno-all-virtual", *************** *** 708,711 **** --- 708,715 ---- "-Wextern-inline", "-Wno-extern-inline", + "-Wreorder", + "-Wno-reorder", + "-Wsynth", + "-Wno-synth", /* these are for obj c */ *************** *** 850,853 **** --- 854,860 ---- get_run_time () { + #ifdef WINNT + return 0; + #else #ifdef USG struct tms tms; *************** *** 882,885 **** --- 889,893 ---- #endif #endif + #endif } *************** *** 943,952 **** } ! /* Called to give a better error message when we don't have an insn to match ! what we are looking for or if the insn's constraints aren't satisfied, ! rather than just calling abort(). */ void ! fatal_insn_not_found (insn) rtx insn; { --- 951,960 ---- } ! /* Called to give a better error message for a bad insn rather than ! just calling abort(). */ void ! fatal_insn (message, insn) ! char *message; rtx insn; { *************** *** 953,960 **** if (!output_bytecode) { ! if (INSN_CODE (insn) < 0) ! error ("internal error--unrecognizable insn:"); ! else ! error ("internal error--insn does not satisfy its constraints:"); debug_rtx (insn); } --- 961,965 ---- if (!output_bytecode) { ! error (message); debug_rtx (insn); } *************** *** 994,997 **** --- 999,1016 ---- } + /* Called to give a better error message when we don't have an insn to match + what we are looking for or if the insn's constraints aren't satisfied, + rather than just calling abort(). */ + + void + fatal_insn_not_found (insn) + rtx insn; + { + if (INSN_CODE (insn) < 0) + fatal_insn ("internal error--unrecognizable insn:", insn); + else + fatal_insn ("internal error--insn does not satisfy its constraints:", insn); + } + /* This is the default decl_printable_name function. */ *************** *** 2720,2723 **** --- 2739,2743 ---- warning_with_decl (decl, lose); DECL_INLINE (decl) = 0; + DECL_ABSTRACT_ORIGIN (decl) = 0; /* Don't really compile an extern inline function. If we can't make it inline, pretend *************** *** 3928,3933 **** compile_file (filename); ! #ifndef OS2 ! #ifndef VMS if (flag_print_mem) { --- 3948,3952 ---- compile_file (filename); ! #if !defined(OS2) && !defined(VMS) && !defined(WINNT) if (flag_print_mem) { *************** *** 3947,3952 **** #endif /* not USG */ } ! #endif /* not VMS */ ! #endif /* not OS2 */ if (errorcount) --- 3966,3970 ---- #endif /* not USG */ } ! #endif /* not OS2 and not VMS and not WINNT */ if (errorcount) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/tree.c gcc-2.6.1/tree.c *** gcc-2.6.0/tree.c Thu Jul 14 13:02:27 1994 --- gcc-2.6.1/tree.c Sun Oct 2 19:14:00 1994 *************** *** 320,325 **** void ! save_tree_status (p) struct function *p; { p->all_types_permanent = all_types_permanent; --- 320,326 ---- void ! save_tree_status (p, toplevel) struct function *p; + int toplevel; { p->all_types_permanent = all_types_permanent; *************** *** 335,342 **** p->rtl_obstack = rtl_obstack; ! /* Objects that need to be saved in this function can be in the nonsaved ! obstack of the enclosing function since they can't possibly be needed ! once it has returned. */ ! function_maybepermanent_obstack = function_obstack; function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack)); --- 336,348 ---- p->rtl_obstack = rtl_obstack; ! if (! toplevel) ! { ! /* Objects that need to be saved in this function can be in the nonsaved ! obstack of the enclosing function since they can't possibly be needed ! once it has returned. */ ! function_maybepermanent_obstack = function_obstack; ! maybepermanent_firstobj ! = (char *) obstack_finish (function_maybepermanent_obstack); ! } function_obstack = (struct obstack *) xmalloc (sizeof (struct obstack)); *************** *** 349,354 **** momentary_firstobj = (char *) obstack_finish (&momentary_obstack); momentary_function_firstobj = momentary_firstobj; - maybepermanent_firstobj - = (char *) obstack_finish (function_maybepermanent_obstack); } --- 355,358 ---- *************** *** 357,362 **** void ! restore_tree_status (p) struct function *p; { all_types_permanent = p->all_types_permanent; --- 361,367 ---- void ! restore_tree_status (p, toplevel) struct function *p; + int toplevel; { all_types_permanent = p->all_types_permanent; *************** *** 365,376 **** obstack_free (&momentary_obstack, momentary_function_firstobj); ! /* Free saveable storage used by the function just compiled and not ! saved. ! CAUTION: This is in function_obstack of the containing function. So ! we must be sure that we never allocate from that obstack during ! the compilation of a nested function if we expect it to survive past the ! nested function's end. */ ! obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); obstack_free (function_obstack, 0); --- 370,384 ---- obstack_free (&momentary_obstack, momentary_function_firstobj); ! if (! toplevel) ! { ! /* Free saveable storage used by the function just compiled and not ! saved. ! CAUTION: This is in function_obstack of the containing function. ! So we must be sure that we never allocate from that obstack during ! the compilation of a nested function if we expect it to survive ! past the nested function's end. */ ! obstack_free (function_maybepermanent_obstack, maybepermanent_firstobj); ! } obstack_free (function_obstack, 0); *************** *** 520,524 **** obstack_free (&temporary_obstack, temporary_firstobj); if (function_end) ! obstack_free (&momentary_obstack, momentary_function_firstobj); else obstack_free (&momentary_obstack, momentary_firstobj); --- 528,535 ---- obstack_free (&temporary_obstack, temporary_firstobj); if (function_end) ! { ! obstack_free (&momentary_obstack, momentary_function_firstobj); ! momentary_firstobj = momentary_function_firstobj; ! } else obstack_free (&momentary_obstack, momentary_firstobj); *************** *** 2354,2357 **** --- 2365,2375 ---- break; + case COMPOUND_EXPR: + result = build_nt (COMPOUND_EXPR, + stabilize_reference_1 (TREE_OPERAND (ref, 0)), + stabilize_reference (TREE_OPERAND (ref, 1))); + break; + + /* If arg isn't a kind of lvalue we recognize, make no change. Caller should recognize the error for an invalid lvalue. */ *************** *** 2793,2809 **** volatilep = !!volatilep; ! /* If not generating auxiliary info, search the chain of variants to see ! if there is already one there just like the one we need to have. If so, ! use that existing one. ! ! We don't do this in the case where we are generating aux info because ! in that case we want each typedef names to get it's own distinct type ! node, even if the type of this new typedef is the same as some other ! (existing) type. */ ! ! if (!flag_gen_aux_info) ! for (t = TYPE_MAIN_VARIANT(type); t; t = TYPE_NEXT_VARIANT (t)) ! if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t)) ! return t; /* We need a new one. */ --- 2811,2822 ---- volatilep = !!volatilep; ! /* Search the chain of variants to see if there is already one there just ! like the one we need to have. If so, use that existing one. We must ! preserve the TYPE_NAME, since there is code that depends on this. */ ! ! for (t = TYPE_MAIN_VARIANT(type); t; t = TYPE_NEXT_VARIANT (t)) ! if (constp == TYPE_READONLY (t) && volatilep == TYPE_VOLATILE (t) ! && TYPE_NAME (t) == TYPE_NAME (type)) ! return t; /* We need a new one. */ *************** *** 2820,2824 **** about TYPE is modified in place. */ ! tree change_main_variant (type, new_main) tree type, new_main; --- 2833,2837 ---- about TYPE is modified in place. */ ! void change_main_variant (type, new_main) tree type, new_main; *************** *** 3055,3059 **** if (cmp < 0) abort (); ! if (cmp == 0) return 0; } --- 3068,3074 ---- if (cmp < 0) abort (); ! if (cmp == 0 ! || TREE_TYPE (TREE_PURPOSE (t1)) ! != TREE_TYPE (TREE_PURPOSE (t2))) return 0; } *************** *** 3844,3848 **** if (TREE_CODE (context) == RECORD_TYPE || TREE_CODE (context) == UNION_TYPE) ! context = TYPE_CONTEXT (context); else if (TREE_CODE (context) == TYPE_DECL) context = DECL_CONTEXT (context); --- 3859,3863 ---- if (TREE_CODE (context) == RECORD_TYPE || TREE_CODE (context) == UNION_TYPE) ! context = NULL_TREE; else if (TREE_CODE (context) == TYPE_DECL) context = DECL_CONTEXT (context); *************** *** 3994,3996 **** --- 4009,4110 ---- return get_identifier (buf); + } + + /* Expand (the constant part of) a SET_TYPE CONTRUCTOR node. + The result is placed in BUFFER (which has length BIT_SIZE), + with one bit in each char ('\000' or '\001'). + + If the constructor is constant, NULL_TREE is returned. + Otherwise, a TREE_LIST of the non-constant elements is emitted. */ + + tree + get_set_constructor_bits (init, buffer, bit_size) + tree init; + char *buffer; + int bit_size; + { + int i; + tree vals; + HOST_WIDE_INT domain_min + = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init)))); + tree non_const_bits = NULL_TREE; + for (i = 0; i < bit_size; i++) + buffer[i] = 0; + + for (vals = TREE_OPERAND (init, 1); + vals != NULL_TREE; vals = TREE_CHAIN (vals)) + { + if (TREE_CODE (TREE_VALUE (vals)) != INTEGER_CST + || (TREE_PURPOSE (vals) != NULL_TREE + && TREE_CODE (TREE_PURPOSE (vals)) != INTEGER_CST)) + non_const_bits = + tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits); + else if (TREE_PURPOSE (vals) != NULL_TREE) + { + /* Set a range of bits to ones. */ + HOST_WIDE_INT lo_index + = TREE_INT_CST_LOW (TREE_PURPOSE (vals)) - domain_min; + HOST_WIDE_INT hi_index + = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min; + if (lo_index < 0 || lo_index >= bit_size + || hi_index < 0 || hi_index >= bit_size) + abort (); + for ( ; lo_index <= hi_index; lo_index++) + buffer[lo_index] = 1; + } + else + { + /* Set a single bit to one. */ + HOST_WIDE_INT index + = TREE_INT_CST_LOW (TREE_VALUE (vals)) - domain_min; + if (index < 0 || index >= bit_size) + { + error ("invalid initializer for bit string"); + return NULL_TREE; + } + buffer[index] = 1; + } + } + return non_const_bits; + } + + /* Expand (the constant part of) a SET_TYPE CONTRUCTOR node. + The result is placed in BUFFER (which is an array of WD_SIZE + words). TYPE_ALIGN bits are stored in each element of BUFFER. + If the constructor is constant, NULL_TREE is returned. + Otherwise, a TREE_LIST of the non-constant elements is emitted. */ + + tree + get_set_constructor_words (init, buffer, wd_size) + tree init; + HOST_WIDE_INT *buffer; + int wd_size; + { + int i; + tree vals = TREE_OPERAND (init, 1); + int set_word_size = TYPE_ALIGN (TREE_TYPE (init)); + int bit_size = wd_size * set_word_size; + int bit_pos = 0; + HOST_WIDE_INT *wordp = buffer; + char *bit_buffer = (char*)alloca(bit_size); + tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size); + + for (i = 0; i < wd_size; i++) + buffer[i] = 0; + + for (i = 0; i < bit_size; i++) + { + if (bit_buffer[i]) + { + #if BITS_BIG_ENDIAN + *wordp |= (1 << (set_word_size - 1 - bit_pos)); + #else + *wordp |= 1 << bit_pos; + #endif + } + bit_pos++; + if (bit_pos >= set_word_size) + bit_pos = 0, wordp++; + } + return non_const_bits; } diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/tree.h gcc-2.6.1/tree.h *** gcc-2.6.0/tree.h Wed Jul 13 07:03:13 1994 --- gcc-2.6.1/tree.h Thu Sep 8 14:25:41 1994 *************** *** 620,623 **** --- 620,627 ---- #define TYPE_NEEDS_CONSTRUCTING(NODE) ((NODE)->type.needs_constructing_flag) + /* Indicates that objects of this type (a UNION_TYPE), should be passed + the same way that the first union alternative would be passed. */ + #define TYPE_TRANSPARENT_UNION(NODE) ((NODE)->type.transparent_union_flag) + struct tree_type { *************** *** 638,641 **** --- 642,646 ---- unsigned no_force_blk_flag : 1; unsigned needs_constructing_flag : 1; + unsigned transparent_union_flag : 1; unsigned lang_flag_0 : 1; unsigned lang_flag_1 : 1; *************** *** 645,649 **** unsigned lang_flag_5 : 1; unsigned lang_flag_6 : 1; ! /* room for 6 more bits */ unsigned int align; --- 650,654 ---- unsigned lang_flag_5 : 1; unsigned lang_flag_6 : 1; ! /* room for 5 more bits */ unsigned int align; *************** *** 929,932 **** --- 934,942 ---- #define DECL_DEFER_OUTPUT(NODE) ((NODE)->decl.defer_output) + /* Used in PARM_DECLs whose type are unions to indicate that the + argument should be passed in the same way that the first union + alternative would be passed. */ + #define DECL_TRANSPARENT_UNION(NODE) ((NODE)->decl.transparent_union) + /* Additional flags for language-specific uses. */ #define DECL_LANG_FLAG_0(NODE) ((NODE)->decl.lang_flag_0) *************** *** 964,968 **** unsigned common_flag : 1; unsigned defer_output : 1; ! /* room for five more */ unsigned lang_flag_0 : 1; --- 974,979 ---- unsigned common_flag : 1; unsigned defer_output : 1; ! unsigned transparent_union : 1; ! /* room for four more */ unsigned lang_flag_0 : 1; *************** *** 1239,1242 **** --- 1250,1259 ---- extern tree sizetype; + /* If nonzero, an upper limit on alignment of structure fields, in bits. */ + extern int maximum_field_alignment; + + /* If non-zero, the alignment of a bitsting or (power-)set value, in bits. */ + extern int set_alignment; + /* Concatenate two lists (chains of TREE_LIST nodes) X and Y by making the last node in X point to Y. *************** *** 1482,1485 **** --- 1499,1505 ---- /* In tree.c */ extern char *perm_calloc PROTO((int, long)); + extern tree get_set_constructor_bits PROTO((tree, char*, int)); + extern tree get_set_constructor_words PROTO((tree, + HOST_WIDE_INT*, int)); /* In stmt.c */ diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/unroll.c gcc-2.6.1/unroll.c *** gcc-2.6.0/unroll.c Sat Jul 2 21:13:26 1994 --- gcc-2.6.1/unroll.c Thu Oct 20 16:28:42 1994 *************** *** 1336,1339 **** --- 1336,1355 ---- if (GET_CODE (increment) == LO_SUM) increment = XEXP (increment, 1); + else if (GET_CODE (increment) == IOR) + { + /* The rs6000 port loads some constants with IOR. */ + rtx second_part = XEXP (increment, 1); + + src_insn = PREV_INSN (src_insn); + increment = SET_SRC (PATTERN (src_insn)); + /* Don't need the last insn anymore. */ + delete_insn (get_last_insn ()); + + if (GET_CODE (second_part) != CONST_INT + || GET_CODE (increment) != CONST_INT) + abort (); + + increment = GEN_INT (INTVAL (increment) | INTVAL (second_part)); + } if (GET_CODE (increment) != CONST_INT) *************** *** 1340,1344 **** abort (); ! /* The insn loading the constant into a register is not longer needed, so delete it. */ delete_insn (get_last_insn ()); --- 1356,1360 ---- abort (); ! /* The insn loading the constant into a register is no longer needed, so delete it. */ delete_insn (get_last_insn ()); *************** *** 1731,1740 **** original jump label case to fall_through. */ ! if (! invert_exp (pattern, copy) ! || ! redirect_exp (&pattern, ! map->label_map[CODE_LABEL_NUMBER ! (JUMP_LABEL (insn))], ! exit_label, copy)) ! abort (); } --- 1747,1776 ---- original jump label case to fall_through. */ ! if (invert_exp (pattern, copy)) ! { ! if (! redirect_exp (&pattern, ! map->label_map[CODE_LABEL_NUMBER ! (JUMP_LABEL (insn))], ! exit_label, copy)) ! abort (); ! } ! else ! { ! rtx jmp; ! rtx lab = gen_label_rtx (); ! /* Can't do it by reversing the jump (probably becasue we ! couln't reverse the conditions), so emit a new ! jump_insn after COPY, and redirect the jump around ! that. */ ! jmp = emit_jump_insn_after (gen_jump (exit_label), copy); ! jmp = emit_barrier_after (jmp); ! emit_label_after (lab, jmp); ! LABEL_NUSES (lab) = 0; ! if (! redirect_exp (&pattern, ! map->label_map[CODE_LABEL_NUMBER ! (JUMP_LABEL (insn))], ! lab, copy)) ! abort (); ! } } *************** *** 3078,3082 **** loop_iteration_var = 0; ! last_loop_insn = prev_nonnote_insn (loop_end); comparison = get_condition_for_loop (last_loop_insn); --- 3114,3122 ---- loop_iteration_var = 0; ! /* We used to use pren_nonnote_insn here, but that fails because it might ! accidentally get the branch for a contained loop if the branch for this ! loop was deleted. We can only trust branches immediately before the ! loop_end. */ ! last_loop_insn = PREV_INSN (loop_end); comparison = get_condition_for_loop (last_loop_insn); *************** *** 3116,3141 **** return 0; - if (increment == 0) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Increment value can't be calculated.\n"); - return 0; - } - if (GET_CODE (increment) != CONST_INT) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Increment value not constant.\n"); - return 0; - } - if (GET_CODE (initial_value) != CONST_INT) - { - if (loop_dump_stream) - fprintf (loop_dump_stream, - "Loop unrolling: Initial value not constant.\n"); - return 0; - } - /* If the comparison value is an invariant register, then try to find its value from the insns before the start of the loop. */ --- 3156,3159 ---- *************** *** 3186,3190 **** loop_final_value = final_value; ! if (final_value == 0) { if (loop_dump_stream) --- 3204,3229 ---- loop_final_value = final_value; ! if (increment == 0) ! { ! if (loop_dump_stream) ! fprintf (loop_dump_stream, ! "Loop unrolling: Increment value can't be calculated.\n"); ! return 0; ! } ! else if (GET_CODE (increment) != CONST_INT) ! { ! if (loop_dump_stream) ! fprintf (loop_dump_stream, ! "Loop unrolling: Increment value not constant.\n"); ! return 0; ! } ! else if (GET_CODE (initial_value) != CONST_INT) ! { ! if (loop_dump_stream) ! fprintf (loop_dump_stream, ! "Loop unrolling: Initial value not constant.\n"); ! return 0; ! } ! else if (final_value == 0) { if (loop_dump_stream) diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/varasm.c gcc-2.6.1/varasm.c *** gcc-2.6.0/varasm.c Mon Jul 11 19:25:28 1994 --- gcc-2.6.1/varasm.c Fri Jul 29 19:03:40 1994 *************** *** 1359,1366 **** } ! /* Output text storage for constructor CONSTR. Returns rtx of ! storage. */ ! rtx bc_output_constructor (constr) tree constr; --- 1359,1365 ---- } ! /* Output text storage for constructor CONSTR. */ ! void bc_output_constructor (constr) tree constr; diff -rc2P -x c-parse.y -x c-parse.c -x c-parse.h -x c-gperf.h -x cexp.c -x bi-parser.c -x objc-parse.y -x objc-parse.c -x TAGS -x gcc.?? -x gcc.??s -x gcc.aux -x gcc.info* -x cpp.?? -x cpp.??s -x cpp.aux -x cpp.info* -x cp/parse.c -x cp/parse.h gcc-2.6.0/version.c gcc-2.6.1/version.c *** gcc-2.6.0/version.c Wed Jul 13 18:33:17 1994 --- gcc-2.6.1/version.c Sun Oct 30 08:05:06 1994 *************** *** 1 **** ! char *version_string = "2.6.0"; --- 1 ---- ! char *version_string = "2.6.1";